You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
898 lines
28 KiB
898 lines
28 KiB
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1995 - 1996
|
|
//
|
|
// File: turlread.cpp
|
|
//
|
|
// Contents: Read the specified URL using the wininet APIs
|
|
//
|
|
// See Usage() for a list of test options.
|
|
//
|
|
//
|
|
// Functions: main
|
|
//
|
|
// History: 26-Feb-96 philh created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <windows.h>
|
|
#include <assert.h>
|
|
#include <wininet.h>
|
|
|
|
#ifndef MAX_CACHE_ENTRY_INFO_SIZE
|
|
# include <winineti.h>
|
|
#endif
|
|
|
|
#include <sensapi.h>
|
|
|
|
#include "wincrypt.h"
|
|
#include "crypthlp.h"
|
|
#include "cryptnet.h"
|
|
#include "certtest.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include <memory.h>
|
|
#include <time.h>
|
|
|
|
// Fix for SP4, where ICU_BROWSER_MODE isn't defined
|
|
#ifndef ICU_BROWSER_MODE
|
|
#define ICU_BROWSER_MODE ICU_ENCODE_SPACES_ONLY
|
|
#endif
|
|
|
|
static void Usage(void)
|
|
{
|
|
printf("Usage: turlread [options] <URL>\n");
|
|
printf("Options are:\n");
|
|
printf(" -d - Delete cached URL\n");
|
|
printf(" -i - Get cached URL information\n");
|
|
printf(" -o - Offline only\n");
|
|
printf(" -w - Wire only\n");
|
|
printf(" -cBrowser - Canonicalize => Browser (default)\n");
|
|
printf(" -cNone - Canonicalize => None\n");
|
|
printf(" -cSpaces - Canonicalize => Spaces\n");
|
|
printf(" -cAll - Canonicalize => All\n");
|
|
printf(" -U - Unicode\n");
|
|
printf(" -s - Get internet state\n");
|
|
printf(" -n - Get host Name from URL\n");
|
|
printf(" -S<number> - SyncTime delta seconds\n");
|
|
printf(" -h - This message\n");
|
|
printf("\n");
|
|
}
|
|
|
|
static void DisplayCacheEntryInfoA(
|
|
LPSTR pszUrl
|
|
)
|
|
{
|
|
BOOL fResult;
|
|
|
|
DWORD cbCachEntryInfo;
|
|
BYTE rgbCachEntryInfo[MAX_CACHE_ENTRY_INFO_SIZE];
|
|
LPINTERNET_CACHE_ENTRY_INFOA pCacheEntryInfo =
|
|
(LPINTERNET_CACHE_ENTRY_INFOA) &rgbCachEntryInfo[0];
|
|
|
|
DWORD dwEntryType;
|
|
|
|
cbCachEntryInfo = sizeof(rgbCachEntryInfo);
|
|
fResult = GetUrlCacheEntryInfoA(
|
|
pszUrl,
|
|
pCacheEntryInfo,
|
|
&cbCachEntryInfo);
|
|
if (!fResult)
|
|
PrintLastError("GetUrlCachEntryInfo");
|
|
else if (cbCachEntryInfo == 0)
|
|
printf("GetUrlCachEntryInfo returned no bytes\n");
|
|
else {
|
|
printf("UrlCachEntryInfo (%d bytes)::\n", cbCachEntryInfo);
|
|
printf(" StructSize: %d\n", pCacheEntryInfo->dwStructSize);
|
|
printf(" SourceUrlName: %s\n", pCacheEntryInfo->lpszSourceUrlName);
|
|
printf(" LocalFileName: %s\n", pCacheEntryInfo->lpszLocalFileName);
|
|
printf(" FileExtension: %s\n", pCacheEntryInfo->lpszFileExtension);
|
|
|
|
dwEntryType = pCacheEntryInfo->CacheEntryType;
|
|
printf(" CacheEntryType: 0x%x", dwEntryType);
|
|
if (dwEntryType & NORMAL_CACHE_ENTRY)
|
|
printf(" NORMAL");
|
|
if (dwEntryType & STICKY_CACHE_ENTRY)
|
|
printf(" STICKY");
|
|
if (dwEntryType & EDITED_CACHE_ENTRY)
|
|
printf(" EDITED");
|
|
if (dwEntryType & TRACK_OFFLINE_CACHE_ENTRY)
|
|
printf(" TRACK_OFFLINE");
|
|
if (dwEntryType & TRACK_ONLINE_CACHE_ENTRY)
|
|
printf(" TRACK_ONLINE");
|
|
if (dwEntryType & SPARSE_CACHE_ENTRY)
|
|
printf(" SPARSE");
|
|
if (dwEntryType & COOKIE_CACHE_ENTRY)
|
|
printf(" COOKIE");
|
|
if (dwEntryType & URLHISTORY_CACHE_ENTRY)
|
|
printf(" URLHISTORY");
|
|
printf("\n");
|
|
|
|
printf(" UseCount: %d\n", pCacheEntryInfo->dwUseCount);
|
|
printf(" HitRate: %d\n", pCacheEntryInfo->dwHitRate);
|
|
printf(" FileSize: %d\n", pCacheEntryInfo->dwSizeLow);
|
|
printf(" LastModifiedTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->LastModifiedTime));
|
|
printf(" ExpireTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->ExpireTime));
|
|
printf(" LastAccessTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->LastAccessTime));
|
|
printf(" LastSyncTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->LastSyncTime));
|
|
printf(" ExemptDelta:: %d\n", pCacheEntryInfo->dwExemptDelta);
|
|
|
|
if (pCacheEntryInfo->dwHeaderInfoSize) {
|
|
printf(" HeaderInfo::\n");
|
|
PrintBytes(" ", (BYTE *) pCacheEntryInfo->lpHeaderInfo,
|
|
pCacheEntryInfo->dwHeaderInfoSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void DisplayCacheEntryInfoW(
|
|
LPWSTR pwszUrl
|
|
)
|
|
{
|
|
BOOL fResult;
|
|
char szUrl[_MAX_PATH + 1];
|
|
|
|
DWORD cbCachEntryInfo;
|
|
BYTE rgbCachEntryInfo[MAX_CACHE_ENTRY_INFO_SIZE];
|
|
LPINTERNET_CACHE_ENTRY_INFOW pCacheEntryInfo =
|
|
(LPINTERNET_CACHE_ENTRY_INFOW) &rgbCachEntryInfo[0];
|
|
|
|
WideCharToMultiByte(
|
|
CP_ACP,
|
|
0, // dwFlags
|
|
pwszUrl,
|
|
-1, // Null terminated
|
|
szUrl,
|
|
sizeof(szUrl),
|
|
NULL, // lpDefaultChar
|
|
NULL // lpfUsedDefaultChar
|
|
);
|
|
|
|
cbCachEntryInfo = sizeof(rgbCachEntryInfo);
|
|
#if 0
|
|
// BUG the signature of the following API was changed around 1804.
|
|
// Changed from szUrl to wszUrl
|
|
|
|
fResult = GetUrlCacheEntryInfoW(
|
|
szUrl,
|
|
pCacheEntryInfo,
|
|
&cbCachEntryInfo);
|
|
#else
|
|
fResult = FALSE;
|
|
SetLastError((DWORD) E_NOTIMPL);
|
|
#endif
|
|
if (!fResult)
|
|
PrintLastError("GetUrlCachEntryInfo");
|
|
else if (cbCachEntryInfo == 0)
|
|
printf("GetUrlCachEntryInfo returned no bytes\n");
|
|
else {
|
|
printf("UrlCachEntryInfo (%d bytes)::\n", cbCachEntryInfo);
|
|
printf(" SourceUrlName: %s\n", pCacheEntryInfo->lpszSourceUrlName);
|
|
printf(" LocalFileName: %S\n", pCacheEntryInfo->lpszLocalFileName);
|
|
printf(" UseCount: %d\n", pCacheEntryInfo->dwUseCount);
|
|
printf(" HitRate: %d\n", pCacheEntryInfo->dwHitRate);
|
|
printf(" FileSize: %d\n", pCacheEntryInfo->dwSizeLow);
|
|
printf(" LastModifiedTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->LastModifiedTime));
|
|
printf(" ExpireTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->ExpireTime));
|
|
printf(" LastAccessTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->LastAccessTime));
|
|
printf(" LastSyncTime:: %s\n",
|
|
FileTimeText(&pCacheEntryInfo->LastSyncTime));
|
|
}
|
|
}
|
|
|
|
|
|
static void SetSyncTime(
|
|
LPSTR pszUrl,
|
|
LONG lDeltaSeconds
|
|
)
|
|
{
|
|
DWORD dwFieldControl = CACHE_ENTRY_SYNCTIME_FC;
|
|
INTERNET_CACHE_ENTRY_INFOA CacheEntry;
|
|
FILETIME CurrentTime;
|
|
BOOL fResult;
|
|
|
|
memset(&CacheEntry, 0, sizeof(CacheEntry));
|
|
CacheEntry.dwStructSize = sizeof(CacheEntry);
|
|
|
|
GetSystemTimeAsFileTime(&CurrentTime);
|
|
|
|
if (lDeltaSeconds >= 0)
|
|
I_CryptIncrementFileTimeBySeconds(
|
|
&CurrentTime,
|
|
(DWORD) lDeltaSeconds,
|
|
&CacheEntry.LastSyncTime
|
|
);
|
|
else
|
|
I_CryptDecrementFileTimeBySeconds(
|
|
&CurrentTime,
|
|
(DWORD) -lDeltaSeconds,
|
|
&CacheEntry.LastSyncTime
|
|
);
|
|
|
|
fResult = SetUrlCacheEntryInfoA( pszUrl, &CacheEntry, dwFieldControl );
|
|
|
|
if (!fResult)
|
|
PrintLastError("SetUrlCacheEntryInfoA");
|
|
}
|
|
|
|
#if 0
|
|
static void DisplayDestinationReachableA(
|
|
LPSTR pszUrl
|
|
)
|
|
{
|
|
BOOL fResult;
|
|
QOCINFO qocInfo;
|
|
|
|
memset(&qocInfo, 0, sizeof(qocInfo));
|
|
qocInfo.dwSize = sizeof(qocInfo);
|
|
|
|
fResult = IsDestinationReachableA(pszUrl, &qocInfo);
|
|
|
|
if (fResult) {
|
|
printf("Url is reachable, InSpeed: %d OutSpeed: %d dwFlags: 0x%x\n",
|
|
qocInfo.dwInSpeed, qocInfo.dwOutSpeed, qocInfo.dwFlags);
|
|
} else
|
|
PrintLastError("IsDestinationReachable");
|
|
}
|
|
#endif
|
|
|
|
static void ReadUrl(
|
|
HINTERNET hInternetFile
|
|
)
|
|
{
|
|
BOOL fResult;
|
|
DWORD cb;
|
|
DWORD cbTotal;
|
|
|
|
cb = 0;
|
|
fResult = InternetQueryDataAvailable(
|
|
hInternetFile,
|
|
&cb,
|
|
0, // dwFlags
|
|
0 // dwContext
|
|
);
|
|
if (!fResult)
|
|
PrintLastError("InternetQueryDataAvailable");
|
|
else
|
|
printf("NumberOfBytesAvailable: %d\n", cb);
|
|
|
|
cbTotal = 0;
|
|
while (TRUE) {
|
|
BYTE rgb[512];
|
|
memset(rgb, 0, sizeof(rgb));
|
|
DWORD cbRead = 0;
|
|
|
|
fResult = InternetReadFile(
|
|
hInternetFile,
|
|
rgb,
|
|
sizeof(rgb),
|
|
&cbRead);
|
|
|
|
if (cbRead) {
|
|
cbTotal += cbRead;
|
|
if (!fResult)
|
|
PrintLastError("InternetReadFile(cbRead != 0)");
|
|
printf("Bytes read from URL::\n");
|
|
PrintBytes(" ", rgb, cbRead);
|
|
} else {
|
|
if (!fResult)
|
|
PrintLastError("InternetReadFile(cbRead == 0)");
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
printf("Total number of bytes read: %d\n", cbTotal);
|
|
}
|
|
|
|
static void OfflineUrlA(
|
|
LPSTR pszUrl
|
|
)
|
|
{
|
|
HINTERNET hInternetSession = NULL;
|
|
HINTERNET hInternetFile = NULL;
|
|
DWORD dwFlags;
|
|
|
|
printf("**** OFFLINE ****\n");
|
|
dwFlags = INTERNET_FLAG_OFFLINE;
|
|
hInternetSession = InternetOpenA(
|
|
"CRL Agent", // lpszAgent
|
|
INTERNET_OPEN_TYPE_PRECONFIG, // dwAccessType
|
|
NULL, // lpszProxy
|
|
NULL, // lpszProxyBypass
|
|
dwFlags
|
|
);
|
|
if (NULL == hInternetSession) {
|
|
PrintLastError("InternetOpen");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
|
|
hInternetFile = InternetOpenUrlA(
|
|
hInternetSession,
|
|
pszUrl,
|
|
"Accept: */*\r\n", // lpszHeaders
|
|
(DWORD) -1L, // dwHeadersLength
|
|
// INTERNET_FLAG_RELOAD, // dwFlags
|
|
INTERNET_FLAG_IGNORE_CERT_CN_INVALID,
|
|
0 // dwContext
|
|
);
|
|
if (NULL == hInternetFile) {
|
|
PrintLastError("InternetOpenUrl");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
DisplayCacheEntryInfoA(pszUrl);
|
|
ReadUrl(hInternetFile);
|
|
|
|
CommonReturn:
|
|
if (hInternetFile) {
|
|
if (!InternetCloseHandle(hInternetFile))
|
|
PrintLastError("InternetCloseHandle(File)");
|
|
}
|
|
if (hInternetSession) {
|
|
if (!InternetCloseHandle(hInternetSession))
|
|
PrintLastError("InternetCloseHandle(Session)");
|
|
}
|
|
}
|
|
|
|
static void OfflineUrlW(
|
|
LPWSTR pwszUrl
|
|
)
|
|
{
|
|
HINTERNET hInternetSession = NULL;
|
|
HINTERNET hInternetFile = NULL;
|
|
DWORD dwFlags;
|
|
|
|
printf("**** OFFLINE ****\n");
|
|
dwFlags = INTERNET_FLAG_OFFLINE;
|
|
hInternetSession = InternetOpenW(
|
|
L"CRL Agent", // lpszAgent
|
|
INTERNET_OPEN_TYPE_PRECONFIG, // dwAccessType
|
|
NULL, // lpszProxy
|
|
NULL, // lpszProxyBypass
|
|
dwFlags
|
|
);
|
|
if (NULL == hInternetSession) {
|
|
PrintLastError("InternetOpenW");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
|
|
hInternetFile = InternetOpenUrlW(
|
|
hInternetSession,
|
|
pwszUrl,
|
|
L"Accept: */*\r\n", // lpszHeaders
|
|
(DWORD) -1L, // dwHeadersLength
|
|
// INTERNET_FLAG_RELOAD, // dwFlags
|
|
INTERNET_FLAG_IGNORE_CERT_CN_INVALID,
|
|
0 // dwContext
|
|
);
|
|
if (NULL == hInternetFile) {
|
|
PrintLastError("InternetOpenUrlW");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
DisplayCacheEntryInfoW(pwszUrl);
|
|
ReadUrl(hInternetFile);
|
|
|
|
CommonReturn:
|
|
if (hInternetFile) {
|
|
if (!InternetCloseHandle(hInternetFile))
|
|
PrintLastError("InternetCloseHandle(File)");
|
|
}
|
|
if (hInternetSession) {
|
|
if (!InternetCloseHandle(hInternetSession))
|
|
PrintLastError("InternetCloseHandle(Session)");
|
|
}
|
|
}
|
|
|
|
|
|
typedef struct _QUERY_INFO {
|
|
LPSTR pszInfo;
|
|
DWORD dwInfo;
|
|
} QUERY_INFO, *PQUERY_INFO;
|
|
|
|
static QUERY_INFO rgQueryInfo[] = {
|
|
#if 0
|
|
"HTTP_QUERY_MIME_VERSION-Req",
|
|
HTTP_QUERY_MIME_VERSION | HTTP_QUERY_FLAG_REQUEST_HEADERS,
|
|
"HTTP_QUERY_CONTENT_TYPE-Req",
|
|
HTTP_QUERY_CONTENT_TYPE | HTTP_QUERY_FLAG_REQUEST_HEADERS,
|
|
"HTTP_QUERY_CONTENT_TRANSFER_ENCODING-Req",
|
|
HTTP_QUERY_CONTENT_TRANSFER_ENCODING | HTTP_QUERY_FLAG_REQUEST_HEADERS,
|
|
"HTTP_QUERY_CONTENT_LENGTH-Req",
|
|
HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_REQUEST_HEADERS,
|
|
#endif
|
|
|
|
"Request WINHTTP_QUERY_RAW_HEADERS_CRLF",
|
|
HTTP_QUERY_RAW_HEADERS_CRLF | HTTP_QUERY_FLAG_REQUEST_HEADERS,
|
|
"HTTP_QUERY_MIME_VERSION", HTTP_QUERY_MIME_VERSION,
|
|
"HTTP_QUERY_CONTENT_TYPE", HTTP_QUERY_CONTENT_TYPE,
|
|
"HTTP_QUERY_CONTENT_TRANSFER_ENCODING",
|
|
HTTP_QUERY_CONTENT_TRANSFER_ENCODING,
|
|
"HTTP_QUERY_CONTENT_LENGTH", HTTP_QUERY_CONTENT_LENGTH,
|
|
"HTTP_QUERY_CONTENT_LENGTH-Num",
|
|
HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER,
|
|
|
|
"HTTP_QUERY_VERSION", HTTP_QUERY_VERSION,
|
|
"HTTP_QUERY_STATUS_CODE", HTTP_QUERY_STATUS_CODE,
|
|
"HTTP_QUERY_STATUS_CODE-Num",
|
|
HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
|
|
"HTTP_QUERY_STATUS_TEXT", HTTP_QUERY_STATUS_TEXT,
|
|
"HTTP_QUERY_RAW_HEADERS", HTTP_QUERY_RAW_HEADERS,
|
|
"HTTP_QUERY_RAW_HEADERS_CRLF", HTTP_QUERY_RAW_HEADERS_CRLF,
|
|
"HTTP_QUERY_CONTENT_ENCODING", HTTP_QUERY_CONTENT_ENCODING,
|
|
"HTTP_QUERY_LOCATION", HTTP_QUERY_LOCATION,
|
|
"HTTP_QUERY_ORIG_URI", HTTP_QUERY_ORIG_URI,
|
|
"HTTP_QUERY_REQUEST_METHOD", HTTP_QUERY_REQUEST_METHOD,
|
|
"HTTP_QUERY_DATE",
|
|
HTTP_QUERY_DATE | HTTP_QUERY_FLAG_SYSTEMTIME,
|
|
"HTTP_QUERY_EXPIRES",
|
|
HTTP_QUERY_EXPIRES | HTTP_QUERY_FLAG_SYSTEMTIME,
|
|
"HTTP_QUERY_LAST_MODIFIED",
|
|
HTTP_QUERY_LAST_MODIFIED | HTTP_QUERY_FLAG_SYSTEMTIME,
|
|
};
|
|
|
|
#define NQUERYINFO (sizeof(rgQueryInfo)/sizeof(rgQueryInfo[0]))
|
|
|
|
static void DisplayQueryInfo(IN HINTERNET hInternetFile, IN BOOL fUnicode)
|
|
{
|
|
DWORD i;
|
|
for (i = 0; i < NQUERYINFO; i++) {
|
|
DWORD dwIndex;
|
|
BOOL fFirst;
|
|
|
|
fFirst = TRUE;
|
|
dwIndex = 0;
|
|
while (TRUE) {
|
|
BYTE rgbBuf[4096];
|
|
DWORD cbBuf;
|
|
DWORD dwThisIndex = dwIndex;
|
|
BOOL fResult;
|
|
DWORD dwValue;
|
|
SYSTEMTIME st;
|
|
|
|
memset(rgbBuf, 0, sizeof(rgbBuf));
|
|
cbBuf = sizeof(rgbBuf);
|
|
|
|
if (rgQueryInfo[i].dwInfo & HTTP_QUERY_FLAG_NUMBER) {
|
|
dwValue = 0x183679;
|
|
cbBuf = sizeof(dwValue);
|
|
fResult = HttpQueryInfoA(
|
|
hInternetFile,
|
|
rgQueryInfo[i].dwInfo,
|
|
&dwValue,
|
|
&cbBuf,
|
|
&dwIndex);
|
|
} else if (rgQueryInfo[i].dwInfo & HTTP_QUERY_FLAG_SYSTEMTIME) {
|
|
cbBuf = sizeof(st);
|
|
fResult = HttpQueryInfoA(
|
|
hInternetFile,
|
|
rgQueryInfo[i].dwInfo,
|
|
&st,
|
|
&cbBuf,
|
|
&dwIndex);
|
|
} else if (fUnicode)
|
|
fResult = HttpQueryInfoW(
|
|
hInternetFile,
|
|
rgQueryInfo[i].dwInfo,
|
|
rgbBuf,
|
|
&cbBuf,
|
|
&dwIndex);
|
|
else
|
|
fResult = HttpQueryInfoA(
|
|
hInternetFile,
|
|
rgQueryInfo[i].dwInfo,
|
|
rgbBuf,
|
|
&cbBuf,
|
|
&dwIndex);
|
|
if (!fResult) {
|
|
DWORD dwErr = GetLastError();
|
|
if (fFirst || ERROR_HTTP_HEADER_NOT_FOUND != dwErr)
|
|
printf("HttpQueryInfo(%s) failed => 0x%x (%d) \n",
|
|
rgQueryInfo[i].pszInfo, dwErr, dwErr);
|
|
break;
|
|
} else if (rgQueryInfo[i].dwInfo & HTTP_QUERY_FLAG_NUMBER) {
|
|
printf("%s[%d]:: 0x%x (%d)\n",
|
|
rgQueryInfo[i].pszInfo, dwThisIndex, dwValue, dwValue);
|
|
} else if (rgQueryInfo[i].dwInfo & HTTP_QUERY_FLAG_SYSTEMTIME) {
|
|
FILETIME ft;
|
|
if (!SystemTimeToFileTime(&st, &ft)) {
|
|
DWORD dwErr = GetLastError();
|
|
printf("SystemTimeToFileTime(%s) failed => 0x%x (%d) \n",
|
|
rgQueryInfo[i].pszInfo, dwErr, dwErr);
|
|
} else
|
|
printf("%s[%d]:: %s\n", rgQueryInfo[i].pszInfo,
|
|
dwThisIndex, FileTimeText(&ft));
|
|
} else {
|
|
printf("%s[%d]::\n",
|
|
rgQueryInfo[i].pszInfo, dwThisIndex);
|
|
PrintBytes(" ", rgbBuf, cbBuf);
|
|
}
|
|
fFirst = FALSE;
|
|
if (dwThisIndex == dwIndex) {
|
|
#if 0
|
|
printf("HttpQueryInfo(%s) dwIndex not advanced\n",
|
|
rgQueryInfo[i].pszInfo);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void OnlineUrlA(
|
|
LPSTR pszUrl
|
|
)
|
|
{
|
|
HINTERNET hInternetSession = NULL;
|
|
HINTERNET hInternetFile = NULL;
|
|
DWORD dwFlags;
|
|
|
|
printf("**** ONLINE ****\n");
|
|
|
|
#if 0
|
|
DisplayDestinationReachableA(pszUrl);
|
|
#endif
|
|
|
|
dwFlags = 0;
|
|
hInternetSession = InternetOpenA(
|
|
"CRL Agent", // lpszAgent
|
|
INTERNET_OPEN_TYPE_PRECONFIG, // dwAccessType
|
|
NULL, // lpszProxy
|
|
NULL, // lpszProxyBypass
|
|
dwFlags
|
|
);
|
|
if (NULL == hInternetSession) {
|
|
PrintLastError("InternetOpen");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
|
|
hInternetFile = InternetOpenUrlA(
|
|
hInternetSession,
|
|
pszUrl,
|
|
"Accept: */*\r\n", // lpszHeaders
|
|
(DWORD) -1L, // dwHeadersLength
|
|
INTERNET_FLAG_RELOAD | INTERNET_FLAG_IGNORE_CERT_CN_INVALID,
|
|
0 // dwContext
|
|
);
|
|
if (NULL == hInternetFile) {
|
|
PrintLastError("InternetOpenUrl");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
DisplayQueryInfo(hInternetFile, FALSE);
|
|
ReadUrl(hInternetFile);
|
|
DisplayCacheEntryInfoA(pszUrl);
|
|
|
|
CommonReturn:
|
|
if (hInternetFile) {
|
|
if (!InternetCloseHandle(hInternetFile))
|
|
PrintLastError("InternetCloseHandle(File)");
|
|
}
|
|
if (hInternetSession) {
|
|
if (!InternetCloseHandle(hInternetSession))
|
|
PrintLastError("InternetCloseHandle(Session)");
|
|
}
|
|
}
|
|
|
|
static void OnlineUrlW(
|
|
LPWSTR pwszUrl
|
|
)
|
|
{
|
|
HINTERNET hInternetSession = NULL;
|
|
HINTERNET hInternetFile = NULL;
|
|
DWORD dwFlags;
|
|
|
|
printf("**** ONLINE ****\n");
|
|
dwFlags = 0;
|
|
hInternetSession = InternetOpenW(
|
|
L"CRL Agent", // lpszAgent
|
|
INTERNET_OPEN_TYPE_PRECONFIG, // dwAccessType
|
|
NULL, // lpszProxy
|
|
NULL, // lpszProxyBypass
|
|
dwFlags
|
|
);
|
|
if (NULL == hInternetSession) {
|
|
PrintLastError("InternetOpenW");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
|
|
hInternetFile = InternetOpenUrlW(
|
|
hInternetSession,
|
|
pwszUrl,
|
|
L"Accept: */*\r\n", // lpszHeaders
|
|
(DWORD) -1L, // dwHeadersLength
|
|
INTERNET_FLAG_RELOAD | INTERNET_FLAG_IGNORE_CERT_CN_INVALID,
|
|
0 // dwContext
|
|
);
|
|
if (NULL == hInternetFile) {
|
|
PrintLastError("InternetOpenUrlW");
|
|
goto CommonReturn;
|
|
}
|
|
|
|
DisplayQueryInfo(hInternetFile, TRUE);
|
|
ReadUrl(hInternetFile);
|
|
DisplayCacheEntryInfoW(pwszUrl);
|
|
|
|
CommonReturn:
|
|
if (hInternetFile) {
|
|
if (!InternetCloseHandle(hInternetFile))
|
|
PrintLastError("InternetCloseHandle(File)");
|
|
}
|
|
if (hInternetSession) {
|
|
if (!InternetCloseHandle(hInternetSession))
|
|
PrintLastError("InternetCloseHandle(Session)");
|
|
}
|
|
}
|
|
|
|
void DisplayInternetState()
|
|
{
|
|
DWORD dwFlags = 0;
|
|
BOOL fResult;
|
|
|
|
fResult = InternetGetConnectedState(&dwFlags, 0);
|
|
if (!fResult)
|
|
printf("NO ");
|
|
printf("Internet Connection, dwFlags: 0x%x", dwFlags);
|
|
|
|
if (dwFlags & INTERNET_CONNECTION_MODEM)
|
|
printf(" MODEM");
|
|
if (dwFlags & INTERNET_CONNECTION_LAN)
|
|
printf(" LAN");
|
|
if (dwFlags & INTERNET_CONNECTION_PROXY)
|
|
printf(" PROXY");
|
|
if (dwFlags & INTERNET_CONNECTION_MODEM_BUSY)
|
|
printf(" MODEM_BUSY");
|
|
if (dwFlags & INTERNET_RAS_INSTALLED)
|
|
printf(" RAS_INSTALLED");
|
|
if (dwFlags & INTERNET_CONNECTION_OFFLINE)
|
|
printf(" OFFLINE");
|
|
if (dwFlags & INTERNET_CONNECTION_CONFIGURED)
|
|
printf(" CONFIGURED");
|
|
printf("\n");
|
|
|
|
|
|
dwFlags = 0;
|
|
fResult = IsNetworkAlive(&dwFlags);
|
|
if (fResult) {
|
|
printf("Network Alive, dwFlags: 0x%x", dwFlags);
|
|
|
|
if (dwFlags & NETWORK_ALIVE_LAN)
|
|
printf(" LAN");
|
|
if (dwFlags & NETWORK_ALIVE_WAN)
|
|
printf(" WAN");
|
|
if (dwFlags & NETWORK_ALIVE_AOL)
|
|
printf(" AOL");
|
|
printf("\n");
|
|
} else {
|
|
DWORD dwErr = GetLastError();
|
|
printf("Network disconnected, 0x%x (%d)\n", dwErr, dwErr);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
int _cdecl main(int argc, char * argv[])
|
|
{
|
|
BOOL fResult;
|
|
LPSTR pszUrl = NULL;
|
|
WCHAR wszUrl[_MAX_PATH + 1];
|
|
LPWSTR pwszUrl = NULL;
|
|
BOOL fUnicode = FALSE;
|
|
char szCanonicalizedUrl[_MAX_PATH + 1];
|
|
WCHAR wszCanonicalizedUrl[_MAX_PATH + 1];
|
|
DWORD cb;
|
|
BOOL fDelete = FALSE;
|
|
BOOL fCacheInfo = FALSE;
|
|
BOOL fOfflineOnly = FALSE;
|
|
BOOL fWireOnly = FALSE;
|
|
#define NO_CANONICALIZE 0xFFFFFFFF
|
|
DWORD dwCanonicalizeFlags = ICU_BROWSER_MODE;
|
|
|
|
BOOL fSyncTime = FALSE;
|
|
LONG lSyncTimeDeltaSeconds = 0;
|
|
|
|
BOOL fHostName = FALSE;
|
|
WCHAR wszHostName[_MAX_PATH + 1];
|
|
|
|
while (--argc>0)
|
|
{
|
|
if (**++argv == '-')
|
|
{
|
|
switch(argv[0][1])
|
|
{
|
|
case 'U':
|
|
fUnicode = TRUE;
|
|
break;
|
|
case 'd':
|
|
fDelete = TRUE;
|
|
break;
|
|
case 'i':
|
|
fCacheInfo = TRUE;
|
|
break;
|
|
case 'o':
|
|
fOfflineOnly = TRUE;
|
|
break;
|
|
case 'w':
|
|
fWireOnly = TRUE;
|
|
break;
|
|
case 'c':
|
|
if (argv[0][2]) {
|
|
if (0 == _stricmp(argv[0]+2, "None"))
|
|
dwCanonicalizeFlags = NO_CANONICALIZE;
|
|
else if (0 == _stricmp(argv[0]+2, "Spaces"))
|
|
dwCanonicalizeFlags = ICU_ENCODE_SPACES_ONLY;
|
|
else if (0 == _stricmp(argv[0]+2, "Browser"))
|
|
dwCanonicalizeFlags = ICU_BROWSER_MODE;
|
|
else if (0 == _stricmp(argv[0]+2, "All"))
|
|
dwCanonicalizeFlags = 0;
|
|
else {
|
|
printf("Need to specify -cNone | -cSpaces | -cBrowser | -cAll\n");
|
|
goto BadUsage;
|
|
}
|
|
} else {
|
|
printf("Need to specify -cNone | -cSpaces | -cBrowser | -cAll\n");
|
|
goto BadUsage;
|
|
}
|
|
break;
|
|
case 's':
|
|
DisplayInternetState();
|
|
goto CommonReturn;
|
|
case 'n':
|
|
fHostName = TRUE;
|
|
break;
|
|
case 'S':
|
|
fSyncTime = TRUE;
|
|
lSyncTimeDeltaSeconds = strtol(argv[0]+2, NULL, 0);
|
|
break;
|
|
case 'h':
|
|
default:
|
|
goto BadUsage;
|
|
}
|
|
} else
|
|
pszUrl = argv[0];
|
|
}
|
|
|
|
|
|
if (pszUrl == NULL) {
|
|
printf("missing URL\n");
|
|
goto BadUsage;
|
|
}
|
|
|
|
printf("command line: %s\n", GetCommandLine());
|
|
|
|
if (fHostName) {
|
|
MultiByteToWideChar(
|
|
CP_ACP,
|
|
0, // dwFlags
|
|
pszUrl,
|
|
-1, // null terminated
|
|
wszUrl,
|
|
sizeof(wszUrl) / sizeof(wszUrl[0]));
|
|
|
|
wszHostName[0] = L'\0';
|
|
fResult = I_CryptNetGetHostNameFromUrl (
|
|
wszUrl,
|
|
sizeof(wszHostName) / sizeof(wszHostName[0]),
|
|
wszHostName
|
|
);
|
|
if (!fResult)
|
|
PrintLastError("I_CryptNetGetHostNameFromUrl");
|
|
else
|
|
printf("HostName :: %S\n", wszHostName);
|
|
|
|
goto CommonReturn;
|
|
}
|
|
|
|
if (fUnicode) {
|
|
MultiByteToWideChar(
|
|
CP_ACP,
|
|
0, // dwFlags
|
|
pszUrl,
|
|
-1, // null terminated
|
|
wszUrl,
|
|
sizeof(wszUrl) / sizeof(wszUrl[0]));
|
|
|
|
if (NO_CANONICALIZE == dwCanonicalizeFlags) {
|
|
pwszUrl = wszUrl;
|
|
printf("Unicode Url:: %S\n", pwszUrl);
|
|
} else {
|
|
cb = sizeof(wszCanonicalizedUrl);
|
|
fResult = InternetCanonicalizeUrlW(
|
|
wszUrl,
|
|
wszCanonicalizedUrl,
|
|
&cb,
|
|
dwCanonicalizeFlags
|
|
);
|
|
if (!fResult) {
|
|
PrintLastError("InternetCanonicalizeUrlW");
|
|
goto CommonReturn;
|
|
} else if (cb) {
|
|
printf("Unicode CanonicalizedUrl:: %S\n", wszCanonicalizedUrl);
|
|
pwszUrl = wszCanonicalizedUrl;
|
|
} else {
|
|
printf("Unicode CanonicalizedUrl:: returned empty string\n");
|
|
goto CommonReturn;
|
|
}
|
|
}
|
|
|
|
if (fDelete) {
|
|
printf("Unicode DeleteUrlCacheEntry not supported\n");
|
|
} else if (fSyncTime) {
|
|
printf("Unicode SyncTime not supported\n");
|
|
} else if (fCacheInfo) {
|
|
DisplayCacheEntryInfoW(pwszUrl);
|
|
} else if (fOfflineOnly) {
|
|
OfflineUrlW(pwszUrl);
|
|
} else if (fWireOnly) {
|
|
OnlineUrlW(pwszUrl);
|
|
} else {
|
|
OfflineUrlW(pwszUrl);
|
|
OnlineUrlW(pwszUrl);
|
|
}
|
|
} else {
|
|
if (NO_CANONICALIZE == dwCanonicalizeFlags) {
|
|
printf("Url:: %s\n", pszUrl);
|
|
} else {
|
|
cb = sizeof(szCanonicalizedUrl);
|
|
fResult = InternetCanonicalizeUrlA(
|
|
pszUrl,
|
|
szCanonicalizedUrl,
|
|
&cb,
|
|
dwCanonicalizeFlags
|
|
);
|
|
if (!fResult) {
|
|
PrintLastError("InternetCanonicalizeUrlA");
|
|
goto CommonReturn;
|
|
} else if (cb) {
|
|
printf("CanonicalizedUrl:: %s\n", szCanonicalizedUrl);
|
|
pszUrl = szCanonicalizedUrl;
|
|
} else {
|
|
printf("CanonicalizedUrl:: returned empty string\n");
|
|
goto CommonReturn;
|
|
}
|
|
}
|
|
|
|
if (fDelete) {
|
|
if (!DeleteUrlCacheEntry(pszUrl)) {
|
|
if (ERROR_FILE_NOT_FOUND != GetLastError())
|
|
PrintLastError("DeleteUrlCacheEntry");
|
|
}
|
|
} else if (fSyncTime) {
|
|
SetSyncTime(pszUrl, lSyncTimeDeltaSeconds);
|
|
} else if (fCacheInfo) {
|
|
DisplayCacheEntryInfoA(pszUrl);
|
|
} else if (fOfflineOnly) {
|
|
OfflineUrlA(pszUrl);
|
|
} else if (fWireOnly) {
|
|
OnlineUrlA(pszUrl);
|
|
} else {
|
|
OfflineUrlA(pszUrl);
|
|
OnlineUrlA(pszUrl);
|
|
}
|
|
}
|
|
|
|
CommonReturn:
|
|
return 0;
|
|
BadUsage:
|
|
Usage();
|
|
goto CommonReturn;
|
|
|
|
}
|