717 lines
17 KiB
C++
717 lines
17 KiB
C++
/*-------------------------------------------------------*/
|
|
//Copyright (c) 1997 Microsoft Corporation
|
|
//
|
|
//Module Name: Url Tracking Log Interfaces
|
|
//
|
|
// Urltrack.cpp
|
|
//
|
|
//
|
|
//Author:
|
|
//
|
|
// Pei-Hwa Lin (peihwal) 19-March-97
|
|
//
|
|
//Environment:
|
|
//
|
|
// User Mode - Win32
|
|
//
|
|
//Revision History:
|
|
// 5/13/97 due to cache container type change, allow
|
|
// OPEN_ALWAYS when CreateFile
|
|
// 5/14/97 remove IsOnTracking, TRACK_ALL, unused code
|
|
/*-------------------------------------------------------*/
|
|
|
|
#include "priv.h"
|
|
#include <wininet.h>
|
|
#include "basesb.h"
|
|
#include "bindcb.h"
|
|
const WCHAR c_szPropURL[] = L"HREF";
|
|
const WCHAR c_szProptagName[] = L"Item";
|
|
const TCHAR c_szLogContainer[] = TEXT("Log");
|
|
|
|
#define MY_MAX_STRING_LEN 512
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// IUnknown interfaces
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CUrlTrackingStg :: QueryInterface(REFIID riid, PVOID *ppvObj)
|
|
{
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
|
|
*ppvObj = NULL;
|
|
|
|
if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IUrlTrackingStg))
|
|
{
|
|
AddRef();
|
|
*ppvObj = (LPVOID) SAFECAST(this, IUrlTrackingStg *);
|
|
hr = S_OK;
|
|
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
ULONG
|
|
CUrlTrackingStg :: AddRef(void)
|
|
{
|
|
_cRef ++;
|
|
return _cRef;
|
|
}
|
|
|
|
ULONG
|
|
CUrlTrackingStg :: Release(void)
|
|
{
|
|
|
|
ASSERT(_cRef > 0);
|
|
|
|
_cRef--;
|
|
|
|
if (!_cRef)
|
|
{
|
|
//time to go bye bye
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return _cRef;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// C'tor/D'tor
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
CUrlTrackingStg :: CUrlTrackingStg()
|
|
{
|
|
|
|
_hFile = NULL;
|
|
_pRecords = NULL;
|
|
_lpPfx = NULL;
|
|
}
|
|
|
|
CUrlTrackingStg :: ~CUrlTrackingStg()
|
|
{
|
|
// browser exit
|
|
while (_pRecords)
|
|
{
|
|
OnUnload(_pRecords->pthisUrl);
|
|
};
|
|
|
|
// DeleteAllNode();
|
|
|
|
if (_lpPfx)
|
|
{
|
|
GlobalFree(_lpPfx);
|
|
_lpPfx = NULL;
|
|
}
|
|
|
|
if (_hFile)
|
|
{
|
|
CloseHandle(_hFile);
|
|
_hFile = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Helper functions
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
LRecord *
|
|
CUrlTrackingStg :: AddNode()
|
|
{
|
|
LRecord* pTemp;
|
|
LRecord* pNew = NULL;
|
|
|
|
pNew = (LRecord *)LocalAlloc(LPTR, sizeof(LRecord));
|
|
if (pNew == NULL)
|
|
return NULL;
|
|
|
|
pNew->pNext = NULL;
|
|
if (_pRecords == NULL)
|
|
{
|
|
//special case for first node
|
|
_pRecords = pNew;
|
|
}
|
|
else
|
|
{
|
|
for (pTemp = _pRecords; pTemp->pNext; pTemp = pTemp->pNext);
|
|
pTemp->pNext = pNew;
|
|
}
|
|
|
|
return pNew;
|
|
}
|
|
|
|
void
|
|
CUrlTrackingStg :: DeleteAllNode()
|
|
{
|
|
|
|
do
|
|
{
|
|
DeleteFirstNode();
|
|
}
|
|
while (_pRecords);
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
CUrlTrackingStg :: DeleteFirstNode()
|
|
{
|
|
LRecord *pTemp;
|
|
|
|
if (!_pRecords)
|
|
return;
|
|
|
|
pTemp = _pRecords;
|
|
_pRecords = pTemp->pNext;
|
|
delete [] pTemp->pthisUrl;
|
|
LocalFree(pTemp);
|
|
pTemp = NULL;
|
|
return;
|
|
}
|
|
|
|
void
|
|
CUrlTrackingStg :: DeleteCurrentNode(LRecord *pThis)
|
|
{
|
|
LRecord *pPrev;
|
|
|
|
if (_pRecords == pThis)
|
|
{
|
|
DeleteFirstNode();
|
|
return;
|
|
}
|
|
|
|
pPrev = _pRecords;
|
|
do
|
|
{
|
|
if (pPrev->pNext == pThis)
|
|
{
|
|
pPrev->pNext = pThis->pNext;
|
|
delete [] pThis->pthisUrl;
|
|
LocalFree(pThis);
|
|
pThis = NULL;
|
|
break;
|
|
}
|
|
pPrev = pPrev->pNext;
|
|
}
|
|
while (pPrev);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// return Current node by comparing url strings
|
|
//
|
|
LRecord*
|
|
CUrlTrackingStg :: FindCurrentNode
|
|
(
|
|
IN LPCTSTR lpUrl
|
|
)
|
|
{
|
|
LRecord* pThis = NULL;
|
|
|
|
ASSERT(_pRecords);
|
|
if (!_pRecords) // missed OnLoad
|
|
return NULL;
|
|
|
|
pThis = _pRecords;
|
|
do
|
|
{
|
|
if (!StrCmpI(lpUrl, pThis->pthisUrl))
|
|
break;
|
|
|
|
pThis = pThis->pNext;
|
|
}
|
|
while (pThis);
|
|
|
|
return pThis;
|
|
}
|
|
|
|
void
|
|
CUrlTrackingStg :: cleanup()
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
void
|
|
CUrlTrackingStg :: DetermineAppModule()
|
|
{
|
|
TCHAR szModule[MAX_PATH];
|
|
LPTSTR szExt;
|
|
|
|
if (GetModuleFileName(NULL, szModule, MAX_PATH))
|
|
{
|
|
szExt = PathFindExtension(szModule);
|
|
TraceMsg(0, "tracking: AppModule %s", szModule);
|
|
|
|
if (StrCmpI(szExt, TEXT(".SCR")) == 0)
|
|
_fScreenSaver = TRUE;
|
|
else
|
|
_fScreenSaver = FALSE;
|
|
|
|
}
|
|
else
|
|
_fScreenSaver = FALSE;
|
|
|
|
_fModule = TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// OnLoad(LPTSTR lpUrl, BRMODE context, BOOL fUseCache)
|
|
// a new page is loaded
|
|
// this function will remember time entering this page, context browsing
|
|
// from and page URL string.
|
|
// (lpUrl does NOT contain "track:" prefix)
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CUrlTrackingStg :: OnLoad
|
|
(
|
|
IN LPCTSTR lpUrl,
|
|
IN BRMODE ContextMode,
|
|
IN BOOL fUseCache
|
|
)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
SYSTEMTIME st;
|
|
LRecord* pNewNode = NULL;
|
|
|
|
GetLocalTime(&st);
|
|
|
|
pNewNode = AddNode();
|
|
if (!pNewNode)
|
|
return hr;
|
|
|
|
int cch = lstrlen(lpUrl)+1;
|
|
pNewNode->pthisUrl = (LPTSTR)LocalAlloc(LPTR, cch * sizeof(TCHAR));
|
|
if (pNewNode->pthisUrl == NULL)
|
|
return hr;
|
|
|
|
// store log info
|
|
StrCpyN(pNewNode->pthisUrl, lpUrl, cch);
|
|
|
|
if (!_fModule)
|
|
DetermineAppModule();
|
|
|
|
// if it's from SS, the fullscreen flag will be set,
|
|
// need to override ContextMode passed in
|
|
if (_fScreenSaver)
|
|
pNewNode->Context = BM_SCREENSAVER;
|
|
else
|
|
pNewNode->Context = (ContextMode > BM_THEATER) ? BM_UNKNOWN : ContextMode;
|
|
|
|
#if 0 //do not open till urlmon support wininet query flag
|
|
DWORD dwOptions = 0;
|
|
DWORD dwSize;
|
|
WCHAR wszURL[MAX_URL_STRING];
|
|
|
|
AnsiToUnicode(lpUrl, wszURL, ARRAYSIZE(wszURL));
|
|
if (SUCCEEDED(CoInitialize(NULL)) &&
|
|
SUCCEEDED(CoInternetQueryInfo(wszURL, (QUERYOPTION)INTERNET_OPTION_REQUEST_FLAGS,
|
|
0, &dwOptions, sizeof(DWORD), &dwSize, 0)))
|
|
{
|
|
pNewNode->fuseCache = dwOptions & INTERNET_REQFLAG_FROM_CACHE;
|
|
CoUninitialize();
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
BYTE cei[MAX_CACHE_ENTRY_INFO_SIZE];
|
|
LPINTERNET_CACHE_ENTRY_INFO pcei = (LPINTERNET_CACHE_ENTRY_INFO)cei;
|
|
DWORD cbcei = MAX_CACHE_ENTRY_INFO_SIZE;
|
|
|
|
if (GetUrlCacheEntryInfo(lpUrl, pcei, &cbcei))
|
|
pNewNode->fuseCache = (pcei->dwHitRate - 1) ? TRUE : FALSE; // off 1 by download
|
|
else
|
|
pNewNode->fuseCache = 0;
|
|
|
|
}
|
|
|
|
SystemTimeToFileTime(&st, &(pNewNode->ftIn));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// OnUnLoad(LPTSTR lpUrl)
|
|
// current page is unloaded
|
|
// 1)find url cache entry and get file handle
|
|
// 2)calculate total time duration visiting this page
|
|
// 3)commit delta log string to file cache entry
|
|
// (lpUrl contains "Tracking: " prefix)
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CUrlTrackingStg :: OnUnload
|
|
(
|
|
IN LPCTSTR lpUrl
|
|
)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
LPTSTR lpPfxUrl = NULL;
|
|
LRecord* pNode = NULL;;
|
|
SYSTEMTIME st;
|
|
LPINTERNET_CACHE_ENTRY_INFO pce = NULL;
|
|
TCHAR lpFile[MAX_PATH];
|
|
|
|
|
|
//
|
|
GetLocalTime(&st);
|
|
|
|
pNode = FindCurrentNode(lpUrl);
|
|
if (!pNode)
|
|
{
|
|
TraceMsg(DM_ERROR, "CUrlTrackingStg: OnUnload (cannot find internal tracking log");
|
|
return hr;
|
|
}
|
|
|
|
//QueryCacheEntry() and OpenLogFile() can be combined in one if CacheAPI supports
|
|
//WriteUrlCacheEntryStream()
|
|
ConvertToPrefixedURL(lpUrl, &lpPfxUrl);
|
|
if (!lpPfxUrl)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pce = QueryCacheEntry(lpPfxUrl);
|
|
if (!pce)
|
|
{
|
|
TraceMsg(DM_ERROR, "CUrlTrackingStg: OnUnload (cannot find url cache entry)");
|
|
DeleteCurrentNode(pNode);
|
|
|
|
// free pce
|
|
GlobalFree(lpPfxUrl);
|
|
lpPfxUrl = NULL;
|
|
return hr;
|
|
}
|
|
|
|
// work around -- begin
|
|
hr = WininetWorkAround(lpPfxUrl, pce->lpszLocalFileName, &lpFile[0]);
|
|
if (FAILED(hr))
|
|
{
|
|
TraceMsg(DM_ERROR, "CUrlTrackingStg: OnUnload (failed to work around wininet)");
|
|
DeleteCurrentNode(pNode);
|
|
if (_hFile)
|
|
{
|
|
CloseHandle(_hFile);
|
|
_hFile = NULL;
|
|
}
|
|
GlobalFree(lpPfxUrl);
|
|
lpPfxUrl = NULL;
|
|
return hr;
|
|
}
|
|
|
|
hr = UpdateLogFile(pNode, &st);
|
|
|
|
// commit change to cache
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = (CommitUrlCacheEntry(lpPfxUrl,
|
|
lpFile, //
|
|
pce->ExpireTime, //ExpireTime
|
|
pce->LastModifiedTime, //LastModifiedTime
|
|
pce->CacheEntryType,
|
|
NULL, //lpHeaderInfo
|
|
0, //dwHeaderSize
|
|
NULL, //lpszFileExtension
|
|
0) ) ? //reserved
|
|
S_OK : E_FAIL;
|
|
}
|
|
|
|
// work around -- end
|
|
|
|
DeleteCurrentNode(pNode);
|
|
|
|
// free pce
|
|
GlobalFree(pce);
|
|
pce = NULL;
|
|
|
|
GlobalFree(lpPfxUrl);
|
|
lpPfxUrl = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Cache helper funcitons
|
|
// This is a workaround for Wininet cache
|
|
// Later when we commit change to URL cache will fail if localFile size is changed
|
|
// [IN] lpszSourceUrlName and lpszLocalFileName remain the same when calling
|
|
// this routine
|
|
// [OUT] new local file name
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT CUrlTrackingStg :: WininetWorkAround(LPCTSTR lpszUrl, LPCTSTR lpOldFile, LPTSTR lpFile)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
ASSERT(!_hFile);
|
|
|
|
if (!CreateUrlCacheEntry(lpszUrl, 512, TEXT("log"), lpFile, 0))
|
|
return E_FAIL;
|
|
|
|
if (lpOldFile)
|
|
{
|
|
if (!CopyFile(lpOldFile, lpFile, FALSE))
|
|
return E_FAIL;
|
|
|
|
DeleteFile(lpOldFile);
|
|
}
|
|
|
|
_hFile = OpenLogFile(lpFile);
|
|
|
|
if (_hFile != INVALID_HANDLE_VALUE)
|
|
_hFile = NULL;
|
|
|
|
return (_hFile) ? S_OK : E_FAIL;
|
|
}
|
|
|
|
LPINTERNET_CACHE_ENTRY_INFO
|
|
CUrlTrackingStg :: QueryCacheEntry
|
|
(
|
|
IN LPCTSTR lpUrl
|
|
)
|
|
{
|
|
// get cache entry info
|
|
LPINTERNET_CACHE_ENTRY_INFO lpCE = NULL;
|
|
DWORD dwEntrySize;
|
|
BOOL bret = FALSE;
|
|
|
|
lpCE = (LPINTERNET_CACHE_ENTRY_INFO)GlobalAlloc(LPTR, MAX_CACHE_ENTRY_INFO_SIZE);
|
|
if (lpCE)
|
|
{
|
|
dwEntrySize = MAX_CACHE_ENTRY_INFO_SIZE;
|
|
|
|
while (!(bret = GetUrlCacheEntryInfo(lpUrl, lpCE, &dwEntrySize)))
|
|
{
|
|
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
GlobalFree(lpCE);
|
|
|
|
lpCE = (LPINTERNET_CACHE_ENTRY_INFO)GlobalAlloc(LPTR, dwEntrySize);
|
|
if (!lpCE)
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!bret && lpCE)
|
|
{
|
|
GlobalFree(lpCE);
|
|
lpCE = NULL;
|
|
SetLastError(ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
return lpCE;
|
|
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// File helper funcitons
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
// 1)open log file
|
|
// 2)move file pointer to end of file
|
|
//
|
|
HANDLE
|
|
CUrlTrackingStg :: OpenLogFile
|
|
(
|
|
IN LPCTSTR lpFileName
|
|
)
|
|
{
|
|
HANDLE hFile = NULL;
|
|
|
|
hFile = CreateFile(lpFileName,
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL, // | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
return NULL;
|
|
|
|
return hFile;
|
|
|
|
}
|
|
|
|
const TCHAR c_szLogFormat[] = TEXT("hh':'mm':'ss");
|
|
const LPTSTR c_szMode[] = { TEXT("N"), // normal browsing
|
|
TEXT("S"), // screen saver
|
|
TEXT("D"), // desktop component
|
|
TEXT("T"), // theater mode
|
|
TEXT("U"), // unknown
|
|
};
|
|
|
|
HRESULT
|
|
CUrlTrackingStg :: UpdateLogFile
|
|
(
|
|
IN LRecord* pNode,
|
|
IN SYSTEMTIME* pst
|
|
)
|
|
{
|
|
FILETIME ftOut;
|
|
DWORD dwWritten= 0;
|
|
HRESULT hr = E_FAIL;
|
|
ULARGE_INTEGER ulIn, ulOut, ulTotal;
|
|
|
|
ASSERT(_hFile);
|
|
|
|
// calculate delta of time
|
|
SystemTimeToFileTime(pst, &ftOut);
|
|
|
|
// #34829: use 64-bit calculation
|
|
ulIn.LowPart = pNode->ftIn.dwLowDateTime;
|
|
ulIn.HighPart = pNode->ftIn.dwHighDateTime;
|
|
ulOut.LowPart = ftOut.dwLowDateTime;
|
|
ulOut.HighPart = ftOut.dwHighDateTime;
|
|
QUAD_PART(ulTotal) = QUAD_PART(ulOut) - QUAD_PART(ulIn);
|
|
|
|
ftOut.dwLowDateTime = ulTotal.LowPart;
|
|
ftOut.dwHighDateTime = ulTotal.HighPart;
|
|
|
|
// log string: timeEnter+Duration
|
|
SYSTEMTIME stOut, stIn;
|
|
TCHAR lpLogString[MY_MAX_STRING_LEN];
|
|
TCHAR pTimeIn[10], pTimeOut[10];
|
|
|
|
FileTimeToSystemTime(&ftOut, &stOut);
|
|
FileTimeToSystemTime(&(pNode->ftIn), &stIn);
|
|
|
|
GetTimeFormat(LOCALE_SYSTEM_DEFAULT, TIME_FORCE24HOURFORMAT, &stIn, c_szLogFormat, pTimeIn, 10);
|
|
GetTimeFormat(LOCALE_SYSTEM_DEFAULT, TIME_FORCE24HOURFORMAT, &stOut, c_szLogFormat, pTimeOut, 10);
|
|
// #34832: add Date in logs
|
|
// #28266: add LFCR in logs
|
|
lpLogString[0] = '\0';
|
|
wnsprintf(lpLogString, ARRAYSIZE(lpLogString), TEXT("%s %d %.2d-%.2d-%d %s %s\r\n"),
|
|
c_szMode[pNode->Context],
|
|
pNode->fuseCache,
|
|
stIn.wMonth, stIn.wDay, stIn.wYear,
|
|
pTimeIn, pTimeOut);
|
|
|
|
// move file pointer to end
|
|
if (0xFFFFFFFF == SetFilePointer(_hFile, 0, 0, FILE_END))
|
|
{
|
|
CloseHandle(_hFile);
|
|
_hFile = NULL;
|
|
return hr;
|
|
}
|
|
|
|
// write ANSI string to file
|
|
char szLogInfo[MY_MAX_STRING_LEN];
|
|
|
|
SHTCharToAnsi(lpLogString, szLogInfo, ARRAYSIZE(szLogInfo));
|
|
hr = (WriteFile(_hFile, szLogInfo, lstrlenA(szLogInfo), &dwWritten, NULL)) ?
|
|
S_OK : E_FAIL;
|
|
|
|
CloseHandle(_hFile);
|
|
_hFile = NULL;
|
|
return hr;
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// ReadTrackingPrefix
|
|
//
|
|
// read prefix string from registry
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
CUrlTrackingStg :: ReadTrackingPrefix(void)
|
|
{
|
|
DWORD cbPfx = 0;
|
|
struct {
|
|
INTERNET_CACHE_CONTAINER_INFO cInfo;
|
|
TCHAR szBuffer[MAX_PATH+MAX_PATH];
|
|
} ContainerInfo;
|
|
DWORD dwModified, dwContainer;
|
|
HANDLE hEnum;
|
|
|
|
dwContainer = sizeof(ContainerInfo);
|
|
hEnum = FindFirstUrlCacheContainer(&dwModified,
|
|
&ContainerInfo.cInfo,
|
|
&dwContainer,
|
|
0);
|
|
|
|
if (hEnum)
|
|
{
|
|
|
|
for (;;)
|
|
{
|
|
if (!StrCmpI(ContainerInfo.cInfo.lpszName, c_szLogContainer))
|
|
{
|
|
DWORD cch = lstrlen(ContainerInfo.cInfo.lpszCachePrefix)+1;
|
|
ASSERT(ContainerInfo.cInfo.lpszCachePrefix[0]);
|
|
|
|
_lpPfx = (LPTSTR)GlobalAlloc(LPTR, cch * sizeof(TCHAR));
|
|
if (!_lpPfx)
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
|
|
StrCpyN(_lpPfx, ContainerInfo.cInfo.lpszCachePrefix, cch);
|
|
break;
|
|
}
|
|
|
|
dwContainer = sizeof(ContainerInfo);
|
|
if (!FindNextUrlCacheContainer(hEnum, &ContainerInfo.cInfo, &dwContainer))
|
|
{
|
|
if (GetLastError() == ERROR_NO_MORE_ITEMS)
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
FindCloseUrlCache(hEnum);
|
|
}
|
|
}
|
|
|
|
|
|
// caller must free lplpPrefixedUrl
|
|
BOOL
|
|
CUrlTrackingStg :: ConvertToPrefixedURL(LPCTSTR lpszUrl, LPTSTR *lplpPrefixedUrl)
|
|
{
|
|
BOOL bret = FALSE;
|
|
|
|
ASSERT(lpszUrl);
|
|
if (!lpszUrl)
|
|
return bret;
|
|
|
|
//ASSERT(lplpPrefixedUrl);
|
|
|
|
if (!_lpPfx)
|
|
ReadTrackingPrefix();
|
|
|
|
if (_lpPfx)
|
|
{
|
|
int len = lstrlen(lpszUrl) + lstrlen(_lpPfx) + 1;
|
|
|
|
*lplpPrefixedUrl = (LPTSTR)GlobalAlloc(LPTR, len * sizeof(TCHAR));
|
|
if (*lplpPrefixedUrl)
|
|
{
|
|
wnsprintf(*lplpPrefixedUrl, len, TEXT("%s%s"), _lpPfx, lpszUrl);
|
|
bret = TRUE;
|
|
}
|
|
}
|
|
|
|
return bret;
|
|
}
|