3375 lines
98 KiB
C++
3375 lines
98 KiB
C++
|
/*++
|
||
|
|
|
||
|
|
Copyright (c) 2000 Microsoft Corporation
|
||
|
|
|
||
|
|
Module Name:
|
||
|
|
|
||
|
|
compression.cxx
|
||
|
|
|
||
|
|
Abstract:
|
||
|
|
|
||
|
|
Do Http compression
|
||
|
|
|
||
|
|
Author:
|
||
|
|
|
||
|
|
Anil Ruia (AnilR) 10-Apr-2000
|
||
|
|
|
||
|
|
--*/
|
||
|
|
|
||
|
|
#include "precomp.hxx"
|
||
|
|
|
||
|
|
#define HTTP_COMPRESSION_KEY L"/LM/w3svc/Filters/Compression"
|
||
|
|
#define HTTP_COMPRESSION_PARAMETERS L"Parameters"
|
||
|
|
#define COMP_FILE_PREFIX L"$^_"
|
||
|
|
#define TEMP_COMP_FILE_SUFFIX L"~TMP~"
|
||
|
|
|
||
|
|
// mask for clearing bits when comparing file acls
|
||
|
|
#define ACL_CLEAR_BIT_MASK (~(SE_DACL_AUTO_INHERITED | \
|
||
|
|
SE_SACL_AUTO_INHERITED | \
|
||
|
|
SE_DACL_PROTECTED | \
|
||
|
|
SE_SACL_PROTECTED))
|
||
|
|
|
||
|
|
#define HEX_TO_ASCII(c) ((CHAR)((c) < 10 ? ((c) + '0') : ((c) + 'a' - 10)))
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// static variables
|
||
|
|
//
|
||
|
|
COMPRESSION_SCHEME *HTTP_COMPRESSION::sm_pCompressionSchemes[MAX_SERVER_SCHEMES];
|
||
|
|
LIST_ENTRY HTTP_COMPRESSION::sm_CompressionThreadWorkQueue;
|
||
|
|
CRITICAL_SECTION HTTP_COMPRESSION::sm_CompressionThreadLock;
|
||
|
|
CRITICAL_SECTION HTTP_COMPRESSION::sm_CompressionDirectoryLock;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwNumberOfSchemes = 0;
|
||
|
|
STRU *HTTP_COMPRESSION::sm_pstrCompressionDirectory = NULL;
|
||
|
|
STRA *HTTP_COMPRESSION::sm_pstrCacheControlHeader = NULL;
|
||
|
|
STRA *HTTP_COMPRESSION::sm_pstrExpiresHeader = NULL;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fDoStaticCompression = FALSE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fDoDynamicCompression = FALSE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fDoOnDemandCompression = TRUE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fDoDiskSpaceLimiting = FALSE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fNoCompressionForHttp10 = TRUE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fNoCompressionForProxies = FALSE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fNoCompressionForRange = TRUE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fSendCacheHeaders = TRUE;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwMaxDiskSpaceUsage = COMPRESSION_DEFAULT_DISK_SPACE_USAGE;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwIoBufferSize = COMPRESSION_DEFAULT_BUFFER_SIZE;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwCompressionBufferSize = COMPRESSION_DEFAULT_BUFFER_SIZE;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwMaxQueueLength = COMPRESSION_DEFAULT_QUEUE_LENGTH;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwFilesDeletedPerDiskFree = COMPRESSION_DEFAULT_FILES_DELETED_PER_DISK_FREE;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwMinFileSizeForCompression = COMPRESSION_DEFAULT_FILE_SIZE_FOR_COMPRESSION;
|
||
|
|
PBYTE HTTP_COMPRESSION::sm_pIoBuffer = NULL;
|
||
|
|
PBYTE HTTP_COMPRESSION::sm_pCompressionBuffer = NULL;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwCurrentDiskSpaceUsage = 0;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fCompressionVolumeIsFat = FALSE;
|
||
|
|
HANDLE HTTP_COMPRESSION::sm_hThreadEvent = NULL;
|
||
|
|
HANDLE HTTP_COMPRESSION::sm_hCompressionThreadHandle = NULL;
|
||
|
|
DWORD HTTP_COMPRESSION::sm_dwCurrentQueueLength = 0;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fHttpCompressionInitialized = FALSE;
|
||
|
|
BOOL HTTP_COMPRESSION::sm_fIsTerminating = FALSE;
|
||
|
|
|
||
|
|
ALLOC_CACHE_HANDLER *COMPRESSION_BUFFER::allocHandler;
|
||
|
|
ALLOC_CACHE_HANDLER *COMPRESSION_CONTEXT::allocHandler;
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::Initialize()
|
||
|
|
/*++
|
||
|
|
Synopsis
|
||
|
|
Initialize function called during Server startup
|
||
|
|
|
||
|
|
Returns
|
||
|
|
HRESULT
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Construct some static variables
|
||
|
|
//
|
||
|
|
sm_pstrCompressionDirectory = new STRU;
|
||
|
|
sm_pstrCacheControlHeader = new STRA;
|
||
|
|
sm_pstrExpiresHeader = new STRA;
|
||
|
|
if (sm_pstrCompressionDirectory == NULL ||
|
||
|
|
sm_pstrCacheControlHeader == NULL ||
|
||
|
|
sm_pstrExpiresHeader == NULL)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
if (FAILED(hr = sm_pstrCompressionDirectory->Copy(
|
||
|
|
L"%windir%\\IIS Temporary Compressed Files")) ||
|
||
|
|
FAILED(hr = sm_pstrCacheControlHeader->Copy("maxage=86400")) ||
|
||
|
|
FAILED(hr = sm_pstrExpiresHeader->Copy(
|
||
|
|
"Wed, 01 Jan 1997 12:00:00 GMT")))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
MB mb(g_pW3Server->QueryMDObject());
|
||
|
|
if (!mb.Open(HTTP_COMPRESSION_KEY))
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read the global configuration from the metabase
|
||
|
|
//
|
||
|
|
if (FAILED(hr = ReadMetadata(&mb)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read in all the compression schemes and initialize them
|
||
|
|
//
|
||
|
|
if (FAILED(hr = InitializeCompressionSchemes(&mb)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
mb.Close();
|
||
|
|
|
||
|
|
if (FAILED(hr = COMPRESSION_CONTEXT::Initialize()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = COMPRESSION_BUFFER::Initialize()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Initialize other stuff
|
||
|
|
//
|
||
|
|
sm_pIoBuffer = new BYTE[sm_dwIoBufferSize];
|
||
|
|
sm_pCompressionBuffer = new BYTE[sm_dwCompressionBufferSize];
|
||
|
|
if (!sm_pIoBuffer || !sm_pCompressionBuffer)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
||
|
|
}
|
||
|
|
|
||
|
|
INITIALIZE_CRITICAL_SECTION(&sm_CompressionDirectoryLock);
|
||
|
|
|
||
|
|
if (FAILED(hr = InitializeCompressionDirectory()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = InitializeCompressionThread()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fHttpCompressionInitialized = TRUE;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
DWORD WINAPI HTTP_COMPRESSION::CompressionThread(LPVOID)
|
||
|
|
/*++
|
||
|
|
Synopsis
|
||
|
|
Entry point for the thread which takes Compression work-items off the
|
||
|
|
queue and processes them
|
||
|
|
|
||
|
|
Arguments and Return Values are ignored
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
BOOL fTerminate = FALSE;
|
||
|
|
|
||
|
|
while (!fTerminate)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Wait for some item to appear on the work queue
|
||
|
|
//
|
||
|
|
if (WaitForSingleObject(sm_hThreadEvent, INFINITE) == WAIT_FAILED)
|
||
|
|
{
|
||
|
|
DBG_ASSERT(FALSE);
|
||
|
|
}
|
||
|
|
|
||
|
|
EnterCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
|
||
|
|
while (!IsListEmpty(&sm_CompressionThreadWorkQueue))
|
||
|
|
{
|
||
|
|
LIST_ENTRY *listEntry =
|
||
|
|
RemoveHeadList(&sm_CompressionThreadWorkQueue);
|
||
|
|
|
||
|
|
LeaveCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
|
||
|
|
COMPRESSION_WORK_ITEM *workItem =
|
||
|
|
CONTAINING_RECORD(listEntry,
|
||
|
|
COMPRESSION_WORK_ITEM,
|
||
|
|
ListEntry);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Look at what the work item exactly is
|
||
|
|
//
|
||
|
|
if(workItem->WorkItemType == COMPRESSION_WORK_ITEM_TERMINATE)
|
||
|
|
{
|
||
|
|
fTerminate = TRUE;
|
||
|
|
}
|
||
|
|
else if (!fTerminate)
|
||
|
|
{
|
||
|
|
if (workItem->WorkItemType == COMPRESSION_WORK_ITEM_DELETE)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// special scheme to indicate that this item is for
|
||
|
|
// deletion, not compression
|
||
|
|
//
|
||
|
|
DeleteFile(workItem->strPhysicalPath.QueryStr());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DBG_ASSERT(workItem->WorkItemType == COMPRESSION_WORK_ITEM_COMPRESS);
|
||
|
|
|
||
|
|
CompressFile(workItem->scheme,
|
||
|
|
workItem->strPhysicalPath);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
delete workItem;
|
||
|
|
|
||
|
|
EnterCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
}
|
||
|
|
|
||
|
|
LeaveCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// We are terminating, close the Event handle
|
||
|
|
//
|
||
|
|
CloseHandle(sm_hThreadEvent);
|
||
|
|
sm_hThreadEvent = NULL;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::InitializeCompressionThread()
|
||
|
|
/*++
|
||
|
|
Initialize stuff related to the Compression Thread
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
InitializeListHead(&sm_CompressionThreadWorkQueue);
|
||
|
|
INITIALIZE_CRITICAL_SECTION(&sm_CompressionThreadLock);
|
||
|
|
|
||
|
|
sm_hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
|
|
if (sm_hThreadEvent == NULL)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD threadId;
|
||
|
|
sm_hCompressionThreadHandle = CreateThread(NULL, 0,
|
||
|
|
CompressionThread,
|
||
|
|
NULL, 0,
|
||
|
|
&threadId);
|
||
|
|
if (sm_hCompressionThreadHandle == NULL)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
}
|
||
|
|
|
||
|
|
// CODEWORK: configurable?
|
||
|
|
SetThreadPriority(sm_hCompressionThreadHandle, THREAD_PRIORITY_LOWEST);
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::InitializeCompressionDirectory()
|
||
|
|
/*++
|
||
|
|
Setup stuff related to the compression directory
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
WIN32_FILE_ATTRIBUTE_DATA fileInformation;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Find if the directory exists, if not create it
|
||
|
|
//
|
||
|
|
if (!GetFileAttributesEx(sm_pstrCompressionDirectory->QueryStr(),
|
||
|
|
GetFileExInfoStandard,
|
||
|
|
&fileInformation))
|
||
|
|
{
|
||
|
|
if (!CreateDirectory(sm_pstrCompressionDirectory->QueryStr(), NULL))
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (!(fileInformation.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sm_fDoDiskSpaceLimiting)
|
||
|
|
{
|
||
|
|
sm_dwCurrentDiskSpaceUsage = 0;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Find usage in the directory
|
||
|
|
//
|
||
|
|
STACK_STRU (CompDirWildcard, 512);
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
if (FAILED(hr = CompDirWildcard.Copy(*sm_pstrCompressionDirectory)) ||
|
||
|
|
FAILED(hr = CompDirWildcard.Append(L"\\", 1)) ||
|
||
|
|
FAILED(hr = CompDirWildcard.Append(COMP_FILE_PREFIX)) ||
|
||
|
|
FAILED(hr = CompDirWildcard.Append(L"*", 1)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
WIN32_FIND_DATA win32FindData;
|
||
|
|
HANDLE hDirectory = FindFirstFile(CompDirWildcard.QueryStr(),
|
||
|
|
&win32FindData);
|
||
|
|
if (hDirectory != INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
do
|
||
|
|
{
|
||
|
|
sm_dwCurrentDiskSpaceUsage += win32FindData.nFileSizeLow;
|
||
|
|
}
|
||
|
|
while (FindNextFile(hDirectory, &win32FindData));
|
||
|
|
|
||
|
|
FindClose(hDirectory);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Find if the Volume is FAT or NTFS, check for file change differs
|
||
|
|
//
|
||
|
|
WCHAR volumeRoot[10];
|
||
|
|
volumeRoot[0] = sm_pstrCompressionDirectory->QueryStr()[0];
|
||
|
|
volumeRoot[1] = L':';
|
||
|
|
volumeRoot[2] = L'\\';
|
||
|
|
volumeRoot[3] = L'\0';
|
||
|
|
|
||
|
|
DWORD maximumComponentLength;
|
||
|
|
DWORD fileSystemFlags;
|
||
|
|
WCHAR fileSystemName[256];
|
||
|
|
if (!GetVolumeInformation(volumeRoot, NULL, 0, NULL,
|
||
|
|
&maximumComponentLength,
|
||
|
|
&fileSystemFlags,
|
||
|
|
fileSystemName,
|
||
|
|
sizeof(fileSystemName)/sizeof(WCHAR)) ||
|
||
|
|
!wcsncmp(L"FAT", fileSystemName, 3))
|
||
|
|
{
|
||
|
|
sm_fCompressionVolumeIsFat = TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sm_fCompressionVolumeIsFat = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (DWORD i=0; i<sm_dwNumberOfSchemes; i++)
|
||
|
|
{
|
||
|
|
STRU &filePrefix = sm_pCompressionSchemes[i]->m_strFilePrefix;
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
if (FAILED(hr = filePrefix.Copy(*sm_pstrCompressionDirectory)) ||
|
||
|
|
FAILED(hr = filePrefix.Append(L"\\", 1)) ||
|
||
|
|
FAILED(hr = filePrefix.Append(COMP_FILE_PREFIX)) ||
|
||
|
|
FAILED(hr = filePrefix.Append(
|
||
|
|
sm_pCompressionSchemes[i]->m_strCompressionSchemeName)) ||
|
||
|
|
FAILED(hr = filePrefix.Append(L"_", 1)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::InitializeCompressionSchemes(MB *pmb)
|
||
|
|
/*++
|
||
|
|
Synopsis:
|
||
|
|
Read in all the compression schemes and initialize them
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
pmb: pointer to the Metabase object
|
||
|
|
|
||
|
|
Return Value
|
||
|
|
HRESULT
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
COMPRESSION_SCHEME *scheme;
|
||
|
|
BOOL fExistStaticScheme = FALSE;
|
||
|
|
BOOL fExistDynamicScheme = FALSE;
|
||
|
|
BOOL fExistOnDemandScheme = FALSE;
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Enumerate all the scheme names under the main Compression key
|
||
|
|
//
|
||
|
|
WCHAR schemeName[METADATA_MAX_NAME_LEN + 1];
|
||
|
|
for (DWORD schemeIndex = 0;
|
||
|
|
pmb->EnumObjects(L"", schemeName, schemeIndex);
|
||
|
|
schemeIndex++)
|
||
|
|
{
|
||
|
|
if (_wcsicmp(schemeName, HTTP_COMPRESSION_PARAMETERS) == 0)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
scheme = new COMPRESSION_SCHEME;
|
||
|
|
if (scheme == NULL)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = scheme->Initialize(pmb, schemeName)))
|
||
|
|
{
|
||
|
|
DBGPRINTF((DBG_CONTEXT, "Error initializing scheme, error %x\n", hr));
|
||
|
|
delete scheme;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (scheme->m_fDoStaticCompression)
|
||
|
|
{
|
||
|
|
fExistStaticScheme = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (scheme->m_fDoDynamicCompression)
|
||
|
|
{
|
||
|
|
fExistDynamicScheme = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (scheme->m_fDoOnDemandCompression)
|
||
|
|
{
|
||
|
|
fExistOnDemandScheme = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_pCompressionSchemes[sm_dwNumberOfSchemes++] = scheme;
|
||
|
|
if (sm_dwNumberOfSchemes == MAX_SERVER_SCHEMES)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Sort the schemes by priority
|
||
|
|
//
|
||
|
|
for (DWORD i=0; i<sm_dwNumberOfSchemes; i++)
|
||
|
|
{
|
||
|
|
for (DWORD j=i+1; j<sm_dwNumberOfSchemes; j++)
|
||
|
|
{
|
||
|
|
if (sm_pCompressionSchemes[j]->m_dwPriority >
|
||
|
|
sm_pCompressionSchemes[i]->m_dwPriority)
|
||
|
|
{
|
||
|
|
scheme = sm_pCompressionSchemes[j];
|
||
|
|
sm_pCompressionSchemes[j] = sm_pCompressionSchemes[i];
|
||
|
|
sm_pCompressionSchemes[i] = scheme;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fExistStaticScheme)
|
||
|
|
{
|
||
|
|
sm_fDoStaticCompression = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fExistDynamicScheme)
|
||
|
|
{
|
||
|
|
sm_fDoDynamicCompression = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fExistOnDemandScheme)
|
||
|
|
{
|
||
|
|
sm_fDoOnDemandCompression = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//static
|
||
|
|
HRESULT HTTP_COMPRESSION::ReadMetadata(MB *pmb)
|
||
|
|
/*++
|
||
|
|
Read all the global compression configuration
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
BUFFER TempBuff;
|
||
|
|
DWORD dwNumMDRecords;
|
||
|
|
DWORD dwDataSetNumber;
|
||
|
|
METADATA_GETALL_RECORD *pMDRecord;
|
||
|
|
DWORD i;
|
||
|
|
BOOL fExpandCompressionDirectory = TRUE;
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
if (!pmb->GetAll(HTTP_COMPRESSION_PARAMETERS,
|
||
|
|
METADATA_INHERIT | METADATA_PARTIAL_PATH,
|
||
|
|
IIS_MD_UT_SERVER,
|
||
|
|
&TempBuff,
|
||
|
|
&dwNumMDRecords,
|
||
|
|
&dwDataSetNumber))
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
pMDRecord = (METADATA_GETALL_RECORD *)TempBuff.QueryPtr();
|
||
|
|
|
||
|
|
for (i=0; i < dwNumMDRecords; i++, pMDRecord++)
|
||
|
|
{
|
||
|
|
PVOID pDataPointer = (PVOID) ((PCHAR)TempBuff.QueryPtr() +
|
||
|
|
pMDRecord->dwMDDataOffset);
|
||
|
|
|
||
|
|
DBG_ASSERT(pMDRecord->dwMDDataTag == 0);
|
||
|
|
|
||
|
|
switch (pMDRecord->dwMDIdentifier)
|
||
|
|
{
|
||
|
|
case MD_HC_COMPRESSION_DIRECTORY:
|
||
|
|
if (pMDRecord->dwMDDataType != STRING_METADATA &&
|
||
|
|
pMDRecord->dwMDDataType != EXPANDSZ_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pMDRecord->dwMDDataType == STRING_METADATA)
|
||
|
|
{
|
||
|
|
fExpandCompressionDirectory = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = sm_pstrCompressionDirectory->Copy(
|
||
|
|
(LPWSTR)pDataPointer)))
|
||
|
|
{
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_CACHE_CONTROL_HEADER:
|
||
|
|
if (pMDRecord->dwMDDataType != STRING_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = sm_pstrCacheControlHeader->CopyWTruncate(
|
||
|
|
(LPWSTR)pDataPointer)))
|
||
|
|
{
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_EXPIRES_HEADER:
|
||
|
|
if (pMDRecord->dwMDDataType != STRING_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = sm_pstrExpiresHeader->CopyWTruncate(
|
||
|
|
(LPWSTR)pDataPointer)))
|
||
|
|
{
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_DYNAMIC_COMPRESSION:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fDoDynamicCompression = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_STATIC_COMPRESSION:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fDoStaticCompression = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_ON_DEMAND_COMPRESSION:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fDoOnDemandCompression = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_DISK_SPACE_LIMITING:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fDoDiskSpaceLimiting = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_NO_COMPRESSION_FOR_HTTP_10:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fNoCompressionForHttp10 = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_NO_COMPRESSION_FOR_PROXIES:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fNoCompressionForProxies = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_NO_COMPRESSION_FOR_RANGE:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fNoCompressionForRange = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_SEND_CACHE_HEADERS:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_fSendCacheHeaders = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_MAX_DISK_SPACE_USAGE:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_dwMaxDiskSpaceUsage = *((DWORD *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_IO_BUFFER_SIZE:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_dwIoBufferSize = *((DWORD *)pDataPointer);
|
||
|
|
sm_dwIoBufferSize = max(COMPRESSION_MIN_IO_BUFFER_SIZE,
|
||
|
|
sm_dwIoBufferSize);
|
||
|
|
sm_dwIoBufferSize = min(COMPRESSION_MAX_IO_BUFFER_SIZE,
|
||
|
|
sm_dwIoBufferSize);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_COMPRESSION_BUFFER_SIZE:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_dwCompressionBufferSize = *((DWORD *)pDataPointer);
|
||
|
|
sm_dwCompressionBufferSize = max(COMPRESSION_MIN_COMP_BUFFER_SIZE,
|
||
|
|
sm_dwCompressionBufferSize);
|
||
|
|
sm_dwCompressionBufferSize = min(COMPRESSION_MAX_COMP_BUFFER_SIZE,
|
||
|
|
sm_dwCompressionBufferSize);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_MAX_QUEUE_LENGTH:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_dwMaxQueueLength = *((DWORD *)pDataPointer);
|
||
|
|
sm_dwMaxQueueLength = min(COMPRESSION_MAX_QUEUE_LENGTH,
|
||
|
|
sm_dwMaxQueueLength);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_FILES_DELETED_PER_DISK_FREE:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_dwFilesDeletedPerDiskFree = *((DWORD *)pDataPointer);
|
||
|
|
sm_dwFilesDeletedPerDiskFree =
|
||
|
|
max(COMPRESSION_MIN_FILES_DELETED_PER_DISK_FREE,
|
||
|
|
sm_dwFilesDeletedPerDiskFree);
|
||
|
|
sm_dwFilesDeletedPerDiskFree =
|
||
|
|
min(COMPRESSION_MAX_FILES_DELETED_PER_DISK_FREE,
|
||
|
|
sm_dwFilesDeletedPerDiskFree);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_MIN_FILE_SIZE_FOR_COMP:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
sm_dwMinFileSizeForCompression = *((DWORD *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// The compression directory name contains an environment vairable,
|
||
|
|
// expand it
|
||
|
|
//
|
||
|
|
if (fExpandCompressionDirectory)
|
||
|
|
{
|
||
|
|
WCHAR pszCompressionDir[MAX_PATH + 1];
|
||
|
|
if (!ExpandEnvironmentStrings(sm_pstrCompressionDirectory->QueryStr(),
|
||
|
|
pszCompressionDir,
|
||
|
|
sizeof pszCompressionDir/sizeof WCHAR))
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
sm_pstrCompressionDirectory->Copy(pszCompressionDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
ErrorExit:
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT COMPRESSION_SCHEME::Initialize(
|
||
|
|
IN MB *pmb,
|
||
|
|
IN LPWSTR schemeName)
|
||
|
|
/*++
|
||
|
|
Initialize all the scheme specific data for the given scheme
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
BUFFER TempBuff;
|
||
|
|
DWORD dwNumMDRecords;
|
||
|
|
DWORD dwDataSetNumber;
|
||
|
|
HRESULT hr;
|
||
|
|
METADATA_GETALL_RECORD *pMDRecord;
|
||
|
|
DWORD i;
|
||
|
|
STACK_STRU (strCompressionDll, 256);
|
||
|
|
HMODULE compressionDll = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Copy the scheme name
|
||
|
|
//
|
||
|
|
if (FAILED(hr = m_strCompressionSchemeName.Copy(schemeName)) ||
|
||
|
|
FAILED(hr = m_straCompressionSchemeName.CopyWTruncate(schemeName)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// First get all the metabase data
|
||
|
|
//
|
||
|
|
if (!pmb->GetAll(schemeName,
|
||
|
|
METADATA_INHERIT | METADATA_PARTIAL_PATH,
|
||
|
|
IIS_MD_UT_SERVER,
|
||
|
|
&TempBuff,
|
||
|
|
&dwNumMDRecords,
|
||
|
|
&dwDataSetNumber))
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
pMDRecord = (METADATA_GETALL_RECORD *)TempBuff.QueryPtr();
|
||
|
|
|
||
|
|
for (i=0; i < dwNumMDRecords; i++, pMDRecord++)
|
||
|
|
{
|
||
|
|
PVOID pDataPointer = (PVOID) ((PCHAR)TempBuff.QueryPtr() +
|
||
|
|
pMDRecord->dwMDDataOffset);
|
||
|
|
|
||
|
|
DBG_ASSERT( pMDRecord->dwMDDataTag == 0);
|
||
|
|
|
||
|
|
switch (pMDRecord->dwMDIdentifier)
|
||
|
|
{
|
||
|
|
case MD_HC_COMPRESSION_DLL:
|
||
|
|
if (pMDRecord->dwMDDataType != STRING_METADATA &&
|
||
|
|
pMDRecord->dwMDDataType != EXPANDSZ_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pMDRecord->dwMDDataType == EXPANDSZ_METADATA)
|
||
|
|
{
|
||
|
|
WCHAR CompressionDll[MAX_PATH + 1];
|
||
|
|
if (!ExpandEnvironmentStrings((LPWSTR)pDataPointer,
|
||
|
|
CompressionDll,
|
||
|
|
sizeof CompressionDll/sizeof WCHAR))
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
hr = strCompressionDll.Copy(CompressionDll);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hr = strCompressionDll.Copy((LPWSTR)pDataPointer);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_DYNAMIC_COMPRESSION:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_fDoDynamicCompression = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_STATIC_COMPRESSION:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_fDoStaticCompression = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DO_ON_DEMAND_COMPRESSION:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_fDoOnDemandCompression = *((BOOL *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_FILE_EXTENSIONS:
|
||
|
|
if (pMDRecord->dwMDDataType != MULTISZ_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
MULTISZ mszTemp((LPWSTR)pDataPointer);
|
||
|
|
m_mszFileExtensions.Copy(mszTemp);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_SCRIPT_FILE_EXTENSIONS:
|
||
|
|
if (pMDRecord->dwMDDataType != MULTISZ_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
MULTISZ mszTemp((LPWSTR)pDataPointer);
|
||
|
|
m_mszScriptFileExtensions.Copy(mszTemp);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_PRIORITY:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dwPriority = *((DWORD *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_DYNAMIC_COMPRESSION_LEVEL:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dwDynamicCompressionLevel = *((DWORD *)pDataPointer);
|
||
|
|
m_dwDynamicCompressionLevel =
|
||
|
|
min(COMPRESSION_MAX_COMPRESSION_LEVEL,
|
||
|
|
m_dwDynamicCompressionLevel);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_ON_DEMAND_COMP_LEVEL:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dwOnDemandCompressionLevel = *((DWORD *)pDataPointer);
|
||
|
|
m_dwOnDemandCompressionLevel =
|
||
|
|
min(COMPRESSION_MAX_COMPRESSION_LEVEL,
|
||
|
|
m_dwOnDemandCompressionLevel);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case MD_HC_CREATE_FLAGS:
|
||
|
|
if (pMDRecord->dwMDDataType != DWORD_METADATA)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_dwCreateFlags = *((DWORD *)pDataPointer);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now, get the dll and the entry-points
|
||
|
|
//
|
||
|
|
compressionDll = LoadLibrary(strCompressionDll.QueryStr());
|
||
|
|
if (compressionDll == NULL)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
m_pfnInitCompression = (PFNCODEC_INIT_COMPRESSION)
|
||
|
|
GetProcAddress(compressionDll, "InitCompression");
|
||
|
|
m_pfnDeInitCompression = (PFNCODEC_DEINIT_COMPRESSION)
|
||
|
|
GetProcAddress(compressionDll, "DeInitCompression");
|
||
|
|
m_pfnCreateCompression = (PFNCODEC_CREATE_COMPRESSION)
|
||
|
|
GetProcAddress(compressionDll, "CreateCompression");
|
||
|
|
m_pfnCompress = (PFNCODEC_COMPRESS)
|
||
|
|
GetProcAddress(compressionDll, "Compress");
|
||
|
|
m_pfnDestroyCompression = (PFNCODEC_DESTROY_COMPRESSION)
|
||
|
|
GetProcAddress(compressionDll, "DestroyCompression");
|
||
|
|
m_pfnResetCompression = (PFNCODEC_RESET_COMPRESSION)
|
||
|
|
GetProcAddress(compressionDll, "ResetCompression");
|
||
|
|
|
||
|
|
if (!m_pfnInitCompression ||
|
||
|
|
!m_pfnDeInitCompression ||
|
||
|
|
!m_pfnCreateCompression ||
|
||
|
|
!m_pfnCompress ||
|
||
|
|
!m_pfnDestroyCompression ||
|
||
|
|
!m_pfnResetCompression)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_PROC_NOT_FOUND);
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Call the initialize entry-point
|
||
|
|
//
|
||
|
|
if (FAILED(hr = m_pfnInitCompression()) ||
|
||
|
|
FAILED(hr = m_pfnCreateCompression(&m_pCompressionContext,
|
||
|
|
m_dwCreateFlags)))
|
||
|
|
{
|
||
|
|
goto ErrorExit;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_hCompressionDll = compressionDll;
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
|
||
|
|
ErrorExit:
|
||
|
|
if (compressionDll)
|
||
|
|
{
|
||
|
|
FreeLibrary(compressionDll);
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
BOOL HTTP_COMPRESSION::QueueWorkItem (
|
||
|
|
IN COMPRESSION_WORK_ITEM *WorkItem,
|
||
|
|
IN BOOL fOverrideMaxQueueLength,
|
||
|
|
IN BOOL fQueueAtHead)
|
||
|
|
/*++
|
||
|
|
Routine Description:
|
||
|
|
This is the routine that handles queuing work items to the compression
|
||
|
|
thread.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
WorkRoutine - the routine that the compression thread should call
|
||
|
|
to do work. If NULL, then the call is an indication to the
|
||
|
|
compression thread that it should terminate.
|
||
|
|
|
||
|
|
Context - a context pointer which is passed to WorkRoutine.
|
||
|
|
|
||
|
|
WorkItem - if not NULL, this is a pointer to the work item to use
|
||
|
|
for this request. If NULL, then this routine will allocate a
|
||
|
|
work item to use. Note that by passing in a work item, the
|
||
|
|
caller agrees to give up control of the memory: we will free it
|
||
|
|
as necessary, either here or in the compression thread.
|
||
|
|
|
||
|
|
MustSucceed - if TRUE, then this request is not subject to the
|
||
|
|
limits on the number of work items that can be queued at any one
|
||
|
|
time.
|
||
|
|
|
||
|
|
QueueAtHead - if TRUE, then this work item is placed at the head
|
||
|
|
of the queue to be serviced immediately.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
TRUE if the queuing succeeded.
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
DBG_ASSERT(WorkItem != NULL);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Acquire the lock that protects the work queue list test to see
|
||
|
|
// how many items we have on the queue. If this is not a "must
|
||
|
|
// succeed" request and if we have reached the configured queue size
|
||
|
|
// limit, then fail this request. "Must succeed" requests are used
|
||
|
|
// for thread shutdown and other things which we really want to
|
||
|
|
// work.
|
||
|
|
//
|
||
|
|
|
||
|
|
EnterCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
|
||
|
|
if (!fOverrideMaxQueueLength &&
|
||
|
|
(sm_dwCurrentQueueLength >= sm_dwMaxQueueLength))
|
||
|
|
{
|
||
|
|
LeaveCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// All looks good, so increment the count of items on the queue and
|
||
|
|
// add this item to the queue.
|
||
|
|
//
|
||
|
|
|
||
|
|
sm_dwCurrentQueueLength++;
|
||
|
|
|
||
|
|
if (fQueueAtHead)
|
||
|
|
{
|
||
|
|
InsertHeadList(&sm_CompressionThreadWorkQueue, &WorkItem->ListEntry);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
InsertTailList(&sm_CompressionThreadWorkQueue, &WorkItem->ListEntry);
|
||
|
|
}
|
||
|
|
|
||
|
|
LeaveCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Signal the event that will cause the compression thread to wake
|
||
|
|
// up and process this work item.
|
||
|
|
//
|
||
|
|
|
||
|
|
SetEvent(sm_hThreadEvent);
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
VOID HTTP_COMPRESSION::Terminate()
|
||
|
|
/*++
|
||
|
|
Called on server shutdown
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
DBG_ASSERT(sm_fHttpCompressionInitialized);
|
||
|
|
sm_fIsTerminating = TRUE;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Make the CompressionThread terminate by queueing a work item indicating
|
||
|
|
// that
|
||
|
|
//
|
||
|
|
COMPRESSION_WORK_ITEM *WorkItem = new COMPRESSION_WORK_ITEM;
|
||
|
|
|
||
|
|
if (WorkItem == NULL)
|
||
|
|
{
|
||
|
|
// if we can't even allocate this much memory, skip the rest of
|
||
|
|
// the termination and exit
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
WorkItem->WorkItemType = COMPRESSION_WORK_ITEM_TERMINATE;
|
||
|
|
|
||
|
|
QueueWorkItem(WorkItem, TRUE, TRUE);
|
||
|
|
WaitForSingleObject(sm_hCompressionThreadHandle, INFINITE);
|
||
|
|
CloseHandle(sm_hCompressionThreadHandle);
|
||
|
|
sm_hCompressionThreadHandle = NULL;
|
||
|
|
|
||
|
|
COMPRESSION_BUFFER::Terminate();
|
||
|
|
|
||
|
|
COMPRESSION_CONTEXT::Terminate();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Free static objects
|
||
|
|
//
|
||
|
|
delete sm_pstrCompressionDirectory;
|
||
|
|
sm_pstrCompressionDirectory = NULL;
|
||
|
|
|
||
|
|
delete sm_pstrCacheControlHeader;
|
||
|
|
sm_pstrCacheControlHeader = NULL;
|
||
|
|
|
||
|
|
delete sm_pstrExpiresHeader;
|
||
|
|
sm_pstrExpiresHeader = NULL;
|
||
|
|
|
||
|
|
delete sm_pIoBuffer;
|
||
|
|
sm_pIoBuffer = NULL;
|
||
|
|
|
||
|
|
delete sm_pCompressionBuffer;
|
||
|
|
sm_pCompressionBuffer = NULL;
|
||
|
|
|
||
|
|
DeleteCriticalSection(&sm_CompressionDirectoryLock);
|
||
|
|
DeleteCriticalSection(&sm_CompressionThreadLock);
|
||
|
|
|
||
|
|
//
|
||
|
|
// For each compression scheme, unload the compression dll and free
|
||
|
|
// the space that holds info about the scheme
|
||
|
|
//
|
||
|
|
for (DWORD i=0; i<sm_dwNumberOfSchemes; i++)
|
||
|
|
{
|
||
|
|
delete sm_pCompressionSchemes[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::DoStaticFileCompression(
|
||
|
|
IN W3_CONTEXT *pW3Context,
|
||
|
|
IN OUT W3_FILE_INFO **ppOpenFile)
|
||
|
|
/*++
|
||
|
|
Synopsis:
|
||
|
|
Handle compression of static file request by either sending back the
|
||
|
|
compression version if present and applicable or queueing a work-item
|
||
|
|
to compress it for future requests. Called by
|
||
|
|
W3_STATIC_FILE_HANDLER::FileDoWork
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
pW3Context: The W3_CONTEXT for the request
|
||
|
|
ppOpenFile: On entry contains the cache entry to the physical path.
|
||
|
|
If a suitable file is found, on exit contains cach entry to the
|
||
|
|
compressed file
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
HRESULT
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// If compression is not initialized, return
|
||
|
|
//
|
||
|
|
if (!sm_fHttpCompressionInitialized)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the client has not sent an Accept-Encoding header, or an empty
|
||
|
|
// Accept-Encoding header, return
|
||
|
|
//
|
||
|
|
W3_REQUEST *pRequest = pW3Context->QueryRequest();
|
||
|
|
CHAR *pszAcceptEncoding = pRequest->GetHeader(HttpHeaderAcceptEncoding);
|
||
|
|
if (pszAcceptEncoding == NULL || *pszAcceptEncoding == '\0')
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to not compress for 1.0, and version is not 1.1,
|
||
|
|
// return
|
||
|
|
//
|
||
|
|
if (sm_fNoCompressionForHttp10 &&
|
||
|
|
((pRequest->QueryVersion().MajorVersion == 0) ||
|
||
|
|
((pRequest->QueryVersion().MajorVersion == 1) &&
|
||
|
|
(pRequest->QueryVersion().MinorVersion == 0))))
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to not compress for proxies and it is a proxy
|
||
|
|
// request, return
|
||
|
|
//
|
||
|
|
if (sm_fNoCompressionForProxies && pRequest->IsProxyRequest())
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to not Compress for range requests and Range
|
||
|
|
// is present, return
|
||
|
|
// BUGBUG: Is the correct behavior to take range on the original request
|
||
|
|
// and compress those chunks or take range on the compressed file? We do
|
||
|
|
// the latter (same as IIS 5.0), figure out if that is correct.
|
||
|
|
//
|
||
|
|
if (sm_fNoCompressionForRange &&
|
||
|
|
pRequest->GetHeader(HttpHeaderRange))
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If file is too small, return
|
||
|
|
//
|
||
|
|
W3_FILE_INFO *pOrigFile = *ppOpenFile;
|
||
|
|
LARGE_INTEGER originalFileSize;
|
||
|
|
pOrigFile->QuerySize(&originalFileSize);
|
||
|
|
if (originalFileSize.QuadPart < sm_dwMinFileSizeForCompression)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Break the accept-encoding header into all the encoding accepted by
|
||
|
|
// the client sorting using the quality value
|
||
|
|
//
|
||
|
|
|
||
|
|
STACK_STRA( strAcceptEncoding, 512);
|
||
|
|
HRESULT hr;
|
||
|
|
if (FAILED(hr = strAcceptEncoding.Copy(pszAcceptEncoding)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
STRU *pstrPhysical = pW3Context->QueryUrlContext()->QueryPhysicalPath();
|
||
|
|
LPWSTR pszExtension = wcsrchr(pstrPhysical->QueryStr(), L'.');
|
||
|
|
if (pszExtension != NULL)
|
||
|
|
{
|
||
|
|
pszExtension++;
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD dwClientCompressionCount;
|
||
|
|
DWORD matchingSchemes[MAX_SERVER_SCHEMES];
|
||
|
|
//
|
||
|
|
// Find out all schemes which will compress for this file
|
||
|
|
//
|
||
|
|
FindMatchingSchemes(strAcceptEncoding.QueryStr(),
|
||
|
|
pszExtension,
|
||
|
|
DO_STATIC_COMPRESSION,
|
||
|
|
matchingSchemes,
|
||
|
|
&dwClientCompressionCount);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Try to find a static scheme, which already has the file
|
||
|
|
// pre-compressed
|
||
|
|
//
|
||
|
|
COMPRESSION_SCHEME *firstOnDemandScheme = NULL;
|
||
|
|
STACK_STRU (strCompressedFileName, 256);
|
||
|
|
for (DWORD i=0; i<dwClientCompressionCount; i++)
|
||
|
|
{
|
||
|
|
COMPRESSION_SCHEME *scheme = sm_pCompressionSchemes[matchingSchemes[i]];
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now, see if there exists a version of the requested file
|
||
|
|
// that has been compressed with that scheme. First, calculate
|
||
|
|
// the name the file would have. The compressed file will live
|
||
|
|
// in the special compression directory with a special converted
|
||
|
|
// name. The file name starts with the compression scheme used,
|
||
|
|
// then the fully qualified file name where slashes and colons
|
||
|
|
// have been converted to underscores. For example, the gzip
|
||
|
|
// version of "c:\inetpub\wwwroot\file.htm" would be
|
||
|
|
// "c:\compdir\$^_gzip^c^^inetpub^wwwroot^file.htm".
|
||
|
|
//
|
||
|
|
|
||
|
|
if (FAILED(hr = ConvertPhysicalPathToCompressedPath(
|
||
|
|
scheme,
|
||
|
|
pstrPhysical,
|
||
|
|
&strCompressedFileName)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
W3_FILE_INFO *pCompFile;
|
||
|
|
if (CheckForExistenceOfCompressedFile(
|
||
|
|
pOrigFile,
|
||
|
|
&strCompressedFileName,
|
||
|
|
&pCompFile))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Bingo--we have a compressed version of the file in a
|
||
|
|
// format that the client understands. Add the appropriate
|
||
|
|
// Content-Encoding header so that the client knows it is
|
||
|
|
// getting compressed data and change the server's mapping
|
||
|
|
// to the compressed version of the file.
|
||
|
|
//
|
||
|
|
|
||
|
|
W3_RESPONSE *pResponse = pW3Context->QueryResponse();
|
||
|
|
if (FAILED(hr = pResponse->SetHeaderByReference(
|
||
|
|
HttpHeaderContentEncoding,
|
||
|
|
scheme->m_straCompressionSchemeName.QueryStr(),
|
||
|
|
scheme->m_straCompressionSchemeName.QueryCCH())))
|
||
|
|
{
|
||
|
|
pCompFile->DereferenceCacheEntry();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sm_fSendCacheHeaders)
|
||
|
|
{
|
||
|
|
if (FAILED(hr = pResponse->SetHeaderByReference(
|
||
|
|
HttpHeaderExpires,
|
||
|
|
sm_pstrExpiresHeader->QueryStr(),
|
||
|
|
sm_pstrExpiresHeader->QueryCCH())) ||
|
||
|
|
FAILED(hr = pResponse->SetHeaderByReference(
|
||
|
|
HttpHeaderCacheControl,
|
||
|
|
sm_pstrCacheControlHeader->QueryStr(),
|
||
|
|
sm_pstrCacheControlHeader->QueryCCH())))
|
||
|
|
{
|
||
|
|
pCompFile->DereferenceCacheEntry();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = pResponse->SetHeaderByReference(
|
||
|
|
HttpHeaderVary,
|
||
|
|
"Accept-Encoding", 15)))
|
||
|
|
{
|
||
|
|
pCompFile->DereferenceCacheEntry();
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Change the cache entry to point to the new file and close
|
||
|
|
// the original file
|
||
|
|
//
|
||
|
|
*ppOpenFile = pCompFile;
|
||
|
|
pOrigFile->DereferenceCacheEntry();
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// We found a scheme, but we don't have a matching file for it.
|
||
|
|
// Remember whether this was the first matching scheme that
|
||
|
|
// supports on-demand compression. In the event that we do not
|
||
|
|
// find any acceptable files, we'll attempt to do an on-demand
|
||
|
|
// compression for this file so that future requests get a
|
||
|
|
// compressed version.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (firstOnDemandScheme == NULL &&
|
||
|
|
scheme->m_fDoOnDemandCompression)
|
||
|
|
{
|
||
|
|
firstOnDemandScheme = scheme;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Loop to see if there is another scheme that is supported
|
||
|
|
// by both client and server.
|
||
|
|
//
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sm_fDoOnDemandCompression && firstOnDemandScheme != NULL)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// if we are here means scheme was found but no compressed
|
||
|
|
// file matching any scheme. So schedule file to compress
|
||
|
|
//
|
||
|
|
QueueCompressFile(firstOnDemandScheme,
|
||
|
|
*pstrPhysical);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// No static compression for this request, will try dynamic compression
|
||
|
|
// if so configured while sending response
|
||
|
|
//
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
VOID HTTP_COMPRESSION::FindMatchingSchemes(
|
||
|
|
IN CHAR * pszAcceptEncoding,
|
||
|
|
IN LPWSTR pszExtension,
|
||
|
|
IN COMPRESSION_TO_PERFORM performCompr,
|
||
|
|
OUT DWORD matchingSchemes[],
|
||
|
|
OUT DWORD *pdwClientCompressionCount)
|
||
|
|
{
|
||
|
|
struct
|
||
|
|
{
|
||
|
|
LPSTR schemeName;
|
||
|
|
float quality;
|
||
|
|
} parsedAcceptEncoding[MAX_SERVER_SCHEMES];
|
||
|
|
DWORD NumberOfParsedSchemes = 0;
|
||
|
|
|
||
|
|
//
|
||
|
|
// First parse the Accept-Encoding header
|
||
|
|
//
|
||
|
|
BOOL fAddStar = FALSE;
|
||
|
|
while (*pszAcceptEncoding != '\0')
|
||
|
|
{
|
||
|
|
LPSTR schemeEnd;
|
||
|
|
BOOL fStar = FALSE;
|
||
|
|
|
||
|
|
while (*pszAcceptEncoding == ' ')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isalnum(*pszAcceptEncoding))
|
||
|
|
{
|
||
|
|
parsedAcceptEncoding[NumberOfParsedSchemes].schemeName =
|
||
|
|
pszAcceptEncoding;
|
||
|
|
parsedAcceptEncoding[NumberOfParsedSchemes].quality = 1;
|
||
|
|
|
||
|
|
while (isalnum(*pszAcceptEncoding))
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mark the end of the scheme name
|
||
|
|
schemeEnd = pszAcceptEncoding;
|
||
|
|
}
|
||
|
|
else if (*pszAcceptEncoding == '*')
|
||
|
|
{
|
||
|
|
fStar = TRUE;
|
||
|
|
parsedAcceptEncoding[NumberOfParsedSchemes].quality = 1;
|
||
|
|
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// incorrect syntax
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (*pszAcceptEncoding == ' ')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*pszAcceptEncoding == ';')
|
||
|
|
{
|
||
|
|
// quality specifier: looks like q=0.7
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
|
||
|
|
while (*pszAcceptEncoding == ' ')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*pszAcceptEncoding == 'q')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (*pszAcceptEncoding == ' ')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*pszAcceptEncoding == '=')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (*pszAcceptEncoding == ' ')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
parsedAcceptEncoding[NumberOfParsedSchemes].quality =
|
||
|
|
atof(pszAcceptEncoding);
|
||
|
|
|
||
|
|
while (*pszAcceptEncoding && *pszAcceptEncoding != ',')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (*pszAcceptEncoding == ',')
|
||
|
|
{
|
||
|
|
pszAcceptEncoding++;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (fStar)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// A star with non-zero quality means that all schemes are
|
||
|
|
// acceptable except those explicitly unacceptable
|
||
|
|
//
|
||
|
|
if (parsedAcceptEncoding[NumberOfParsedSchemes].quality != 0)
|
||
|
|
{
|
||
|
|
fAddStar = TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*schemeEnd = '\0';
|
||
|
|
NumberOfParsedSchemes++;
|
||
|
|
if (NumberOfParsedSchemes >= MAX_SERVER_SCHEMES)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now sort by quality
|
||
|
|
//
|
||
|
|
LPSTR tempName;
|
||
|
|
float tempQuality;
|
||
|
|
for (DWORD i=0; i<NumberOfParsedSchemes; i++)
|
||
|
|
{
|
||
|
|
for (DWORD j=i+1; j<NumberOfParsedSchemes; j++)
|
||
|
|
{
|
||
|
|
if (parsedAcceptEncoding[j].quality <
|
||
|
|
parsedAcceptEncoding[i].quality)
|
||
|
|
{
|
||
|
|
tempName = parsedAcceptEncoding[i].schemeName;
|
||
|
|
parsedAcceptEncoding[i].schemeName = parsedAcceptEncoding[j].schemeName;
|
||
|
|
parsedAcceptEncoding[j].schemeName = tempName;
|
||
|
|
|
||
|
|
tempQuality = parsedAcceptEncoding[i].quality;
|
||
|
|
parsedAcceptEncoding[i].quality = parsedAcceptEncoding[j].quality;
|
||
|
|
parsedAcceptEncoding[j].quality = tempQuality;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now convert the names to indexes into actual schemes
|
||
|
|
//
|
||
|
|
BOOL fAddedScheme[MAX_SERVER_SCHEMES];
|
||
|
|
for (i=0; i<sm_dwNumberOfSchemes; i++)
|
||
|
|
{
|
||
|
|
fAddedScheme[i] = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD dwNumberOfActualSchemes = 0;
|
||
|
|
for (i=0; i<NumberOfParsedSchemes; i++)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Find this scheme
|
||
|
|
//
|
||
|
|
for (DWORD j=0; j<sm_dwNumberOfSchemes; j++)
|
||
|
|
{
|
||
|
|
if (!fAddedScheme[j] &&
|
||
|
|
!_stricmp(parsedAcceptEncoding[i].schemeName,
|
||
|
|
sm_pCompressionSchemes[j]->
|
||
|
|
m_straCompressionSchemeName.QueryStr()))
|
||
|
|
{
|
||
|
|
// found a match
|
||
|
|
fAddedScheme[j] = TRUE;
|
||
|
|
|
||
|
|
if (parsedAcceptEncoding[i].quality == 0)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Check if the given scheme does the required kind of
|
||
|
|
// compression. Also, check that either there is no list
|
||
|
|
// of restricted extensions or that the given file extension
|
||
|
|
// matches one in the list
|
||
|
|
//
|
||
|
|
if (performCompr == DO_STATIC_COMPRESSION)
|
||
|
|
{
|
||
|
|
if (!sm_pCompressionSchemes[j]->m_fDoStaticCompression ||
|
||
|
|
(sm_pCompressionSchemes[j]->m_mszFileExtensions.QueryStringCount() &&
|
||
|
|
(!pszExtension ||
|
||
|
|
!sm_pCompressionSchemes[j]->m_mszFileExtensions.FindString(pszExtension))))
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!sm_pCompressionSchemes[j]->m_fDoDynamicCompression ||
|
||
|
|
(sm_pCompressionSchemes[j]->m_mszScriptFileExtensions.QueryStringCount() &&
|
||
|
|
(!pszExtension ||
|
||
|
|
!sm_pCompressionSchemes[j]->m_mszScriptFileExtensions.FindString(pszExtension))))
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
matchingSchemes[dwNumberOfActualSchemes++] = j;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If * was specified, add all unadded applicable schemes
|
||
|
|
//
|
||
|
|
if (fAddStar)
|
||
|
|
{
|
||
|
|
for (DWORD j=0; j<sm_dwNumberOfSchemes; j++)
|
||
|
|
{
|
||
|
|
if (!fAddedScheme[j])
|
||
|
|
{
|
||
|
|
fAddedScheme[j] = TRUE;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Check if the given scheme does the required kind of
|
||
|
|
// compression. Also, check that either there is no list
|
||
|
|
// of restricted extensions or that the given file extension
|
||
|
|
// matches one in the list
|
||
|
|
//
|
||
|
|
if (performCompr == DO_STATIC_COMPRESSION)
|
||
|
|
{
|
||
|
|
if (!sm_pCompressionSchemes[j]->m_fDoStaticCompression ||
|
||
|
|
(sm_pCompressionSchemes[j]->m_mszFileExtensions.QueryStringCount() &&
|
||
|
|
(!pszExtension ||
|
||
|
|
!sm_pCompressionSchemes[j]->m_mszFileExtensions.FindString(pszExtension))))
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!sm_pCompressionSchemes[j]->m_fDoDynamicCompression ||
|
||
|
|
(sm_pCompressionSchemes[j]->m_mszScriptFileExtensions.QueryStringCount() &&
|
||
|
|
(!pszExtension ||
|
||
|
|
!sm_pCompressionSchemes[j]->m_mszScriptFileExtensions.FindString(pszExtension))))
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
matchingSchemes[dwNumberOfActualSchemes++] = j;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
*pdwClientCompressionCount = dwNumberOfActualSchemes;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::ConvertPhysicalPathToCompressedPath(
|
||
|
|
IN COMPRESSION_SCHEME *scheme,
|
||
|
|
IN STRU *pstrPhysicalPath,
|
||
|
|
OUT STRU *pstrCompressedPath)
|
||
|
|
/*++
|
||
|
|
Routine Description:
|
||
|
|
Builds a string that has the directory for the specified compression
|
||
|
|
scheme, followed by the file name with all slashes and colons
|
||
|
|
converted to underscores. This allows for a flat directory which
|
||
|
|
contains all the compressed files.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
Scheme - the compression scheme to use.
|
||
|
|
|
||
|
|
pstrPhysicalPath - the physical file name that we want to convert.
|
||
|
|
|
||
|
|
pstrCompressedPath - the resultant string.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
HRESULT
|
||
|
|
--*/
|
||
|
|
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
EnterCriticalSection(&sm_CompressionDirectoryLock);
|
||
|
|
|
||
|
|
hr = pstrCompressedPath->Copy(scheme->m_strFilePrefix);
|
||
|
|
|
||
|
|
LeaveCriticalSection(&sm_CompressionDirectoryLock);
|
||
|
|
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Copy over the actual file name, converting slashes and colons
|
||
|
|
// to underscores.
|
||
|
|
//
|
||
|
|
|
||
|
|
DWORD cchPathLength = pstrCompressedPath->QueryCCH();
|
||
|
|
if (FAILED(hr = pstrCompressedPath->Append(*pstrPhysicalPath)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (LPWSTR s = pstrCompressedPath->QueryStr() + cchPathLength;
|
||
|
|
*s != L'\0';
|
||
|
|
s++)
|
||
|
|
{
|
||
|
|
if (*s == L'\\' || *s == L':')
|
||
|
|
{
|
||
|
|
*s = L'^';
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
BOOL HTTP_COMPRESSION::CheckForExistenceOfCompressedFile(
|
||
|
|
IN W3_FILE_INFO *pOrigFile,
|
||
|
|
IN STRU *pstrFileName,
|
||
|
|
OUT W3_FILE_INFO **ppCompFile,
|
||
|
|
IN BOOL fDeleteAllowed)
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
FILE_CACHE_USER fileUser;
|
||
|
|
|
||
|
|
DBG_ASSERT( g_pW3Server->QueryFileCache() != NULL );
|
||
|
|
|
||
|
|
hr = g_pW3Server->QueryFileCache()->GetFileInfo(
|
||
|
|
*pstrFileName,
|
||
|
|
NULL,
|
||
|
|
&fileUser,
|
||
|
|
TRUE,
|
||
|
|
ppCompFile );
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// So far so good. Determine whether the compressed version
|
||
|
|
// of the file is out of date. If the compressed file is
|
||
|
|
// out of date, delete it and remember that we did not get a
|
||
|
|
// good match. Note that there's really nothing we can do
|
||
|
|
// if the delete fails, so ignore any failures from it.
|
||
|
|
//
|
||
|
|
// The last write times must differ by exactly two seconds
|
||
|
|
// to constitute a match. The two-second difference results
|
||
|
|
// from the fact that we set the time on the compressed file
|
||
|
|
// to be two seconds behind the uncompressed version in
|
||
|
|
// order to ensure unique ETag: header values.
|
||
|
|
//
|
||
|
|
|
||
|
|
W3_FILE_INFO *pCompFile = *ppCompFile;
|
||
|
|
LARGE_INTEGER compressedFileSize;
|
||
|
|
FILETIME compressedFileTime;
|
||
|
|
LARGE_INTEGER *pli = (LARGE_INTEGER *)&compressedFileTime;
|
||
|
|
FILETIME originalFileTime;
|
||
|
|
BOOL success = FALSE;
|
||
|
|
|
||
|
|
pCompFile->QuerySize(&compressedFileSize);
|
||
|
|
pCompFile->QueryLastWriteTime(&compressedFileTime);
|
||
|
|
pOrigFile->QueryLastWriteTime(&originalFileTime);
|
||
|
|
|
||
|
|
pli->QuadPart += 2*10*1000*1000;
|
||
|
|
|
||
|
|
LONG timeResult = CompareFileTime(&compressedFileTime, &originalFileTime);
|
||
|
|
if ( timeResult != 0 )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// That check failed. If the compression directory is
|
||
|
|
// on a FAT volume, then see if they are within two
|
||
|
|
// seconds of one another. If they are, then consider
|
||
|
|
// things valid. We have to do this because FAT file
|
||
|
|
// times get truncated in weird ways sometimes: despite
|
||
|
|
// the fact that we request setting the file time
|
||
|
|
// different by an exact amount, it gets rounded
|
||
|
|
// sometimes.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (sm_fCompressionVolumeIsFat)
|
||
|
|
{
|
||
|
|
pli->QuadPart -= 2*10*1000*1000 + 1;
|
||
|
|
timeResult += CompareFileTime(&compressedFileTime, &originalFileTime);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (timeResult == 0)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// The filetime passed, also check if ACLs are the same
|
||
|
|
//
|
||
|
|
PSECURITY_DESCRIPTOR compressedFileAcls =
|
||
|
|
pCompFile->QuerySecDesc();
|
||
|
|
PSECURITY_DESCRIPTOR originalFileAcls =
|
||
|
|
pOrigFile->QuerySecDesc();
|
||
|
|
|
||
|
|
if (compressedFileAcls != NULL && originalFileAcls != NULL )
|
||
|
|
{
|
||
|
|
DWORD compressedFileAclsLen =
|
||
|
|
GetSecurityDescriptorLength(compressedFileAcls);
|
||
|
|
DWORD originalFileAclsLen =
|
||
|
|
GetSecurityDescriptorLength(originalFileAcls);
|
||
|
|
|
||
|
|
if (originalFileAclsLen == compressedFileAclsLen)
|
||
|
|
{
|
||
|
|
SECURITY_DESCRIPTOR_CONTROL compressedFileCtl =
|
||
|
|
((PISECURITY_DESCRIPTOR)compressedFileAcls)->Control;
|
||
|
|
SECURITY_DESCRIPTOR_CONTROL originalFileCtl =
|
||
|
|
((PISECURITY_DESCRIPTOR)originalFileAcls)->Control;
|
||
|
|
|
||
|
|
((PISECURITY_DESCRIPTOR)compressedFileAcls)->Control &=
|
||
|
|
ACL_CLEAR_BIT_MASK;
|
||
|
|
((PISECURITY_DESCRIPTOR)originalFileAcls)->Control &=
|
||
|
|
ACL_CLEAR_BIT_MASK;
|
||
|
|
|
||
|
|
success = (memcmp((PVOID)originalFileAcls,(PVOID)compressedFileAcls, originalFileAclsLen) == 0);
|
||
|
|
|
||
|
|
((PISECURITY_DESCRIPTOR)compressedFileAcls)->Control =
|
||
|
|
compressedFileCtl;
|
||
|
|
((PISECURITY_DESCRIPTOR)originalFileAcls)->Control =
|
||
|
|
originalFileCtl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// The original file has changed since the compression, close this cache
|
||
|
|
// entry
|
||
|
|
//
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
pCompFile->DereferenceCacheEntry();
|
||
|
|
*ppCompFile = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the compressed file exists but is stale, queue for deletion
|
||
|
|
//
|
||
|
|
if (!success && fDeleteAllowed)
|
||
|
|
{
|
||
|
|
// don't delete if call came from compression thread because then
|
||
|
|
// delete request will be in a queue after compression request
|
||
|
|
// and will delete a file which was just moment ago compressed
|
||
|
|
COMPRESSION_WORK_ITEM *WorkItem = new COMPRESSION_WORK_ITEM;
|
||
|
|
if (WorkItem == NULL)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
WorkItem->WorkItemType = COMPRESSION_WORK_ITEM_DELETE;
|
||
|
|
if (FAILED(WorkItem->strPhysicalPath.Copy(*pstrFileName)))
|
||
|
|
{
|
||
|
|
delete WorkItem;
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!QueueWorkItem(WorkItem,
|
||
|
|
FALSE,
|
||
|
|
FALSE))
|
||
|
|
{
|
||
|
|
delete WorkItem;
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to limit the amount of disk
|
||
|
|
// space we use for compressed files, then, in a
|
||
|
|
// thread-safe manner, update the tally of disk
|
||
|
|
// space used by compression.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (sm_fDoDiskSpaceLimiting)
|
||
|
|
{
|
||
|
|
InterlockedExchangeAdd((PLONG)&sm_dwCurrentDiskSpaceUsage,
|
||
|
|
-1 * compressedFileSize.LowPart);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return success;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
BOOL HTTP_COMPRESSION::QueueCompressFile(
|
||
|
|
IN COMPRESSION_SCHEME *scheme,
|
||
|
|
IN STRU &strPhysicalPath)
|
||
|
|
/*++
|
||
|
|
Routine Description:
|
||
|
|
Queues a compress file request to the compression thread.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
Scheme - a pointer to the compression scheme to use in compressing
|
||
|
|
the file.
|
||
|
|
|
||
|
|
pszPhysicalPath - the current physical path to the file.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
TRUE if the queuing succeeded.
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
COMPRESSION_WORK_ITEM *WorkItem = new COMPRESSION_WORK_ITEM;
|
||
|
|
if ( WorkItem == NULL )
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Initialize this structure with the necessary information.
|
||
|
|
//
|
||
|
|
WorkItem->WorkItemType = COMPRESSION_WORK_ITEM_COMPRESS;
|
||
|
|
WorkItem->scheme = scheme;
|
||
|
|
if (FAILED(WorkItem->strPhysicalPath.Copy(strPhysicalPath)))
|
||
|
|
{
|
||
|
|
delete WorkItem;
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Queue a work item and we're done.
|
||
|
|
//
|
||
|
|
if (!QueueWorkItem(WorkItem,
|
||
|
|
FALSE,
|
||
|
|
FALSE))
|
||
|
|
{
|
||
|
|
delete WorkItem;
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
VOID HTTP_COMPRESSION::CompressFile(IN COMPRESSION_SCHEME *scheme,
|
||
|
|
IN STRU &strPhysicalPath)
|
||
|
|
/*++
|
||
|
|
Routine Description:
|
||
|
|
This routine does the real work of compressing a static file and
|
||
|
|
storing it to the compression directory with a unique name.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
Context - a pointer to context information for the request,
|
||
|
|
including the compression scheme to use for compression and the
|
||
|
|
physical path to the file that we need to compress.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
None. If the compression fails, we just press on and attempt to
|
||
|
|
compress the file the next time it is requested.
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
HANDLE hOriginalFile = NULL;
|
||
|
|
HANDLE hCompressedFile = NULL;
|
||
|
|
STACK_STRU ( compressedFileName, 256);
|
||
|
|
STACK_STRU ( realCompressedFileName, 256);
|
||
|
|
BOOL success = FALSE;
|
||
|
|
DWORD cbIo = 0;
|
||
|
|
DWORD bytesCompressed = 0;
|
||
|
|
SECURITY_ATTRIBUTES securityAttributes;
|
||
|
|
DWORD totalBytesWritten = 0;
|
||
|
|
BOOL usedScheme = FALSE;
|
||
|
|
LARGE_INTEGER *pli = NULL;
|
||
|
|
W3_FILE_INFO *pofiOriginalFile = NULL;
|
||
|
|
W3_FILE_INFO *pofiCompressedFile = NULL;
|
||
|
|
FILETIME originalFileTime;
|
||
|
|
PSECURITY_DESCRIPTOR originalFileAcls = NULL;
|
||
|
|
DWORD originalFileAclsLen = 0;
|
||
|
|
OVERLAPPED ovlForRead;
|
||
|
|
DWORD readStatus;
|
||
|
|
ULARGE_INTEGER readOffset;
|
||
|
|
SYSTEMTIME systemTime;
|
||
|
|
FILETIME fileTime;
|
||
|
|
WCHAR pszPid[16];
|
||
|
|
DWORD dwPid;
|
||
|
|
BYTE *pCachedFileBuffer;
|
||
|
|
BOOL fHaveCachedFileBuffer = FALSE;
|
||
|
|
DWORD dwOrigFileSize;
|
||
|
|
LARGE_INTEGER liOrigFileSize;
|
||
|
|
DIRMON_CONFIG dirConfig;
|
||
|
|
FILE_CACHE_USER fileUser;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Determine the name of the file to which we will write compression
|
||
|
|
// file data. Note that we use a bogus file name initially: this
|
||
|
|
// allows us to rename it later and ensure an atomic update to the
|
||
|
|
// file system, thereby preventing other threads from returning the
|
||
|
|
// compressed file when it has only been partially written.
|
||
|
|
//
|
||
|
|
// If the caller specified a specific output file name, then use that
|
||
|
|
// instead of the calculated name.
|
||
|
|
//
|
||
|
|
if (FAILED(ConvertPhysicalPathToCompressedPath(
|
||
|
|
scheme,
|
||
|
|
&strPhysicalPath,
|
||
|
|
&realCompressedFileName)))
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
dwPid = GetCurrentProcessId();
|
||
|
|
_itow(dwPid, pszPid, 10);
|
||
|
|
if (FAILED(compressedFileName.Copy(realCompressedFileName)) ||
|
||
|
|
FAILED(compressedFileName.Append(pszPid)) ||
|
||
|
|
FAILED(compressedFileName.Append(TEMP_COMP_FILE_SUFFIX)))
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
DBG_ASSERT( g_pW3Server->QueryFileCache() != NULL );
|
||
|
|
|
||
|
|
if (FAILED(g_pW3Server->QueryFileCache()->GetFileInfo(
|
||
|
|
strPhysicalPath,
|
||
|
|
NULL,
|
||
|
|
&fileUser,
|
||
|
|
TRUE,
|
||
|
|
&pofiOriginalFile)))
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
success = CheckForExistenceOfCompressedFile(pofiOriginalFile,
|
||
|
|
&realCompressedFileName,
|
||
|
|
&pofiCompressedFile,
|
||
|
|
FALSE);
|
||
|
|
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
originalFileAcls = pofiOriginalFile->QuerySecDesc();
|
||
|
|
|
||
|
|
if (originalFileAcls == NULL)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
originalFileAclsLen = GetSecurityDescriptorLength(originalFileAcls);
|
||
|
|
|
||
|
|
pofiOriginalFile->QueryLastWriteTime(&originalFileTime);
|
||
|
|
|
||
|
|
pCachedFileBuffer = pofiOriginalFile->QueryFileBuffer();
|
||
|
|
|
||
|
|
pofiOriginalFile->QuerySize(&liOrigFileSize);
|
||
|
|
dwOrigFileSize = liOrigFileSize.LowPart;
|
||
|
|
|
||
|
|
securityAttributes.nLength = originalFileAclsLen;
|
||
|
|
securityAttributes.lpSecurityDescriptor = originalFileAcls;
|
||
|
|
securityAttributes.bInheritHandle = FALSE;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Do the actual file open. We open the file for exclusive access,
|
||
|
|
// and we assume that the file will not already exist.
|
||
|
|
//
|
||
|
|
|
||
|
|
hCompressedFile = CreateFile(
|
||
|
|
compressedFileName.QueryStr(),
|
||
|
|
GENERIC_WRITE,
|
||
|
|
0,
|
||
|
|
&securityAttributes,
|
||
|
|
CREATE_ALWAYS,
|
||
|
|
FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_SEQUENTIAL_SCAN,
|
||
|
|
NULL);
|
||
|
|
if (hCompressedFile == INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Loop through the file data, reading it, then compressing it, then
|
||
|
|
// writing out the compressed data.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (pCachedFileBuffer)
|
||
|
|
{
|
||
|
|
fHaveCachedFileBuffer = TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
hOriginalFile = pofiOriginalFile->QueryFileHandle();
|
||
|
|
if ( hOriginalFile == INVALID_HANDLE_VALUE )
|
||
|
|
{
|
||
|
|
hOriginalFile = NULL;
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
ovlForRead.Offset = 0;
|
||
|
|
ovlForRead.OffsetHigh = 0;
|
||
|
|
ovlForRead.hEvent = NULL;
|
||
|
|
readOffset.QuadPart = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (TRUE)
|
||
|
|
{
|
||
|
|
if (!fHaveCachedFileBuffer)
|
||
|
|
{
|
||
|
|
success = ReadFile(hOriginalFile, sm_pIoBuffer,
|
||
|
|
sm_dwIoBufferSize, &cbIo, &ovlForRead);
|
||
|
|
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
switch (readStatus = GetLastError())
|
||
|
|
{
|
||
|
|
case ERROR_HANDLE_EOF:
|
||
|
|
cbIo = 0;
|
||
|
|
success = TRUE;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERROR_IO_PENDING:
|
||
|
|
success = GetOverlappedResult(hOriginalFile, &ovlForRead, &cbIo, TRUE);
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
switch (readStatus = GetLastError())
|
||
|
|
{
|
||
|
|
case ERROR_HANDLE_EOF:
|
||
|
|
cbIo = 0;
|
||
|
|
success = TRUE;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (cbIo)
|
||
|
|
{
|
||
|
|
readOffset.QuadPart += cbIo;
|
||
|
|
ovlForRead.Offset = readOffset.LowPart;
|
||
|
|
ovlForRead.OffsetHigh = readOffset.HighPart;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// ReadFile returns zero bytes read at the end of the
|
||
|
|
// file. If we hit that, then break out of this loop.
|
||
|
|
//
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Remember that we used this compression scheme and that we
|
||
|
|
// will need to reset it on exit.
|
||
|
|
//
|
||
|
|
|
||
|
|
usedScheme = TRUE;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Write the compressed data to the output file.
|
||
|
|
//
|
||
|
|
|
||
|
|
success = CompressAndWriteData(
|
||
|
|
scheme,
|
||
|
|
fHaveCachedFileBuffer ? pCachedFileBuffer : sm_pIoBuffer,
|
||
|
|
fHaveCachedFileBuffer ? dwOrigFileSize : cbIo,
|
||
|
|
&totalBytesWritten,
|
||
|
|
hCompressedFile
|
||
|
|
);
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (fHaveCachedFileBuffer)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} // end while(TRUE)
|
||
|
|
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Tell the compression DLL that we're done with this file. It may
|
||
|
|
// return a last little bit of data for us to write to the the file.
|
||
|
|
// This is because most compression schemes store an end-of-file
|
||
|
|
// code in the compressed data stream. Using "0" as the number of
|
||
|
|
// bytes to compress handles this case.
|
||
|
|
//
|
||
|
|
|
||
|
|
success = CompressAndWriteData(
|
||
|
|
scheme,
|
||
|
|
NULL,
|
||
|
|
0,
|
||
|
|
&totalBytesWritten,
|
||
|
|
hCompressedFile
|
||
|
|
);
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Set the compressed file's creation time to be identical to the
|
||
|
|
// original file. This allows a more granular test for things being
|
||
|
|
// out of date. If we just did a greater-than-or-equal time
|
||
|
|
// comparison, then copied or renamed files might not get registered
|
||
|
|
// as changed.
|
||
|
|
//
|
||
|
|
|
||
|
|
//
|
||
|
|
// Subtract two seconds from the file time to get the file time that
|
||
|
|
// we actually want to put on the file. We do this to make sure
|
||
|
|
// that the server will send a different Etag: header for the
|
||
|
|
// compressed file than for the uncompressed file, and the server
|
||
|
|
// uses the file time to calculate the Etag: it uses.
|
||
|
|
//
|
||
|
|
// We set it in the past so that if the original file changes, it
|
||
|
|
// should never happen to get the same value as the compressed file.
|
||
|
|
// We pick two seconds instead of one second because the FAT file
|
||
|
|
// system stores file times at a granularity of two seconds.
|
||
|
|
//
|
||
|
|
|
||
|
|
pli = (PLARGE_INTEGER)(&originalFileTime);
|
||
|
|
pli->QuadPart -= 2*10*1000*1000;
|
||
|
|
|
||
|
|
success = SetFileTime(
|
||
|
|
hCompressedFile,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
&originalFileTime
|
||
|
|
);
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
CloseHandle(hCompressedFile);
|
||
|
|
hCompressedFile = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Almost done now. Just rename the file to the proper name.
|
||
|
|
//
|
||
|
|
|
||
|
|
success = MoveFileEx(
|
||
|
|
compressedFileName.QueryStr(),
|
||
|
|
realCompressedFileName.QueryStr(),
|
||
|
|
MOVEFILE_REPLACE_EXISTING);
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to limit the amount of disk space we use for
|
||
|
|
// compressed files, then update the tally of disk space used by
|
||
|
|
// compression. If the value is too high, then free up some space.
|
||
|
|
//
|
||
|
|
// Use InterlockedExchangeAdd to update this value because other
|
||
|
|
// threads may be deleting files from the compression directory
|
||
|
|
// because they have gone out of date.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (sm_fDoDiskSpaceLimiting)
|
||
|
|
{
|
||
|
|
InterlockedExchangeAdd((PLONG)&sm_dwCurrentDiskSpaceUsage,
|
||
|
|
totalBytesWritten);
|
||
|
|
|
||
|
|
if (sm_dwCurrentDiskSpaceUsage > sm_dwMaxDiskSpaceUsage)
|
||
|
|
{
|
||
|
|
FreeDiskSpace();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Free the context structure and return.
|
||
|
|
//
|
||
|
|
|
||
|
|
exit:
|
||
|
|
if (pofiOriginalFile != NULL)
|
||
|
|
{
|
||
|
|
pofiOriginalFile->DereferenceCacheEntry();
|
||
|
|
pofiOriginalFile = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pofiCompressedFile != NULL)
|
||
|
|
{
|
||
|
|
pofiCompressedFile->DereferenceCacheEntry();
|
||
|
|
pofiCompressedFile = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Reset the compression context for reuse the next time through.
|
||
|
|
// This is more optimal than recreating the compression context for
|
||
|
|
// every file--it avoids allocations, etc.
|
||
|
|
//
|
||
|
|
if (usedScheme)
|
||
|
|
{
|
||
|
|
scheme->m_pfnResetCompression(scheme->m_pCompressionContext);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hCompressedFile != NULL)
|
||
|
|
{
|
||
|
|
CloseHandle(hCompressedFile);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!success)
|
||
|
|
{
|
||
|
|
DeleteFile(compressedFileName.QueryStr());
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
VOID HTTP_COMPRESSION::FreeDiskSpace()
|
||
|
|
/*++
|
||
|
|
Routine Description:
|
||
|
|
If disk space limiting is in effect, this routine frees up the
|
||
|
|
oldest compressed files to make room for new files.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
None.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
None. This routine makes a best-effort attempt to free space, but
|
||
|
|
if it doesn't work, oh well.
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
WIN32_FIND_DATA **filesToDelete;
|
||
|
|
WIN32_FIND_DATA *currentFindData;
|
||
|
|
WIN32_FIND_DATA *findDataHolder;
|
||
|
|
BOOL success;
|
||
|
|
DWORD i;
|
||
|
|
HANDLE hDirectory = INVALID_HANDLE_VALUE;
|
||
|
|
STACK_STRU (strFile, MAX_PATH);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Allocate space to hold the array of files to delete and the
|
||
|
|
// WIN32_FIND_DATA structures that we will need. We will find the
|
||
|
|
// least-recently-used files in the compression directory to delete.
|
||
|
|
// The reason we delete multpiple files is to reduce the number of
|
||
|
|
// times that we have to go through the process of freeing up disk
|
||
|
|
// space, since this is a fairly expensive operation.
|
||
|
|
//
|
||
|
|
|
||
|
|
filesToDelete = (WIN32_FIND_DATA **)LocalAlloc(
|
||
|
|
LMEM_FIXED,
|
||
|
|
sizeof(filesToDelete)*sm_dwFilesDeletedPerDiskFree +
|
||
|
|
sizeof(WIN32_FIND_DATA)*(sm_dwFilesDeletedPerDiskFree + 1));
|
||
|
|
if (filesToDelete == NULL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Parcel out the allocation to the various uses. The initial
|
||
|
|
// currentFindData will follow the array, and then the
|
||
|
|
// WIN32_FIND_DATA structures that start off in the sorted array.
|
||
|
|
// Initialize the last access times of the entries in the array to
|
||
|
|
// 0xFFFFFFFF so that they are considered recently used and quickly
|
||
|
|
// get tossed from the array with real files.
|
||
|
|
//
|
||
|
|
|
||
|
|
currentFindData = (PWIN32_FIND_DATA)(filesToDelete + sm_dwFilesDeletedPerDiskFree);
|
||
|
|
|
||
|
|
for (i = 0; i < sm_dwFilesDeletedPerDiskFree; i++)
|
||
|
|
{
|
||
|
|
filesToDelete[i] = currentFindData + 1 + i;
|
||
|
|
filesToDelete[i]->ftLastAccessTime.dwLowDateTime = 0xFFFFFFFF;
|
||
|
|
filesToDelete[i]->ftLastAccessTime.dwHighDateTime = 0x7FFFFFFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Start enumerating the files in the compression directory. Do
|
||
|
|
// this while holding the lock that protects the
|
||
|
|
// CompressionDirectoryWildcard variable, since it is possible for
|
||
|
|
// that string pointer to get freed if there is a metabase
|
||
|
|
// configuration change. Note that holding the critical section for
|
||
|
|
// a long time is not a perf issue because, in general, only this
|
||
|
|
// thread ever acquires this lock, except for the rare configuration
|
||
|
|
// change.
|
||
|
|
//
|
||
|
|
|
||
|
|
EnterCriticalSection(&sm_CompressionDirectoryLock);
|
||
|
|
|
||
|
|
STACK_STRU (CompDirWildcard, 512);
|
||
|
|
|
||
|
|
if (FAILED(CompDirWildcard.Copy(*sm_pstrCompressionDirectory)) ||
|
||
|
|
FAILED(CompDirWildcard.Append(L"\\", 1)) ||
|
||
|
|
FAILED(CompDirWildcard.Append(COMP_FILE_PREFIX)) ||
|
||
|
|
FAILED(CompDirWildcard.Append(L"*", 1)))
|
||
|
|
{
|
||
|
|
LeaveCriticalSection(&sm_CompressionDirectoryLock);
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
hDirectory = FindFirstFile(CompDirWildcard.QueryStr(), currentFindData);
|
||
|
|
|
||
|
|
LeaveCriticalSection(&sm_CompressionDirectoryLock);
|
||
|
|
|
||
|
|
if (hDirectory == INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (TRUE)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Ignore this entry if it is a directory.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (!(currentFindData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Walk down the sorted array of files, comparing the time
|
||
|
|
// of this file against the times of the files currently in
|
||
|
|
// the array. We need to find whether this file belongs in
|
||
|
|
// the array at all, and, if so, where in the array it
|
||
|
|
// belongs.
|
||
|
|
//
|
||
|
|
|
||
|
|
for (i = 0;
|
||
|
|
i < sm_dwFilesDeletedPerDiskFree &&
|
||
|
|
CompareFileTime(¤tFindData->ftLastAccessTime,
|
||
|
|
&filesToDelete[i]->ftLastAccessTime) > 0;
|
||
|
|
i++)
|
||
|
|
{}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If this file needs to get inserted in the array, put it
|
||
|
|
// in and move the other entries forward.
|
||
|
|
//
|
||
|
|
while (i < sm_dwFilesDeletedPerDiskFree)
|
||
|
|
{
|
||
|
|
findDataHolder = currentFindData;
|
||
|
|
currentFindData = filesToDelete[i];
|
||
|
|
filesToDelete[i] = findDataHolder;
|
||
|
|
|
||
|
|
i++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Get the next file in the directory.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (!FindNextFile(hDirectory, currentFindData))
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now walk through the array of files to delete and get rid of
|
||
|
|
// them.
|
||
|
|
//
|
||
|
|
|
||
|
|
for (i = 0; i < sm_dwFilesDeletedPerDiskFree; i++)
|
||
|
|
{
|
||
|
|
if (filesToDelete[i]->ftLastAccessTime.dwHighDateTime != 0x7FFFFFFF)
|
||
|
|
{
|
||
|
|
if (FAILED(strFile.Copy(*sm_pstrCompressionDirectory)) ||
|
||
|
|
FAILED(strFile.Append(L"\\", 1)) ||
|
||
|
|
FAILED(strFile.Append(filesToDelete[i]->cFileName)))
|
||
|
|
{
|
||
|
|
goto exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (DeleteFile(strFile.QueryStr()))
|
||
|
|
{
|
||
|
|
InterlockedExchangeAdd((LPLONG)&sm_dwCurrentDiskSpaceUsage,
|
||
|
|
-(LONG)filesToDelete[i]->nFileSizeLow);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
exit:
|
||
|
|
if (filesToDelete)
|
||
|
|
{
|
||
|
|
LocalFree(filesToDelete);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hDirectory != INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
FindClose(hDirectory);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
BOOL HTTP_COMPRESSION::CompressAndWriteData(
|
||
|
|
COMPRESSION_SCHEME *scheme,
|
||
|
|
PBYTE InputBuffer,
|
||
|
|
DWORD BytesToCompress,
|
||
|
|
PDWORD BytesWritten,
|
||
|
|
HANDLE hCompressedFile)
|
||
|
|
/*++
|
||
|
|
Routine Description:
|
||
|
|
Takes uncompressed data, compresses it with the specified compression
|
||
|
|
scheme, and writes the result to the specified file.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
Scheme - the compression scheme to use.
|
||
|
|
|
||
|
|
InputBuffer - the data we need to compress.
|
||
|
|
|
||
|
|
BytesToCompress - the size of the input buffer, or 0 if we should
|
||
|
|
flush the compression buffers to the file at the end of the
|
||
|
|
input file. Note that this routine DOES NOT handle compressing
|
||
|
|
a zero-byte file; we assume that the input file has some data.
|
||
|
|
|
||
|
|
BytesWritten - the number of bytes written to the output file.
|
||
|
|
|
||
|
|
hCompressedFile - a handle to the file to which we should write the
|
||
|
|
compressed results.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
None. This routine makes a best-effort attempt to free space, but
|
||
|
|
if it doesn't work, oh well.
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
DWORD inputBytesUsed;
|
||
|
|
DWORD bytesCompressed;
|
||
|
|
HRESULT hResult;
|
||
|
|
BOOL keepGoing;
|
||
|
|
BOOL success;
|
||
|
|
DWORD cbIo;
|
||
|
|
|
||
|
|
if (sm_fIsTerminating)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Perform compression on the actual file data. Note that it is
|
||
|
|
// possible that the compressed data is actually larger than the
|
||
|
|
// input data, so we might need to call the compression routine
|
||
|
|
// multiple times.
|
||
|
|
//
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
bytesCompressed = sm_dwCompressionBufferSize;
|
||
|
|
|
||
|
|
hResult = scheme->m_pfnCompress(
|
||
|
|
scheme->m_pCompressionContext,
|
||
|
|
InputBuffer,
|
||
|
|
BytesToCompress,
|
||
|
|
sm_pCompressionBuffer,
|
||
|
|
sm_dwCompressionBufferSize,
|
||
|
|
(PLONG)&inputBytesUsed,
|
||
|
|
(PLONG)&bytesCompressed,
|
||
|
|
scheme->m_dwOnDemandCompressionLevel);
|
||
|
|
|
||
|
|
if (FAILED(hResult))
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hResult == S_OK && BytesToCompress == 0)
|
||
|
|
{
|
||
|
|
keepGoing = TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
keepGoing = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the compressor gave us any data, then write the result to
|
||
|
|
// disk. Some compression schemes buffer up data in order to
|
||
|
|
// perform better compression, so not every compression call
|
||
|
|
// will result in output data.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (bytesCompressed > 0)
|
||
|
|
{
|
||
|
|
if (!WriteFile(hCompressedFile,
|
||
|
|
sm_pCompressionBuffer,
|
||
|
|
bytesCompressed,
|
||
|
|
&cbIo,
|
||
|
|
NULL))
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
*BytesWritten += cbIo;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Update the number of input bytes that we have compressed
|
||
|
|
// so far, and adjust the input buffer pointer accordingly.
|
||
|
|
//
|
||
|
|
|
||
|
|
BytesToCompress -= inputBytesUsed;
|
||
|
|
InputBuffer += inputBytesUsed;
|
||
|
|
}
|
||
|
|
while ( BytesToCompress > 0 || keepGoing );
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
BOOL DoesCacheControlNeedMaxAge(IN PCHAR CacheControlHeaderValue)
|
||
|
|
/*++
|
||
|
|
|
||
|
|
Routine Description:
|
||
|
|
|
||
|
|
This function determines whether the Cache-Control header on a
|
||
|
|
compressed response needs to have the max-age directive added.
|
||
|
|
If there is already a max-age, or if there is a no-cache directive,
|
||
|
|
then we should not add max-age.
|
||
|
|
|
||
|
|
Arguments:
|
||
|
|
|
||
|
|
CacheControlHeaderValue - the value of the cache control header to
|
||
|
|
scan. The string should be zero-terminated.
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
|
||
|
|
TRUE if we need to add max-age; FALSE if we should not add max-age.
|
||
|
|
|
||
|
|
--*/
|
||
|
|
|
||
|
|
{
|
||
|
|
if (strstr(CacheControlHeaderValue, "max-age"))
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
PCHAR s;
|
||
|
|
while (s = strstr(CacheControlHeaderValue, "no-cache"))
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// If it is a no-cache=foo then it only refers to a specific header
|
||
|
|
// Continue
|
||
|
|
//
|
||
|
|
|
||
|
|
if (s[8] != '=')
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
CacheControlHeaderValue = s + 8;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// We didn't find any directives that would prevent us from adding
|
||
|
|
// max-age.
|
||
|
|
//
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::OnSendResponse(
|
||
|
|
IN W3_CONTEXT *pW3Context,
|
||
|
|
IN BOOL fMoreData)
|
||
|
|
{
|
||
|
|
W3_RESPONSE *pResponse = pW3Context->QueryResponse();
|
||
|
|
W3_REQUEST *pRequest = pW3Context->QueryRequest();
|
||
|
|
|
||
|
|
//
|
||
|
|
// If compression is not initialized, return
|
||
|
|
//
|
||
|
|
if (!sm_fHttpCompressionInitialized)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If Response status is not 200 (let us not try compressing 206, 3xx or
|
||
|
|
// error responses), return
|
||
|
|
//
|
||
|
|
if (pResponse->QueryStatusCode() != HttpStatusOk.statusCode &&
|
||
|
|
pResponse->QueryStatusCode() != HttpStatusMultiStatus.statusCode)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the client has not sent an Accept-Encoding header, or an empty
|
||
|
|
// Accept-Encoding header, return
|
||
|
|
//
|
||
|
|
CHAR *pszAcceptEncoding = pRequest->GetHeader(HttpHeaderAcceptEncoding);
|
||
|
|
if (pszAcceptEncoding == NULL || *pszAcceptEncoding == L'\0')
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Don't compress for TRACEs
|
||
|
|
//
|
||
|
|
HTTP_VERB VerbType = pW3Context->QueryRequest()->QueryVerbType();
|
||
|
|
if (VerbType == HttpVerbTRACE ||
|
||
|
|
VerbType == HttpVerbTRACK)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to not compress for 1.0, and version is not 1.1,
|
||
|
|
// return
|
||
|
|
//
|
||
|
|
if (sm_fNoCompressionForHttp10 &&
|
||
|
|
((pRequest->QueryVersion().MajorVersion == 0) ||
|
||
|
|
((pRequest->QueryVersion().MajorVersion == 1) &&
|
||
|
|
(pRequest->QueryVersion().MinorVersion == 0))))
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are configured to not compress for proxies and it is a proxy
|
||
|
|
// request, return
|
||
|
|
//
|
||
|
|
if (sm_fNoCompressionForProxies && pRequest->IsProxyRequest())
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the response already has a Content-Encoding header, return
|
||
|
|
//
|
||
|
|
if (pResponse->GetHeader(HttpHeaderContentEncoding))
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now see if we have any matching scheme
|
||
|
|
//
|
||
|
|
STACK_STRA( strAcceptEncoding, 512);
|
||
|
|
HRESULT hr;
|
||
|
|
if (FAILED(hr = strAcceptEncoding.Copy(pszAcceptEncoding)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
STRU *pstrPhysical = pW3Context->QueryUrlContext()->QueryPhysicalPath();
|
||
|
|
LPWSTR pszExtension = wcsrchr(pstrPhysical->QueryStr(), L'.');
|
||
|
|
if (pszExtension != NULL)
|
||
|
|
{
|
||
|
|
pszExtension++;
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD dwClientCompressionCount;
|
||
|
|
DWORD matchingSchemes[MAX_SERVER_SCHEMES];
|
||
|
|
//
|
||
|
|
// Find out all schemes which will compress for this url
|
||
|
|
//
|
||
|
|
FindMatchingSchemes(strAcceptEncoding.QueryStr(),
|
||
|
|
pszExtension,
|
||
|
|
DO_DYNAMIC_COMPRESSION,
|
||
|
|
matchingSchemes,
|
||
|
|
&dwClientCompressionCount);
|
||
|
|
if (dwClientCompressionCount == 0)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// All tests passed, we are GO for dynamic compression
|
||
|
|
//
|
||
|
|
COMPRESSION_CONTEXT *pCompressionContext = new COMPRESSION_CONTEXT;
|
||
|
|
if (pCompressionContext == NULL)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
||
|
|
}
|
||
|
|
pW3Context->SetCompressionContext(pCompressionContext);
|
||
|
|
pCompressionContext->m_pScheme = sm_pCompressionSchemes[matchingSchemes[0]];
|
||
|
|
|
||
|
|
PCHAR xferEncoding = pResponse->GetHeader(HttpHeaderTransferEncoding);
|
||
|
|
if (xferEncoding &&
|
||
|
|
_stricmp(xferEncoding, "chunked") == 0)
|
||
|
|
{
|
||
|
|
pCompressionContext->m_fTransferChunkEncoded = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Remove the Content-Length header, set the Content-Encoding, Vary and
|
||
|
|
// Transfer-Encoding headers
|
||
|
|
//
|
||
|
|
if (FAILED(hr = pResponse->SetHeaderByReference(HttpHeaderContentLength,
|
||
|
|
NULL, 0)) ||
|
||
|
|
FAILED(hr = pResponse->SetHeaderByReference(
|
||
|
|
HttpHeaderContentEncoding,
|
||
|
|
pCompressionContext->m_pScheme->m_straCompressionSchemeName.QueryStr(),
|
||
|
|
pCompressionContext->m_pScheme->m_straCompressionSchemeName.QueryCCH())) ||
|
||
|
|
FAILED(hr = pResponse->SetHeader(HttpHeaderVary,
|
||
|
|
"Accept-Encoding", 15,
|
||
|
|
TRUE)) ||
|
||
|
|
FAILED(hr = pResponse->SetHeaderByReference(HttpHeaderTransferEncoding,
|
||
|
|
"chunked", 7)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sm_fSendCacheHeaders)
|
||
|
|
{
|
||
|
|
if (FAILED(hr = pResponse->SetHeaderByReference(
|
||
|
|
HttpHeaderExpires,
|
||
|
|
sm_pstrExpiresHeader->QueryStr(),
|
||
|
|
sm_pstrExpiresHeader->QueryCCH())))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
PCHAR cacheControl = pResponse->GetHeader(HttpHeaderCacheControl);
|
||
|
|
if (!cacheControl || DoesCacheControlNeedMaxAge(cacheControl))
|
||
|
|
{
|
||
|
|
if (FAILED(hr = pResponse->SetHeader(
|
||
|
|
HttpHeaderCacheControl,
|
||
|
|
sm_pstrCacheControlHeader->QueryStr(),
|
||
|
|
sm_pstrCacheControlHeader->QueryCCH(),
|
||
|
|
TRUE)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Get a compression context
|
||
|
|
//
|
||
|
|
if (FAILED(hr = pCompressionContext->m_pScheme->m_pfnCreateCompression(
|
||
|
|
&pCompressionContext->m_pCompressionContext,
|
||
|
|
pCompressionContext->m_pScheme->m_dwCreateFlags)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Ok, done with all the header stuff, now actually start compressing
|
||
|
|
// the entity
|
||
|
|
//
|
||
|
|
|
||
|
|
if (VerbType == HttpVerbHEAD)
|
||
|
|
{
|
||
|
|
pCompressionContext->m_fRequestIsHead = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// BUGBUG: UL does not know about compression right now, so
|
||
|
|
// disable UL caching for this response
|
||
|
|
//
|
||
|
|
pW3Context->DisableUlCache();
|
||
|
|
|
||
|
|
return DoDynamicCompression(pW3Context,
|
||
|
|
fMoreData);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// static
|
||
|
|
HRESULT HTTP_COMPRESSION::DoDynamicCompression(
|
||
|
|
IN W3_CONTEXT *pW3Context,
|
||
|
|
IN BOOL fMoreData)
|
||
|
|
{
|
||
|
|
COMPRESSION_CONTEXT *pCompressionContext = pW3Context->QueryCompressionContext();
|
||
|
|
|
||
|
|
if (pCompressionContext == NULL)
|
||
|
|
{
|
||
|
|
pW3Context->SetDoneWithCompression();
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
pCompressionContext->FreeBuffers();
|
||
|
|
|
||
|
|
//
|
||
|
|
// Get hold of the response chunks
|
||
|
|
//
|
||
|
|
W3_RESPONSE *pResponse = pW3Context->QueryResponse();
|
||
|
|
HRESULT hr;
|
||
|
|
if (FAILED(hr = pResponse->GetChunks(&pCompressionContext->m_ULChunkBuffer,
|
||
|
|
&pCompressionContext->m_cULChunks)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (pCompressionContext->m_cULChunks > 0)
|
||
|
|
{
|
||
|
|
pCompressionContext->m_fOriginalBodyEmpty = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the request was a HEAD request and we haven't seen any
|
||
|
|
// entity body, no point in going any further (if the output
|
||
|
|
// is already suppressed, we do not want to compress it and make it
|
||
|
|
// non-empty)
|
||
|
|
//
|
||
|
|
if (pCompressionContext->m_fRequestIsHead &&
|
||
|
|
pCompressionContext->m_fOriginalBodyEmpty)
|
||
|
|
{
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
pCompressionContext->m_cCurrentULChunk = 0;
|
||
|
|
pCompressionContext->m_pCurrentULChunk =
|
||
|
|
(HTTP_DATA_CHUNK *)pCompressionContext->m_ULChunkBuffer.QueryPtr();
|
||
|
|
//
|
||
|
|
// Do whatever is necessary to setup the current chunk of response
|
||
|
|
// e.g. do an I/O for FileHandle chunk
|
||
|
|
//
|
||
|
|
if (FAILED(hr = pCompressionContext->SetupCurrentULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL fKeepGoing;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
fKeepGoing = FALSE;
|
||
|
|
|
||
|
|
if (pCompressionContext->m_fTransferChunkEncoded)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// If the input data is being chunk-transfered, initially,
|
||
|
|
// we'll be looking at the chunk header. This is a hex
|
||
|
|
// representation of the number of bytes in this chunk.
|
||
|
|
// Translate this number from ASCII to a DWORD and remember
|
||
|
|
// it. Also advance the chunk pointer to the start of the
|
||
|
|
// actual data.
|
||
|
|
//
|
||
|
|
|
||
|
|
if (FAILED(hr = pCompressionContext->ProcessEncodedChunkHeader()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Try to compress all the contiguous bytes
|
||
|
|
//
|
||
|
|
DWORD bytesToCompress = 0;
|
||
|
|
if (pCompressionContext->m_cCurrentULChunk < pCompressionContext->m_cULChunks)
|
||
|
|
{
|
||
|
|
bytesToCompress = pCompressionContext->QueryBytesAvailable();
|
||
|
|
if (pCompressionContext->m_fTransferChunkEncoded)
|
||
|
|
{
|
||
|
|
bytesToCompress =
|
||
|
|
min(bytesToCompress,
|
||
|
|
pCompressionContext->m_dwBytesInCurrentEncodedChunk);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fMoreData || bytesToCompress > 0)
|
||
|
|
{
|
||
|
|
DWORD inputBytesUsed = 0;
|
||
|
|
DWORD bytesCompressed = 0;
|
||
|
|
|
||
|
|
PBYTE compressionBuffer = pCompressionContext->GetNewBuffer();
|
||
|
|
|
||
|
|
hr = pCompressionContext->m_pScheme->m_pfnCompress(
|
||
|
|
pCompressionContext->m_pCompressionContext,
|
||
|
|
bytesToCompress ? pCompressionContext->QueryBytePtr() : NULL,
|
||
|
|
bytesToCompress,
|
||
|
|
compressionBuffer + 6,
|
||
|
|
DYNAMIC_COMPRESSION_BUFFER_SIZE,
|
||
|
|
(PLONG)&inputBytesUsed,
|
||
|
|
(PLONG)&bytesCompressed,
|
||
|
|
pCompressionContext->m_pScheme->m_dwDynamicCompressionLevel);
|
||
|
|
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (hr == S_OK)
|
||
|
|
{
|
||
|
|
fKeepGoing = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr =
|
||
|
|
pCompressionContext->IncrementPointerInULChunk(inputBytesUsed)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
if (pCompressionContext->m_fTransferChunkEncoded)
|
||
|
|
{
|
||
|
|
pCompressionContext->m_dwBytesInCurrentEncodedChunk -=
|
||
|
|
inputBytesUsed;
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD startSendLocation = 8;
|
||
|
|
DWORD bytesToSend = 0;
|
||
|
|
|
||
|
|
if (bytesCompressed > 0)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// Add the CRLF just before and after the chunk data
|
||
|
|
//
|
||
|
|
compressionBuffer[4] = '\r';
|
||
|
|
compressionBuffer[5] = '\n';
|
||
|
|
|
||
|
|
compressionBuffer[bytesCompressed + 6] = '\r';
|
||
|
|
compressionBuffer[bytesCompressed + 7] = '\n';
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now create the chunk header which is basically the chunk
|
||
|
|
// size written out in hex
|
||
|
|
//
|
||
|
|
|
||
|
|
if (bytesCompressed < 0x10 )
|
||
|
|
{
|
||
|
|
startSendLocation = 3;
|
||
|
|
bytesToSend = 3 + bytesCompressed + 2;
|
||
|
|
compressionBuffer[3] = HEX_TO_ASCII(bytesCompressed);
|
||
|
|
}
|
||
|
|
else if (bytesCompressed < 0x100)
|
||
|
|
{
|
||
|
|
startSendLocation = 2;
|
||
|
|
bytesToSend = 4 + bytesCompressed + 2;
|
||
|
|
compressionBuffer[2] = HEX_TO_ASCII(bytesCompressed >> 4);
|
||
|
|
compressionBuffer[3] = HEX_TO_ASCII(bytesCompressed & 0xF);
|
||
|
|
}
|
||
|
|
else if (bytesCompressed < 0x1000)
|
||
|
|
{
|
||
|
|
startSendLocation = 1;
|
||
|
|
bytesToSend = 5 + bytesCompressed + 2;
|
||
|
|
compressionBuffer[1] = HEX_TO_ASCII(bytesCompressed >> 8);
|
||
|
|
compressionBuffer[2] = HEX_TO_ASCII((bytesCompressed >> 4) & 0xF);
|
||
|
|
compressionBuffer[3] = HEX_TO_ASCII(bytesCompressed & 0xF);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DBG_ASSERT( bytesCompressed < 0x10000 );
|
||
|
|
|
||
|
|
startSendLocation = 0;
|
||
|
|
bytesToSend = 6 + bytesCompressed + 2;
|
||
|
|
compressionBuffer[0] = HEX_TO_ASCII(bytesCompressed >> 12);
|
||
|
|
compressionBuffer[1] = HEX_TO_ASCII((bytesCompressed >> 8) & 0xF);
|
||
|
|
compressionBuffer[2] = HEX_TO_ASCII((bytesCompressed >> 4) & 0xF);
|
||
|
|
compressionBuffer[3] = HEX_TO_ASCII(bytesCompressed & 0xF);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fKeepGoing)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// If this is the last send, add the trailer 0 length chunk
|
||
|
|
//
|
||
|
|
|
||
|
|
memcpy(compressionBuffer + bytesCompressed + 8, "0\r\n\r\n", 5);
|
||
|
|
bytesToSend += 5;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!fKeepGoing || bytesCompressed > 0)
|
||
|
|
{
|
||
|
|
if (FAILED(hr = pResponse->AddMemoryChunkByReference(
|
||
|
|
compressionBuffer + startSendLocation,
|
||
|
|
bytesToSend)))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
while (fKeepGoing);
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT COMPRESSION_CONTEXT::SetupCurrentULChunk()
|
||
|
|
/*++
|
||
|
|
Set up this new chunk so that compression has some bytes to read. If
|
||
|
|
the current chunk is a 0 length chunk or we have reached the end-of-file
|
||
|
|
on the file handle, this function will recurse
|
||
|
|
|
||
|
|
Return Value:
|
||
|
|
HRESULT
|
||
|
|
--*/
|
||
|
|
{
|
||
|
|
if (m_cCurrentULChunk >= m_cULChunks)
|
||
|
|
{
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_pCurrentULChunk->DataChunkType == HttpDataChunkFromMemory)
|
||
|
|
{
|
||
|
|
if (m_pCurrentULChunk->FromMemory.BufferLength == 0)
|
||
|
|
{
|
||
|
|
m_cCurrentULChunk++;
|
||
|
|
m_pCurrentULChunk++;
|
||
|
|
return SetupCurrentULChunk();
|
||
|
|
}
|
||
|
|
|
||
|
|
m_fCurrentULChunkFromMemory = TRUE;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
// We do not (nor do we plan to) handle filename chunks
|
||
|
|
DBG_ASSERT(m_pCurrentULChunk->DataChunkType == HttpDataChunkFromFileHandle);
|
||
|
|
m_fCurrentULChunkFromMemory = FALSE;
|
||
|
|
if (m_pIoBuffer == NULL)
|
||
|
|
{
|
||
|
|
m_pIoBuffer = new BYTE[DYNAMIC_COMPRESSION_BUFFER_SIZE];
|
||
|
|
if (m_pIoBuffer == NULL)
|
||
|
|
{
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD bytesToRead =
|
||
|
|
(DWORD)min(DYNAMIC_COMPRESSION_BUFFER_SIZE,
|
||
|
|
m_pCurrentULChunk->FromFileHandle.ByteRange.Length.QuadPart);
|
||
|
|
|
||
|
|
OVERLAPPED ovl;
|
||
|
|
ZeroMemory(&ovl, sizeof ovl);
|
||
|
|
ovl.Offset =
|
||
|
|
m_pCurrentULChunk->FromFileHandle.ByteRange.StartingOffset.LowPart;
|
||
|
|
ovl.OffsetHigh =
|
||
|
|
m_pCurrentULChunk->FromFileHandle.ByteRange.StartingOffset.HighPart;
|
||
|
|
DWORD bytesRead = 0;
|
||
|
|
|
||
|
|
if (!ReadFile(m_pCurrentULChunk->FromFileHandle.FileHandle,
|
||
|
|
m_pIoBuffer,
|
||
|
|
bytesToRead,
|
||
|
|
&bytesRead,
|
||
|
|
&ovl))
|
||
|
|
{
|
||
|
|
DWORD dwErr = GetLastError();
|
||
|
|
switch (dwErr)
|
||
|
|
{
|
||
|
|
case ERROR_IO_PENDING:
|
||
|
|
if (!GetOverlappedResult(
|
||
|
|
m_pCurrentULChunk->FromFileHandle.FileHandle,
|
||
|
|
&ovl,
|
||
|
|
&bytesRead,
|
||
|
|
TRUE))
|
||
|
|
{
|
||
|
|
dwErr = GetLastError();
|
||
|
|
switch(dwErr)
|
||
|
|
{
|
||
|
|
case ERROR_HANDLE_EOF:
|
||
|
|
m_pCurrentULChunk++;
|
||
|
|
m_cCurrentULChunk++;
|
||
|
|
return SetupCurrentULChunk();
|
||
|
|
|
||
|
|
default:
|
||
|
|
return HRESULT_FROM_WIN32(dwErr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERROR_HANDLE_EOF:
|
||
|
|
m_pCurrentULChunk++;
|
||
|
|
m_cCurrentULChunk++;
|
||
|
|
return SetupCurrentULChunk();
|
||
|
|
|
||
|
|
default:
|
||
|
|
return HRESULT_FROM_WIN32(dwErr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
m_pCurrentULChunk->FromFileHandle.ByteRange.Length.QuadPart -= bytesRead;
|
||
|
|
m_pCurrentULChunk->FromFileHandle.ByteRange.StartingOffset.QuadPart +=
|
||
|
|
bytesRead;
|
||
|
|
m_currentLocationInIoBuffer = 0;
|
||
|
|
m_bytesInIoBuffer = bytesRead;
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT COMPRESSION_CONTEXT::ProcessEncodedChunkHeader()
|
||
|
|
{
|
||
|
|
HRESULT hr;
|
||
|
|
|
||
|
|
while ((m_dwBytesInCurrentEncodedChunk == 0 ||
|
||
|
|
m_encodedChunkState != IN_CHUNK_DATA) &&
|
||
|
|
m_cCurrentULChunk < m_cULChunks)
|
||
|
|
{
|
||
|
|
switch (m_encodedChunkState)
|
||
|
|
{
|
||
|
|
case IN_CHUNK_LENGTH:
|
||
|
|
if (FAILED(hr = CalculateEncodedChunkByteCount()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IN_CHUNK_EXTENSION:
|
||
|
|
if (FAILED(hr = DeleteEncodedChunkExtension()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IN_CHUNK_HEADER_NEW_LINE:
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
m_encodedChunkState = IN_CHUNK_DATA;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case AT_CHUNK_DATA_NEW_LINE:
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
m_encodedChunkState = IN_CHUNK_DATA_NEW_LINE;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IN_CHUNK_DATA_NEW_LINE:
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
m_encodedChunkState = IN_CHUNK_LENGTH;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case IN_CHUNK_DATA:
|
||
|
|
m_encodedChunkState = AT_CHUNK_DATA_NEW_LINE;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
DBG_ASSERT(FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT COMPRESSION_CONTEXT::IncrementPointerInULChunk(IN DWORD dwIncr)
|
||
|
|
{
|
||
|
|
while (dwIncr &&
|
||
|
|
(m_cCurrentULChunk < m_cULChunks))
|
||
|
|
{
|
||
|
|
DWORD bytesLeft = QueryBytesAvailable();
|
||
|
|
if (bytesLeft > dwIncr)
|
||
|
|
{
|
||
|
|
if (m_fCurrentULChunkFromMemory)
|
||
|
|
{
|
||
|
|
m_pCurrentULChunk->FromMemory.pBuffer =
|
||
|
|
(PBYTE)m_pCurrentULChunk->FromMemory.pBuffer + dwIncr;
|
||
|
|
m_pCurrentULChunk->FromMemory.BufferLength -= dwIncr;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// We do not (nor do we plan to) handle filename chunks
|
||
|
|
DBG_ASSERT(m_pCurrentULChunk->DataChunkType == HttpDataChunkFromFileHandle);
|
||
|
|
m_currentLocationInIoBuffer += dwIncr;
|
||
|
|
}
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
dwIncr -= bytesLeft;
|
||
|
|
if (m_fCurrentULChunkFromMemory ||
|
||
|
|
m_pCurrentULChunk->FromFileHandle.ByteRange.Length.QuadPart == 0)
|
||
|
|
{
|
||
|
|
m_cCurrentULChunk++;
|
||
|
|
m_pCurrentULChunk++;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT hr;
|
||
|
|
if (FAILED(hr = SetupCurrentULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT COMPRESSION_CONTEXT::CalculateEncodedChunkByteCount()
|
||
|
|
{
|
||
|
|
CHAR c;
|
||
|
|
HRESULT hr;
|
||
|
|
//
|
||
|
|
// Walk to the first '\r' or ';' which signifies the end of the chunk
|
||
|
|
// byte count
|
||
|
|
//
|
||
|
|
|
||
|
|
while (m_cCurrentULChunk < m_cULChunks &&
|
||
|
|
SAFEIsXDigit(c = (CHAR)*QueryBytePtr()))
|
||
|
|
{
|
||
|
|
m_dwBytesInCurrentEncodedChunk <<= 4;
|
||
|
|
if (c >= '0' && c <= '9')
|
||
|
|
{
|
||
|
|
m_dwBytesInCurrentEncodedChunk += c - '0';
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_dwBytesInCurrentEncodedChunk += (c | 0x20) - 'a' + 10;
|
||
|
|
}
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_cCurrentULChunk < m_cULChunks)
|
||
|
|
{
|
||
|
|
if (c == ';')
|
||
|
|
{
|
||
|
|
m_encodedChunkState = IN_CHUNK_EXTENSION;
|
||
|
|
}
|
||
|
|
else if (c == '\r')
|
||
|
|
{
|
||
|
|
m_encodedChunkState = IN_CHUNK_HEADER_NEW_LINE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DBG_ASSERT(!"Malformed chunk header");
|
||
|
|
return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT COMPRESSION_CONTEXT::DeleteEncodedChunkExtension()
|
||
|
|
{
|
||
|
|
CHAR c;
|
||
|
|
HRESULT hr;
|
||
|
|
//
|
||
|
|
// Walk to the first '\r' which signifies the end of the chunk extension
|
||
|
|
//
|
||
|
|
|
||
|
|
while (m_cCurrentULChunk < m_cULChunks &&
|
||
|
|
(c = (CHAR)*QueryBytePtr()) != '\r')
|
||
|
|
{
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (m_cCurrentULChunk < m_cULChunks)
|
||
|
|
{
|
||
|
|
m_encodedChunkState = IN_CHUNK_HEADER_NEW_LINE;
|
||
|
|
if (FAILED(hr = IncrementPointerInULChunk()))
|
||
|
|
{
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|