375 lines
9.8 KiB
C++
375 lines
9.8 KiB
C++
/*-------------------------------------------------------*/
|
|
//Copyright (c) 1997 Microsoft Corporation
|
|
//
|
|
// Util.cpp
|
|
//
|
|
//Author:
|
|
//
|
|
//
|
|
//Environment:
|
|
//
|
|
// User Mode - Win32
|
|
//
|
|
//Revision History:
|
|
/*-------------------------------------------------------*/
|
|
|
|
#include "urltrk.h"
|
|
#include <inetreg.h>
|
|
|
|
const CHAR c_szLogFormat[] = "hh':'mm':'ss";
|
|
const CHAR c_szMode[] = "U"; // unknown
|
|
const CHAR c_szLogContainerA[] = "Log";
|
|
|
|
#define MY_CACHE_ENTRY_INFO_SIZE 512
|
|
#define MY_MAX_STRING_LEN 512
|
|
|
|
BOOL ConvertToPrefixedURL(LPCSTR lpszUrl, LPSTR *lplpPrefixedUrl);
|
|
LPINTERNET_CACHE_ENTRY_INFOA QueryCacheEntry(LPCSTR lpUrl);
|
|
HANDLE GetLogFile(LPCSTR lpUrl, LPINTERNET_CACHE_ENTRY_INFOA pce, LPSTR lpFile);
|
|
LPSTR GetLogString(LPMY_LOGGING_INFO lpLogInfo);
|
|
|
|
|
|
ULONG _IsLoggingEnabled(LPCSTR pszUrl)
|
|
{
|
|
LPINTERNET_CACHE_ENTRY_INFOA pce;
|
|
LPSTR lpPfxUrl = NULL;
|
|
ULONG dwTrack;
|
|
|
|
//
|
|
ConvertToPrefixedURL(pszUrl, &lpPfxUrl);
|
|
if (!lpPfxUrl)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return 0;
|
|
}
|
|
|
|
pce = QueryCacheEntry(lpPfxUrl);
|
|
if (!pce)
|
|
{
|
|
GlobalFree(lpPfxUrl);
|
|
SetLastError(ERROR_FILE_NOT_FOUND);
|
|
return 0;
|
|
}
|
|
|
|
dwTrack = pce->CacheEntryType;
|
|
GlobalFree(pce);
|
|
GlobalFree(lpPfxUrl);
|
|
return dwTrack;
|
|
}
|
|
|
|
BOOL _WriteHitLogging(LPMY_LOGGING_INFO pmLi)
|
|
{
|
|
LPSTR lpLogString = NULL;
|
|
LPSTR lpPfxUrl = NULL;
|
|
LPINTERNET_CACHE_ENTRY_INFOA pce = NULL;
|
|
HANDLE hFile;
|
|
CHAR lpFile[MAX_PATH];
|
|
DWORD dwWritten = 0;
|
|
BOOL fuseCache;
|
|
BOOL bRet = FALSE;
|
|
|
|
//
|
|
ConvertToPrefixedURL(pmLi->pLogInfo->lpszLoggedUrlName, &lpPfxUrl);
|
|
if (!lpPfxUrl)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return bRet;
|
|
}
|
|
|
|
pce = QueryCacheEntry(lpPfxUrl);
|
|
if (!pce)
|
|
{
|
|
GlobalFree(lpPfxUrl);
|
|
SetLastError(ERROR_FILE_NOT_FOUND);
|
|
return bRet;
|
|
}
|
|
|
|
hFile = GetLogFile(lpPfxUrl, pce, &lpFile[0]);
|
|
if (hFile == NULL)
|
|
{
|
|
GlobalFree(lpPfxUrl);
|
|
GlobalFree(pce);
|
|
SetLastError(ERROR_FILE_NOT_FOUND);
|
|
return bRet;
|
|
}
|
|
|
|
pmLi->fuseCache = GetUrlCacheEntryInfoExA(pmLi->pLogInfo->lpszLoggedUrlName, NULL, NULL, NULL, NULL, NULL, 0);
|
|
lpLogString = GetLogString(pmLi);
|
|
if (!lpLogString)
|
|
{
|
|
GlobalFree(lpPfxUrl);
|
|
GlobalFree(pce);
|
|
CloseHandle(hFile);
|
|
return bRet;
|
|
}
|
|
|
|
bRet = WriteFile(hFile, lpLogString, lstrlenA(lpLogString), &dwWritten, NULL);
|
|
|
|
CloseHandle(hFile);
|
|
GlobalFree(lpLogString);
|
|
|
|
// commit change to cache
|
|
if(bRet)
|
|
{
|
|
bRet = CommitUrlCacheEntry(lpPfxUrl,
|
|
lpFile, //
|
|
pce->ExpireTime, //ExpireTime
|
|
pce->LastModifiedTime, //LastModifiedTime
|
|
pce->CacheEntryType,
|
|
NULL, //lpHeaderInfo
|
|
0, //dwHeaderSize
|
|
NULL, //lpszFileExtension
|
|
0); //reserved
|
|
}
|
|
|
|
// free pce
|
|
GlobalFree(pce);
|
|
GlobalFree(lpPfxUrl);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
BOOL IsGlobalOffline(void)
|
|
{
|
|
DWORD dwState = 0, dwSize = sizeof(DWORD);
|
|
BOOL fRet = FALSE;
|
|
#ifdef _SBS_
|
|
HMODULE hModuleHandle = GetModuleHandleA("sbswinet.dll");
|
|
#else
|
|
HMODULE hModuleHandle = GetModuleHandleA("wininet.dll");
|
|
#endif // _SBS_
|
|
|
|
if(!hModuleHandle)
|
|
return FALSE;
|
|
|
|
if(InternetQueryOptionA(NULL, INTERNET_OPTION_CONNECTED_STATE, &dwState,
|
|
&dwSize))
|
|
{
|
|
if(dwState & INTERNET_STATE_DISCONNECTED_BY_USER)
|
|
fRet = TRUE;
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
//
|
|
// Helper Functions
|
|
//
|
|
LPSTR GetLogString(LPMY_LOGGING_INFO pmLi)
|
|
{
|
|
FILETIME ftIn, ftOut;
|
|
ULARGE_INTEGER ulIn, ulOut, ulTotal;
|
|
SYSTEMTIME stIn, stOut;
|
|
LPSTR lpData = NULL;
|
|
CHAR pTimeIn[10], pTimeOut[10];
|
|
|
|
lpData = (LPSTR)GlobalAlloc(LPTR, lstrlenA(pmLi->pLogInfo->lpszExtendedInfo)+MY_MAX_STRING_LEN);
|
|
if (!lpData)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return NULL;
|
|
}
|
|
|
|
// calculate delta of time
|
|
SystemTimeToFileTime(&(pmLi->pLogInfo->StartTime), &ftIn);
|
|
SystemTimeToFileTime(&(pmLi->pLogInfo->EndTime), &ftOut);
|
|
|
|
ulIn.LowPart = ftIn.dwLowDateTime;
|
|
ulIn.HighPart = ftIn.dwHighDateTime;
|
|
ulOut.LowPart = ftOut.dwLowDateTime;
|
|
ulOut.HighPart = ftOut.dwHighDateTime;
|
|
#ifndef unix
|
|
ulTotal.QuadPart = ulOut.QuadPart - ulIn.QuadPart;
|
|
#else
|
|
U_QUAD_PART(ulTotal) = U_QUAD_PART(ulOut) - U_QUAD_PART(ulIn);
|
|
#endif /* unix */
|
|
ftOut.dwLowDateTime = ulTotal.LowPart;
|
|
ftOut.dwHighDateTime = ulTotal.HighPart;
|
|
FileTimeToSystemTime(&ftOut, &stOut);
|
|
stIn = pmLi->pLogInfo->StartTime;
|
|
|
|
// log string: timeEnter+Duration
|
|
GetTimeFormat(LOCALE_SYSTEM_DEFAULT, TIME_FORCE24HOURFORMAT, &stIn, c_szLogFormat, pTimeIn, 10);
|
|
GetTimeFormat(LOCALE_SYSTEM_DEFAULT, TIME_FORCE24HOURFORMAT, &stOut, c_szLogFormat, pTimeOut, 10);
|
|
|
|
if (!pmLi->pLogInfo->lpszExtendedInfo)
|
|
{
|
|
wsprintf(lpData, "%s %d %.2d-%.2d-%d %s %s\r\n", c_szMode,
|
|
pmLi->fuseCache,
|
|
stIn.wMonth, stIn.wDay, stIn.wYear,
|
|
pTimeIn, pTimeOut);
|
|
}
|
|
else
|
|
{
|
|
wsprintf(lpData, "%s %d %.2d-%.2d-%d %s %s %s\r\n", c_szMode,
|
|
pmLi->fuseCache,
|
|
stIn.wMonth, stIn.wDay, stIn.wYear,
|
|
pTimeIn, pTimeOut,
|
|
pmLi->pLogInfo->lpszExtendedInfo);
|
|
}
|
|
|
|
return lpData;
|
|
}
|
|
|
|
|
|
LPSTR ReadTrackingPrefix(void)
|
|
{
|
|
LPSTR lpPfx = NULL;
|
|
|
|
DWORD cbPfx = 0;
|
|
struct {
|
|
INTERNET_CACHE_CONTAINER_INFOA cInfo;
|
|
CHAR szBuffer[MAX_PATH+INTERNET_MAX_URL_LENGTH+1];
|
|
} ContainerInfo;
|
|
DWORD dwModified, dwContainer;
|
|
HANDLE hEnum;
|
|
|
|
dwContainer = sizeof(ContainerInfo);
|
|
hEnum = FindFirstUrlCacheContainerA(&dwModified,
|
|
&ContainerInfo.cInfo,
|
|
&dwContainer,
|
|
0);
|
|
|
|
if (hEnum)
|
|
{
|
|
|
|
for (;;)
|
|
{
|
|
if (!lstrcmpiA(ContainerInfo.cInfo.lpszName, c_szLogContainerA))
|
|
{
|
|
if (ContainerInfo.cInfo.lpszCachePrefix[0])
|
|
{
|
|
DWORD cb = lstrlenA(ContainerInfo.cInfo.lpszCachePrefix)+sizeof(CHAR);
|
|
lpPfx = (LPSTR)GlobalAlloc(LPTR, cb);
|
|
if (!lpPfx)
|
|
{
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
break;
|
|
}
|
|
|
|
lstrcpynA(lpPfx, ContainerInfo.cInfo.lpszCachePrefix, cb);
|
|
}
|
|
break;
|
|
}
|
|
|
|
dwContainer = sizeof(ContainerInfo);
|
|
if (!FindNextUrlCacheContainerA(hEnum, &ContainerInfo.cInfo, &dwContainer))
|
|
{
|
|
if (GetLastError() == ERROR_NO_MORE_ITEMS)
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
FindCloseUrlCache(hEnum);
|
|
}
|
|
|
|
return lpPfx;
|
|
}
|
|
|
|
|
|
// caller must free lplpPrefixedUrl
|
|
BOOL
|
|
ConvertToPrefixedURL(LPCSTR lpszUrl, LPSTR *lplpPrefixedUrl)
|
|
{
|
|
BOOL bret = FALSE;
|
|
LPTSTR lpPfx = NULL;
|
|
|
|
if (!lpszUrl)
|
|
return bret;
|
|
|
|
lpPfx = ReadTrackingPrefix();
|
|
if (lpPfx)
|
|
{
|
|
*lplpPrefixedUrl = (LPSTR)GlobalAlloc(LPTR, lstrlenA(lpszUrl)+lstrlenA(lpPfx)+1);
|
|
if (*lplpPrefixedUrl)
|
|
{
|
|
wsprintf(*lplpPrefixedUrl, "%s%s", lpPfx, lpszUrl);
|
|
bret = TRUE;
|
|
}
|
|
|
|
GlobalFree(lpPfx);
|
|
}
|
|
|
|
return bret;
|
|
}
|
|
|
|
LPINTERNET_CACHE_ENTRY_INFOA
|
|
QueryCacheEntry(LPCSTR lpUrl)
|
|
{
|
|
// get cache entry info
|
|
LPINTERNET_CACHE_ENTRY_INFOA lpCE = NULL;
|
|
DWORD dwEntrySize;
|
|
BOOL bret = FALSE;
|
|
|
|
lpCE = (LPINTERNET_CACHE_ENTRY_INFOA)GlobalAlloc(LPTR, MY_CACHE_ENTRY_INFO_SIZE);
|
|
if (lpCE)
|
|
{
|
|
dwEntrySize = MY_CACHE_ENTRY_INFO_SIZE;
|
|
|
|
while (!(bret = GetUrlCacheEntryInfoA(lpUrl, lpCE, &dwEntrySize)))
|
|
{
|
|
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
GlobalFree(lpCE);
|
|
|
|
lpCE = (LPINTERNET_CACHE_ENTRY_INFOA)GlobalAlloc(LPTR, dwEntrySize);
|
|
if (!lpCE)
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bret && lpCE)
|
|
{
|
|
GlobalFree(lpCE);
|
|
lpCE = NULL;
|
|
SetLastError(ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
return lpCE;
|
|
|
|
}
|
|
|
|
HANDLE GetLogFile(LPCSTR lpUrl, LPINTERNET_CACHE_ENTRY_INFOA pce, LPSTR lpFile)
|
|
{
|
|
HANDLE hFile = NULL;
|
|
|
|
// work around -- begin
|
|
if (!CreateUrlCacheEntry(lpUrl, 512, "log", lpFile, 0))
|
|
return NULL;
|
|
|
|
if (pce->lpszLocalFileName)
|
|
{
|
|
if (!CopyFile(pce->lpszLocalFileName, lpFile, FALSE))
|
|
return NULL;
|
|
|
|
DeleteFile(pce->lpszLocalFileName);
|
|
}
|
|
// work around -- end
|
|
|
|
hFile = CreateFile(lpFile,
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, // | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
return NULL;
|
|
|
|
// move file pointer to end
|
|
if (0xFFFFFFFF == SetFilePointer(hFile, 0, 0, FILE_END))
|
|
{
|
|
CloseHandle(hFile);
|
|
hFile = NULL;
|
|
}
|
|
|
|
return hFile;
|
|
}
|
|
|