archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/inetsrv/iis/svcs/infocomm/log/scripting/logscripting.cpp

1213 lines
30 KiB
Raw Blame History

/*++
Copyright (c) 1998 Microsoft Corporation
Module Name :
logscripting.cpp
Abstract:
LogScripting.cpp : Implementation of CLogScripting
Automation compatible logging interface
Author:
Saurab Nog ( saurabn ) 01-Feb-1998
Project:
IIS Logging 5.0
--*/
#include "stdafx.h"
#include "script.h"
#include <initguid.h>
#include <InetCom.h>
#include <LogType.h>
#include <ILogObj.hxx>
#include <limits.h>
#include <iadmw.h>
#include <iiscnfg.h>
#include <atlimpl.cpp>
#include "LogScripting.h"
const int MB_TIMEOUT = 5000;
/////////////////////////////////////////////////////////////////////////////
// CLogScripting
CLogScripting::CLogScripting(VOID)
:
m_iNumPlugins ( -1),
m_iReadPlugin ( -1),
m_iWritePlugin ( -1),
m_pPluginInfo ( NULL),
m_fDirectory ( false),
m_fEndOfReadRecords ( true),
m_StartDateTime ( LONG_MIN),
m_EndDateTime ( LONG_MAX),
m_hDirSearchHandle ( INVALID_HANDLE_VALUE)
{
m_wcsReadFileName[0] = 0;
m_wcsReadDirectoryName[0] = 0;
}
/* ************************************************************************* */
/* ************************************************************************* */
HRESULT CLogScripting::FinalConstruct()
{
m_pMBCom = NULL;
::CoCreateInstance(GETAdminBaseCLSID(TRUE), NULL, CLSCTX_LOCAL_SERVER,
IID_IMSAdminBase, (void **)(&m_pMBCom));
if (m_pMBCom)
{
CreateAllPlugins();
}
return S_OK;
}
/* ************************************************************************* */
/* ************************************************************************* */
void CLogScripting::FinalRelease()
{
if ( m_pMBCom )
{
m_pMBCom->Release();
m_pMBCom = NULL;
}
for(int i=0; i< m_iNumPlugins; i++)
{
if ( NULL != m_pPluginInfo[i].pILogScripting)
{
m_pPluginInfo[i].pILogScripting->CloseLogFiles(AllOpenFiles);
m_pPluginInfo[i].pILogScripting->Release();
m_pPluginInfo[i].pILogScripting = NULL;
}
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// Private Methods of CLogScripting
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
int CLogScripting:: CreateAllPlugins()
{
int i,j = 0;
HRESULT hr;
typedef ILogScripting *pILogScripting;
m_iNumPlugins = 0;
if (GetListOfAvailablePlugins() && (m_iNumPlugins > 0))
{
//
// Load all the plugins
//
for (i=j=0; i<m_iNumPlugins; i++)
{
hr = ::CoCreateInstance(m_pPluginInfo[i].clsid, NULL, CLSCTX_INPROC_SERVER,
IID_ILogScripting, (void **)(& m_pPluginInfo[i].pILogScripting));
if (SUCCEEDED(hr))
{
j++;
}
else
{
m_pPluginInfo[i].pILogScripting = NULL;
}
}
}
return j; // Number of plugins successfully created.
}
/* ************************************************************************* */
/* ************************************************************************* */
bool CLogScripting::GetListOfAvailablePlugins()
{
USES_CONVERSION;
m_pPluginInfo = new PLUGIN_INFO[4];
if( m_pPluginInfo == NULL )
{
return false;
}
wcscpy(m_pPluginInfo[0].wcsFriendlyName, L"NCSA Common Log File Format");
CLSIDFromString(A2W(NCSALOG_CLSID), &m_pPluginInfo[0].clsid);
wcscpy(m_pPluginInfo[1].wcsFriendlyName, L"ODBC Logging");
CLSIDFromString(A2W(ODBCLOG_CLSID), &m_pPluginInfo[1].clsid);
wcscpy(m_pPluginInfo[2].wcsFriendlyName, L"Microsoft IIS Log File Format");
CLSIDFromString(A2W(ASCLOG_CLSID), &m_pPluginInfo[2].clsid);
wcscpy(m_pPluginInfo[3].wcsFriendlyName, L"W3C Extended Log File Format");
CLSIDFromString(A2W(EXTLOG_CLSID), &m_pPluginInfo[3].clsid);
m_iNumPlugins = 4;
return true;
}
/* ************************************************************************* */
/* ************************************************************************* */
bool CLogScripting::GetNextFileName()
{
WIN32_FIND_DATAW stFindFileData;
PFileListEntry pFileInfo;
if (NULL == m_hDirSearchHandle)
{
return false;
}
if (INVALID_HANDLE_VALUE == m_hDirSearchHandle)
{
//
// This is the first/new call. Clean up file Q by removing old file information.
//
while(! m_fQueue.empty())
{
pFileInfo = m_fQueue.top();
m_fQueue.pop();
delete pFileInfo;
}
//
// Loop till we enumerate all files in this directory
//
WCHAR wcsSearchPath[MAX_PATH+1];
wcscpy(wcsSearchPath, m_wcsReadDirectoryName);
wcscat(wcsSearchPath, L"\\*");
if (m_hDirSearchHandle)
{
FindClose(m_hDirSearchHandle);
}
m_hDirSearchHandle = FindFirstFileW(wcsSearchPath, &stFindFileData);
do
{
if (! (stFindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
pFileInfo = new FileListEntry;
pFileInfo->Copy(stFindFileData);
m_fQueue.push(pFileInfo);
}
}
while ( FindNextFileW(m_hDirSearchHandle, &stFindFileData) );
}
//
// Pop the lowest timestamp file
//
pFileInfo = NULL;
if (! m_fQueue.empty())
{
pFileInfo = m_fQueue.top();
m_fQueue.pop();
}
if (NULL == pFileInfo)
{
//
// We have run out of files or some error occured. Prevent another search.
//
FindClose(m_hDirSearchHandle);
m_hDirSearchHandle = NULL;
m_wcsReadFileName[0] = 0;
return false;
}
else
{
wcscpy(m_wcsReadFileName, m_wcsReadDirectoryName);
wcscat(m_wcsReadFileName, L"\\");
wcscat(m_wcsReadFileName, pFileInfo->wcsFileName);
delete pFileInfo;
return true;
}
}
/* ************************************************************************* */
/* ************************************************************************* */
int CLogScripting::ParseLogFile()
{
if (m_wcsReadFileName[0] == 0)
{
return INVALID_PLUGIN;
}
//
// Linear search thru all plugins
//
for(int i=0; i < m_iNumPlugins; i++)
{
if ( m_pPluginInfo[i].pILogScripting != NULL )
{
m_pPluginInfo[i].pILogScripting->OpenLogFile(
W2BSTR(m_wcsReadFileName),
ForReading,
L"",
0,
L""
);
if ( SUCCEEDED(m_pPluginInfo[i].pILogScripting->ReadLogRecord()) )
{
return i;
}
m_pPluginInfo[i].pILogScripting->CloseLogFiles(ForReading);
}
}
//
// None of the registered plugins knows how to read the log file. Sorry !!
//
return INVALID_PLUGIN;
}
/* ************************************************************************* */
/* ************************************************************************* */
HRESULT CLogScripting::InternalReadLogRecord()
{
DATE logDateTime = 0;
HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS);
if (!m_fDirectory)
{
//
// Simple case. Not a directory.
//
if ( INVALID_PLUGIN == m_iReadPlugin )
{
//
// First use. Find a plugin to read the file.
//
if ( (m_iReadPlugin = ParseLogFile()) != INVALID_PLUGIN)
{
hr = S_OK;
}
}
else
{
//
// Read next record
//
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->ReadLogRecord();
}
}
else
{
//
// Directory case
//
if (m_iReadPlugin != INVALID_PLUGIN)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->ReadLogRecord();
if (SUCCEEDED(hr))
{
goto returnlabel;
}
}
//
// Either this is the first use or the last read failed
//
while (GetNextFileName())
{
if ( (m_iReadPlugin = ParseLogFile()) != INVALID_PLUGIN)
{
hr = S_OK;
break;
}
}
}
returnlabel:
return hr;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
// Methods of ILogRead
//
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CLogScripting::OpenLogFile(
BSTR szLogFileName,
IOMode Mode,
BSTR szServiceName,
long iServiceInstance,
BSTR szOutputLogFileFormat
)
{
DWORD dwFileAttrib;
HRESULT hr = E_INVALIDARG;
WCHAR szFilePath[MAX_PATH+1];
BOOL fHasFileName = (( NULL != szLogFileName) && ( 0 != szLogFileName[0]));
BOOL fHasServiceName = (( NULL != szServiceName) && ( 0 != szServiceName[0]));
BOOL fHasOutputFormatName = (( NULL != szOutputLogFileFormat) &&
( 0 != szOutputLogFileFormat[0]));
CloseLogFiles(Mode);
if (ForReading == Mode)
{
//
// If the File Name isn't specified but Service Name & ID are, get
// the appropriate log directory and use that as the log file name.
//
if ( (!fHasFileName) && fHasServiceName && ( 0 != iServiceInstance))
{
METADATA_HANDLE hMeta = NULL;
METADATA_RECORD mdRecord;
WCHAR szTemp[MAX_PATH+1] = L"/LM/";
DWORD dwRequiredLen;
if (m_pMBCom == NULL)
{
hr = E_FAIL;
goto cleanup;
}
if (wcslen(szServiceName) > MAX_PATH+1 - sizeof("/LM//4294967296"))
{
hr = E_INVALIDARG;
goto cleanup;
}
wcscat(szTemp, szServiceName);
wcscat(szTemp, L"/");
_ltow(iServiceInstance, szTemp+wcslen(szTemp),10);
hr = m_pMBCom->OpenKey( METADATA_MASTER_ROOT_HANDLE, szTemp,
METADATA_PERMISSION_READ, MB_TIMEOUT, &hMeta);
if ( FAILED(hr))
{
goto cleanup;
}
//
// prepare the metadata record for reading
//
mdRecord.dwMDIdentifier = MD_LOGFILE_DIRECTORY;
mdRecord.dwMDAttributes = METADATA_INHERIT;
mdRecord.dwMDUserType = IIS_MD_UT_SERVER;
mdRecord.dwMDDataType = EXPANDSZ_METADATA;
mdRecord.pbMDData = (PBYTE)szTemp;
mdRecord.dwMDDataLen = MAX_PATH;
hr = m_pMBCom->GetData(hMeta, L"", &mdRecord, &dwRequiredLen);
m_pMBCom->CloseKey(hMeta);
if ( FAILED(hr))
{
goto cleanup;
}
//
// Expand system variables used in this path.
//
if (ExpandEnvironmentStringsW(szTemp, szFilePath, MAX_PATH+1) != 0)
{
if ( wcslen(szFilePath) > MAX_PATH-wcslen(szServiceName)-10 )
{
hr = E_OUTOFMEMORY;
goto cleanup;
}
wcscat(szFilePath,L"\\");
wcscat(szFilePath,szServiceName);
_ltow(iServiceInstance, szFilePath+wcslen(szFilePath),10);
wcscat(szFilePath,L"\\");
szLogFileName = szFilePath;
}
}
}
//
// At this point szLogFileName should be defined.
//
hr = E_INVALIDARG;
if ( (NULL == szLogFileName ) || ( 0 == szLogFileName[0]) ||
((ForReading != Mode ) && (ForWriting != Mode))
)
{
goto cleanup;
}
if (ForReading == Mode)
{
//
// Reset EOF flag
//
m_fEndOfReadRecords = false;
//
// Check if this is a valid file and/or a directory
//
if ( 0xFFFFFFFF != (dwFileAttrib = GetFileAttributesW(szLogFileName)) )
{
if (dwFileAttrib & FILE_ATTRIBUTE_DIRECTORY)
{
// This is a directory
m_fDirectory = true;
wcscpy(m_wcsReadDirectoryName, szLogFileName);
}
else
{
wcscpy(m_wcsReadFileName, szLogFileName);
}
hr = S_OK;
}
else
{
// couldn't get file attributes. check for error code
hr = HRESULT_FROM_WIN32(GetLastError());
}
}
else
{
//
// Find the correct plugin & set the value. If user didn't specify file format use W3C
//
if ( ( NULL == szOutputLogFileFormat) ||
( 0 == *szOutputLogFileFormat)
)
{
//
// Search based on the clsid of W3C Logging
//
for(int i=0; i< m_iNumPlugins; i++)
{
if ( (CLSID_EXTLOG == m_pPluginInfo[i].clsid) &&
(NULL != m_pPluginInfo[i].pILogScripting)
)
{
m_iWritePlugin = i;
break;
}
}
}
else
{
//
// Search based on format name provided by the user
//
for(int i=0; i< m_iNumPlugins; i++)
{
if ( (0 == _wcsicmp(m_pPluginInfo[i].wcsFriendlyName,
szOutputLogFileFormat)) &&
(NULL != m_pPluginInfo[i].pILogScripting)
)
{
m_iWritePlugin = i;
break;
}
}
}
if (0 <= m_iWritePlugin)
{
hr = m_pPluginInfo[m_iWritePlugin].pILogScripting->OpenLogFile(
W2BSTR(szLogFileName),
Mode,
L"",
0,
L"");
}
}
cleanup:
/*
fix for bug 364649:
No need to do that becuase oleaut does some thicks with mem allocation and free.
That's true for both cscirtp and ASP, so I choose to remove these deltions. Even if
I am wrong, and it necesasry to free somehow that string, it is better to leak ~20 bytes than
AV or currupt memory while deleting what was not allocated by sysallocstring
if (fHasFileName)
{
SysFreeString(szLogFileName);
}
if (fHasServiceName)
{
SysFreeString(szServiceName);
}
if (fHasOutputFormatName)
{
SysFreeString(szOutputLogFileFormat);
}
*/
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::CloseLogFiles(IOMode Mode)
{
if ((ForReading == Mode) || (AllOpenFiles == Mode))
{
if (m_iReadPlugin != INVALID_PLUGIN)
{
m_pPluginInfo[m_iReadPlugin].pILogScripting->CloseLogFiles(ForReading);
}
m_iReadPlugin = INVALID_PLUGIN; // Reset Plugin in Use
m_fDirectory = false;
m_hDirSearchHandle = INVALID_HANDLE_VALUE; // Reset Search Handle
m_wcsReadFileName[0] = 0;
m_wcsReadDirectoryName[0] = 0;
}
if ((ForWriting == Mode) || (AllOpenFiles == Mode))
{
if (m_iWritePlugin != INVALID_PLUGIN)
{
m_pPluginInfo[m_iWritePlugin].pILogScripting->CloseLogFiles(ForWriting);
}
m_iWritePlugin = INVALID_PLUGIN; // Reset Plugin in Use
}
return S_OK;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::ReadFilter( DATE startDateTime, DATE endDateTime)
{
m_StartDateTime = startDateTime;
m_EndDateTime = endDateTime;
return S_OK;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::ReadLogRecord()
{
HRESULT hr = E_FAIL;
VARIANT logDateTime = {0};
if ( m_fEndOfReadRecords )
{
return S_OK;
}
//
// Read the next record. Only return records between the start & end times.
//
while ( SUCCEEDED( hr = InternalReadLogRecord() ) )
{
if ( SUCCEEDED(m_pPluginInfo[m_iReadPlugin].pILogScripting->get_DateTime(&logDateTime)) )
{
if ( (m_StartDateTime > logDateTime.date) || (m_EndDateTime < logDateTime.date))
{
//
// Read next record
//
continue;
}
}
break;
}
if ( FAILED(hr))
{
m_fEndOfReadRecords = true;
hr = S_OK;
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::AtEndOfLog(VARIANT_BOOL *pfEndOfRead)
{
DBG_ASSERT( NULL != pfEndOfRead);
*pfEndOfRead = m_fEndOfReadRecords;
return S_OK;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::WriteLogRecord(ILogScripting * pILogScripting)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pILogScripting);
if (m_iWritePlugin >= 0)
{
hr = m_pPluginInfo[m_iWritePlugin].pILogScripting->WriteLogRecord(pILogScripting);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_DateTime(VARIANT * pvarDateTime)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarDateTime);
if (m_fEndOfReadRecords)
{
pvarDateTime->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_DateTime(pvarDateTime);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ServiceName(VARIANT * pvarServiceName)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarServiceName);
if (m_fEndOfReadRecords)
{
pvarServiceName->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ServiceName(pvarServiceName);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ServerName(VARIANT * pvarServerName)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarServerName);
if (m_fEndOfReadRecords)
{
pvarServerName->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ServerName(pvarServerName);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ClientIP(VARIANT * pvarClientIP)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarClientIP);
if (m_fEndOfReadRecords)
{
pvarClientIP->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ClientIP(pvarClientIP);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_UserName(VARIANT * pvarUserName)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarUserName);
if (m_fEndOfReadRecords)
{
pvarUserName->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_UserName(pvarUserName);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ServerIP(VARIANT * pvarServerIP)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarServerIP);
if (m_fEndOfReadRecords)
{
pvarServerIP->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ServerIP(pvarServerIP);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_Method(VARIANT * pvarMethod)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarMethod);
if (m_fEndOfReadRecords)
{
pvarMethod->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_Method(pvarMethod);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_URIStem(VARIANT * pvarURIStem)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarURIStem);
if (m_fEndOfReadRecords)
{
pvarURIStem->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_URIStem(pvarURIStem);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_URIQuery(VARIANT * pvarURIQuery)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarURIQuery);
if (m_fEndOfReadRecords)
{
pvarURIQuery->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_URIQuery(pvarURIQuery);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_TimeTaken(VARIANT * pvarTimeTaken)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarTimeTaken);
if (m_fEndOfReadRecords)
{
pvarTimeTaken->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_TimeTaken(pvarTimeTaken);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_BytesSent(VARIANT * pvarBytesSent)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarBytesSent);
if (m_fEndOfReadRecords)
{
pvarBytesSent->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_BytesSent(pvarBytesSent);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_BytesReceived(VARIANT * pvarBytesReceived)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarBytesReceived);
if (m_fEndOfReadRecords)
{
pvarBytesReceived->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_BytesReceived(pvarBytesReceived);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_Win32Status(VARIANT * pvarWin32Status)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarWin32Status);
if (m_fEndOfReadRecords)
{
pvarWin32Status->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_Win32Status(pvarWin32Status);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ProtocolStatus(VARIANT * pvarProtocolStatus)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarProtocolStatus);
if (m_fEndOfReadRecords)
{
pvarProtocolStatus->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ProtocolStatus(pvarProtocolStatus);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ServerPort(VARIANT * pvarServerPort)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarServerPort);
if (m_fEndOfReadRecords)
{
pvarServerPort->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ServerPort(pvarServerPort);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_ProtocolVersion(VARIANT * pvarProtocolVersion)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarProtocolVersion);
if (m_fEndOfReadRecords)
{
pvarProtocolVersion->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_ProtocolVersion(pvarProtocolVersion);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_UserAgent(VARIANT * pvarUserAgent)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarUserAgent);
if (m_fEndOfReadRecords)
{
pvarUserAgent->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_UserAgent(pvarUserAgent);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_Cookie(VARIANT * pvarCookie)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarCookie);
if (m_fEndOfReadRecords)
{
pvarCookie->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_Cookie(pvarCookie);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_Referer(VARIANT * pvarReferer)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarReferer);
if (m_fEndOfReadRecords)
{
pvarReferer->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_Referer(pvarReferer);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */
STDMETHODIMP
CLogScripting::get_CustomFields(VARIANT * pvarCustomFieldsArray)
{
HRESULT hr = E_FAIL;
DBG_ASSERT( NULL != pvarCustomFieldsArray);
if (m_fEndOfReadRecords)
{
pvarCustomFieldsArray->vt = VT_NULL;
return S_OK;
}
if (m_iReadPlugin >= 0)
{
hr = m_pPluginInfo[m_iReadPlugin].pILogScripting->get_CustomFields(pvarCustomFieldsArray);
}
return hr;
}
/* ************************************************************************* */
/* ************************************************************************* */