KEYS.CPP
/*++
Copyright (c) 1997 Microsoft Corporation
Module Name: keys.cpp
Abstract:
This module contains functions which deal with keys and values
on inbound form data. Please, see keys.h for details.
--*/
#define WIN32_LEAN_AND_MEAN // the bare essential Win32 API
#include <windows.h>
#include <httpext.h>
//
// If your application plans to receive huge amounts of data
// and you don't want megabytes of memory allocated, define
// the USE_TEMPORARY_FILES. It is recommended to leave the
// define line below commented out unless absolutely necessary.
//
//#define USE_TEMPORARY_FILES
#include "keys.h"
#ifndef USE_MEMORY
#ifndef USE_TEMPORARY_FILES
#define USE_MEMORY
#endif
#endif
//
// If you want to record errors, modify this macro definition to
// call your own logging function. This sample does not save
// error strings.
//
#define LOG(errorstring) // OutputDebugString( errorstring ); \
// OutputDebugString ( "\r\n" )
//
//
// Intended external interface:
//
// GetKeyList Determines if data was sent, and if it was, the
// data is extracted by GetPostKeys or GetUrlKeys,
// two private functions within this file. A
// pointer to a linked list is returned ( as a
// handle ).
//
// GetKeyInfo Returns a pointer to the key name,
// the length of the data, a flag indicating if
// the data has control characters in it, and an
// instance number for duplicate key names.
//
// GetKeyBuffer Returns a pointer to the buffer holding the key's
// data.
//
// FindKey Sequentially searches linked list for key name.
//
// FreeKeyList Deallocates memory used by the linked list of
// keys. Also deletes content resources.
//
// GetKeyOffset Returns the offset to either the content memory
// buffer or the content temporary file.
//
// GetContentFile Returns a pointer to the temporary file, only
// when USE_TEMPORARY_FILES is defined.
//
// CloseContentFile Closes the content file, normally left open
// until FreeKeyList is called, available only
// when USE_TEMPORARY_FILES is defined.
//
// OpenContentFile Reopens the content file for additional use
// by GetKeyBuffer, available only when
// USE_TEMPORARY_FILES is defined.
//
// GetDataBuffer Returns a pointer to the content, only if the
// USE_TEMPORARY_FILES constant is NOT defined.
//
// Helper functions called only in this source file:
//
// GetQueryByte Similar to GetPostedByte, this function
// extracts data from the query string.
//
// HexDigitToInt Returns the decimal value of a hex character.
//
// GetFirstByte Sets up POSDATA struct and calls GetNextByte.
// Caller specifies function used to retrieve
// data, either GetPostedByte or GetQueryByte.
//
// GetNextByte Uses GetInboundByte ( specified in GetFirstByte )
// to retrieve inbound data, and decodes it using
// the URL encoding rules.
//
// BKL_Alloc Allocates memory used in GetPostKeys.
//
// BKL_Dealloc Deallocates memory used in GetPostKeys.
//
// BKL_Abort Cleans up all resources for abnormal exits from
// GetPostKeys.
//
// IsKeySeparator Returns TRUE if character is one of "=\r\n&\0".
//
// BuildKeyList Given a data extraction function ( i.e.
// GetPostedByte or GetQueryByte ), this function
// converts all keys into a linked list of POSTKEY
// structures.
//
// GetPostKeys Takes inbound data off the wire by calling
// BuildKeyList with GetPostedByte as the extraction
// function.
//
// GetUrlKeys Extracts data from the query string by calling
// BuildKeyList with GetQueryByte as the extraction
// function.
//
// GetPropAddr Calculates the address of the list's properties,
// appended to the first key in a list.
//
// The typedef for the linked list is kept privately in this file,
// and our interface isolates other source files from the
// implementation details.
//
//
// Constants for this source file only
//
#define MAX_KEY_NAME_LENGTH 256 // maximum size of an inbound key name
#define CONTENT_BUF_LENGTH 8192 // amount of content buffered before
// WriteFile call
// ( used for temporary files only )
#define GNB_NOTHING_LEFT 0 // GetNextByte return values
#define GNB_DECODED_CHAR 1
#define GNB_NORMAL_CHAR 2
//
// POSDATA struct is used with GetInboundByte to keep
// track of the position within incoming data.
// GETINBOUNDBYTE is a function pointer type.
//
typedef struct _tagPOSDATA {
EXTENSION_CONTROL_BLOCK *pECB;
int nCurrentPos; // overall position
int nBufferLength; // length of buffer
int nBufferPos; // position within buffer
int nAllocLength; // size of buffer as allocated
LPBYTE pData;
int (*GetInboundByte)(struct _tagPOSDATA * p);
} POSDATA, *PPOSDATA;
typedef int (*GETINBOUNDBYTE)(PPOSDATA p);
#ifdef USE_MEMORY
//
// LISTPROP struct is used to maintain a set of
// list-wide properties. This implementation
// uses the properties list to hold a buffer
// pointer.
//
typedef struct _tagLISTPROP {
LPBYTE lpbyBuf;
} LISTPROP, *PLISTPROP;
#elif defined USE_TEMPORARY_FILES
//
// This LISTPROP struct holds temporary
// file information.
//
typedef struct _tagLISTPROP {
char szTempFileName[MAX_PATH];
HANDLE hFile;
} LISTPROP, *PLISTPROP;
#endif
// This private helper needs a prototype
PLISTPROP GetPropAddr( HKEYLIST hKey );
int
GetPostedByte(
PPOSDATA pPosData
)
/*++
Purpose:
GetPostedByte returns a waiting character that is not
decoded yet. We have this function to smooth out the
inbound data: the server gives us blocks of data, one at
a time, and there can be any number of blocks.
For the first call, pPosData->nAllocLength must be zero,
and pECB must be set.
Arguments:
pPostData - pointer to POSTDATA struct
Returns:
incoming byte value or
-1 to indicate an error
--*/
{
int nBytesToCopy;
// For readability only...
EXTENSION_CONTROL_BLOCK *pECB;
pECB = pPosData->pECB;
//
// Initialize position struct on first call.
//
if ( !pPosData->nAllocLength ) {
// Initialize the members
pPosData->nCurrentPos = 0;
pPosData->nBufferPos = 0;
pPosData->nBufferLength = 0;
pPosData->nAllocLength = 0x10000; // 65536 bytes
// Allocate the memory
pPosData->pData = (LPBYTE) HeapAlloc(
GetProcessHeap( ),
HEAP_ZERO_MEMORY,
pPosData->nAllocLength );
}
//
// Was memory allocated? Is it still allocated?
// If not, return right away.
//
if ( !pPosData->pData ) {
LOG( "GetPostedByte: Buffer not allocated." );
return -1;
}
//
// Check for end. Deallocate and return if we're done.
//
if ( (DWORD) pPosData->nCurrentPos == pECB->cbTotalBytes ) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) pPosData->pData );
pPosData->pData = 0;
return -1;
}
//
// Check for buffer not loaded. Load if necessary.
//
if ( pPosData->nBufferPos == pPosData->nBufferLength ) {
//
// Fill the buffer with new inbound data.
// Request it via ReadClient if necessary.
//
if ( pECB->cbAvailable < 1 ) {
// Calculate how much we should go and get
nBytesToCopy = pECB->cbTotalBytes - pPosData->nCurrentPos;
if ( nBytesToCopy > pPosData->nAllocLength ) {
nBytesToCopy = pPosData->nAllocLength;
}
// Let's go get the data
if ( !pECB->ReadClient(
pECB->ConnID,
pPosData->pData,
(LPDWORD) & nBytesToCopy
)) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) pPosData->pData );
pPosData->pData = 0;
LOG( "GetPostedByte: Error reading data via ReadClient" );
return -1;
}
}else{
// Take at most nAllocLength bytes of data
if ( pECB->cbAvailable > (DWORD) (pPosData->nAllocLength) ) {
nBytesToCopy = pPosData->nAllocLength;
}else{
nBytesToCopy = pECB->cbAvailable;
}
// Copy the inbound data to our buffer
memcpy(
pPosData->pData,
&pECB->lpbData[pPosData->nCurrentPos],
nBytesToCopy
);
// Account for removed data
pECB->cbAvailable -= nBytesToCopy;
}
// Our buffer is now full
pPosData->nBufferLength = nBytesToCopy;
pPosData->nBufferPos = 0;
// Make sure we have something
if ( !nBytesToCopy ) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) pPosData->pData );
pPosData->pData = 0;
return -1;
}
}
//
// Inc current pos, buffer pos, and return a character
//
pPosData->nCurrentPos++;
pPosData->nBufferPos++;
return ( (int)pPosData->pData[pPosData->nBufferPos - 1] );
}
int
GetQueryByte(
IN OUT PPOSDATA pPosData
)
/*++
Purpose:
Returns a waiting character that is not
decoded yet. We have this function to match GetPostedData.
For the first call, pPosData->nAllocLength must be zero,
and pECB must be set.
Arguments:
pPostData - points to POSDATA structura
Returns:
byte value or -1 to indicate an error
--*/
{
// For readability only...
EXTENSION_CONTROL_BLOCK *pECB;
pECB = pPosData->pECB;
//
// Initialize position struct on first call.
//
if ( !pPosData->nAllocLength ) {
// Initialize the useful members
pPosData->nBufferPos = 0;
pPosData->nBufferLength = lstrlen( (LPCSTR) pECB->lpszQueryString );
pPosData->nAllocLength = -1;
char szMsg[256];
wsprintf(
szMsg,
"pPosData->nBufferLength=%i",
pPosData->nBufferLength
);
LOG( szMsg );
}
//
// Check for end. Deallocate and return if we're done.
//
if ( pPosData->nBufferPos == pPosData->nBufferLength ) {
return -1;
}
//
// Inc buffer pos and return a character
//
pPosData->nBufferPos++;
return ( (int)pECB->lpszQueryString[pPosData->nBufferPos - 1] );
}
//
// Now that we have GetPostedByte, and GetQueryByte, we can
// build a more useful function that decodes URL-style
// encoded characters.
//
// Recall that there are two special cases for this encoding:
//
// 1. Each plus sign must be converted to a space
// 2. A percent sign denotes a hex value-encoded character
//
// Percents are used to specify characters that are otherwise
// illegal. This includes percents themselves, ampersands,
// control characters, and so on.
//
// GetNextByte returns the decoded byte, plus a flag indicating
// normal character, decoded character, or failure. See top of
// file for return value constants.
//
int
HexDigitToInt(
IN char c
)
/*++
Purpose:
HexDigitToInt simply converts a hex-based character to an int.
Arguments:
tc - character to convert
Returns:
binary value of the character (0-15)
-1 if the character is not hex digit
--*/
{
if ( c >= '0' && c <= '9' ) {
return ( c - '0' );
}
if ( tolower( c ) >= 'a' && tolower( c ) <= 'f' ) {
return ( tolower( c ) - 'a' + 10 );
}
return -1;
}
int
GetNextByte(
IN OUT PPOSDATA pPosData,
OUT char * pc
)
/*++
Purpose:
Decode single byte of the input data
Arguments:
pPostData - points to POSDATA struct
pc - points to variable to accept decoded byte
Returns:
GNB_NORMAL_CHAR, GNB_NOTHING_LEFT or GNB_DECODED_CHAR
--*/
{
int nChar;
int nDigit;
// Initialize character pointer
*pc = 0;
// Fetch the next inbound character
nChar = pPosData->GetInboundByte( pPosData );
if ( nChar == -1 ) {
return GNB_NOTHING_LEFT;
}
// Plus signs: convert to spaces
if ( nChar == '+' ) {
*pc = ' ';
return GNB_DECODED_CHAR;
}
// Percent signs: convert hex values
else if ( nChar == '%' ) {
nChar = pPosData->GetInboundByte( pPosData );
nDigit = HexDigitToInt( nChar );
if ( nDigit == -1 ) {
return GNB_NOTHING_LEFT;
}
*pc = ( char ) ( ( UINT ) nDigit << 4 );
nChar = pPosData->GetInboundByte( pPosData );
nDigit = HexDigitToInt( nChar );
if ( nDigit == -1 ) {
*pc = 0; // incomplete
return GNB_NOTHING_LEFT;
}
*pc |= ( char ) ( UINT ) nDigit;
return GNB_DECODED_CHAR;
}
// Must be normal character then
*pc = (char) nChar;
return GNB_NORMAL_CHAR;
}
int
GetFirstByte(
IN OUT PPOSDATA pPosData,
IN EXTENSION_CONTROL_BLOCK * pECB,
OUT char * pc,
IN GETINBOUNDBYTE GetInboundByte
)
/*++
Purpose:
GetFirstByte eliminates the guesswork from initialization.
We call GetFirstByte with an uninitialized POSDATA structure,
and we call GetNextByte from there on.
Arguments:
pPosData - points to POSDATA struct to initialize
pECB - points to the extenstion control block
pc - points to variable to accept decoded byte
GetInboundByte - points to function to get incoming bytes
Returns:
same as GetNextByte()
--*/
{
// Initialize struct
pPosData->nAllocLength = 0;
pPosData->pECB = pECB;
pPosData->GetInboundByte = GetInboundByte;
// Make the call as usual
return GetNextByte( pPosData, pc );
}
//
// Structure used in data processing - the elements of the
// key list.
//
typedef struct _tagPOSTKEY {
int nInstance; // used when key name is the same as another,
// normally 0
DWORD dwOffset; // offset into content file
DWORD dwLength; // length of data
BOOL bHasCtrlChars; // a character value < 32 is in data
struct _tagPOSTKEY *pNext; // linked list
struct _tagPOSTKEY *pHead; // first in linked list
LPBYTE lpbyBuf; // pointer to the key's data in the list
// buffer
// key string appended to structure
// for the head key, list properties are appended
} POSTKEY, *PPOSTKEY;
//
// These three helper functions isolate the memory allocation,
// deallocation and abnormal exit code. They are used only to
// keep BuildKeyList readable.
//
BOOL
BKL_Alloc(
OUT LPSTR * plpszKey,
OUT LPBYTE * plpbyBuf
)
{
// Allocate a buffer for the key name
*plpszKey = (LPSTR) HeapAlloc( GetProcessHeap( ),
HEAP_ZERO_MEMORY,
MAX_KEY_NAME_LENGTH );
if ( !*plpszKey ) {
return FALSE;
}
#ifdef USE_MEMORY
// Init buffer to NULL
*plpbyBuf = NULL;
#elif defined USE_TEMPORARY_FILES
// Allocate a buffer for the content
*plpbyBuf = (LPBYTE) HeapAlloc( GetProcessHeap( ),
HEAP_ZERO_MEMORY,
CONTENT_BUF_LENGTH );
if ( !*plpbyBuf ) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) * plpszKey );
return FALSE;
}
#endif
return TRUE;
}
void
BKL_Dealloc(
IN LPSTR * plpsz,
IN LPBYTE * plpby
)
{
if ( plpsz && *plpsz ) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) * plpsz );
}
if ( plpby && *plpby ) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) * plpby );
}
}
//
// This allows us to clean up... with temporary files we have to close
// and delete them. Otherwise, we have to free a lot of memory.
//
#ifdef USE_TEMPORARY_FILES
#define MACRO_AbortCleanup BKL_Abort( pHead, hDataFile, \
lpszKeyNameBuf, lpbyContentBuf );\
if ( hDataFile != INVALID_HANDLE_VALUE ) DeleteFile( szTempPath )
#elif defined USE_MEMORY
#define MACRO_AbortCleanup BKL_Abort( pHead, INVALID_HANDLE_VALUE, \
lpszKeyNameBuf,lpbyContentBuf )
#endif
void
BKL_Abort(
IN PPOSTKEY pHead,
IN HANDLE hFile,
IN LPSTR lpszKey,
IN LPBYTE lpbyBuf
)
{
if ( pHead ) {
FreeKeyList( (HKEYLIST) pHead );
}
if ( hFile != INVALID_HANDLE_VALUE ) {
CloseHandle( hFile );
}
BKL_Dealloc( &lpszKey, &lpbyBuf );
}
BOOL
IsKeySeparator(
char c
)
/*++
Purpose:
Identify key separators
Arguments:
c - character
Returns:
TRUE if character is a key separator,
FALSE otherwise
--*/
{
return ( c == '=' || c == '\r' || c == '\n' || c == '&' || !c );
}
PPOSTKEY
BuildKeyList(
IN EXTENSION_CONTROL_BLOCK * pECB,
IN GETINBOUNDBYTE GetInboundByte
)
/*++
Purpose:
Now that we have a way to get a decoded byte from the stream,
we can parse POST data. POST data comes in as:
key=data&key=data&key=data\r\n
A linked list of keys is established, and the head node
of the list is returned. A NULL indicates no keys or
an error.
Arguments:
pECB - pointer to the extension control block
GetInboundByte - pointer to function to get input data
Returns:
Pointer to the head node or NULL
--*/
{
PPOSTKEY pHead = NULL; // head of linked list ( the return val )
PPOSTKEY pTail = NULL; // last member in linked list
PPOSTKEY pNewPostKey; // pointer for unlinked, newly allocated
// objects
PPOSTKEY pListWalk; // linked list walking pointer
PLISTPROP pProp; // pointer to list properties
LPSTR lpszKeyNameBuf; // pointer to buffer, used in obtaining key
// name
int nPos; // position within key name buffer
DWORD dwOffset; // offset from start of content buffer or
// file
DWORD dwLength; // length of key data
char c; // general-purpose character
int nReturn; // general-purpose return code
POSDATA pd; // POSDATA struct needed in GetInboundByte
int nContentPos; // position within content buffer
LPBYTE lpbyContentBuf; // pointer to buffer
BOOL bHasCtrlChars; // flag to detect ctrl chars
// Call helper to allocate a buffer
if ( !BKL_Alloc( &lpszKeyNameBuf, &lpbyContentBuf ) ) {
LOG( "BuildKeyList: Memory allocation failure" );
return NULL;
}
nContentPos = dwOffset = 0;
#ifdef USE_MEMORY
//
// Allocate enough memory for all the content.
// For the POST method, the cbTotalBytes gives us the number
// of bytes that are being sent by the browser. We can
// allocate that much but we'll really only use about 75% of it.
// For the GET method, we need to allocate the size of the
// query string plus 1.
//
lpbyContentBuf = (LPBYTE) HeapAlloc( GetProcessHeap( ),
HEAP_ZERO_MEMORY,
pECB->cbTotalBytes +
lstrlen( pECB->lpszQueryString ) + 1 );
if ( !lpbyContentBuf ) {
LOG( "BuildKeyList: Error allocating content memory" );
BKL_Dealloc( &lpszKeyNameBuf, &lpbyContentBuf );
return NULL;
}
#elif defined USE_TEMPORARY_FILES
//
// When USE_TEMPORARY_FILES is chosen, we create
// a temporary file to store all the inbound data.
// This is done to support huge amounts of inbound
// data, like file uploads.
//
char szTempDir[MAX_PATH]; // directory of temporary files
char szTempPath[MAX_PATH]; // path of content file
HANDLE hDataFile; // handle to content file
DWORD dwBytesWritten; // used with WriteFile
// Get a temp file name
GetTempPath( MAX_PATH, szTempDir );
if ( !GetTempFileName( szTempDir, "key", 0, szTempPath ) ) {
LOG( "BuildKeyList: Error creating temporary file" );
BKL_Dealloc( &lpszKeyNameBuf, &lpbyContentBuf );
return NULL;
}
// Create the content file
hDataFile = CreateFile( szTempPath,
GENERIC_READ | GENERIC_WRITE,
0, // No sharing mode
NULL, // Default security attribs
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL // No template file
);
// Return if an error occured
if ( hDataFile == INVALID_HANDLE_VALUE ) {
LOG( "BuildKeyList: Error opening temporary file" );
MACRO_AbortCleanup;
return NULL;
}
#endif
//
// 'for' statement detects the start of a valid key name.
//
// To do inside 'for' loop:
// Obtain key name
// Write data to buffer or content file
// Create POSTKEY object
// Update links
//
for ( nReturn = GetFirstByte( &pd, pECB, &c, GetInboundByte );
nReturn != GNB_NOTHING_LEFT;
nReturn = GetNextByte( &pd, &c ) ) {
// If \r or \n, ignore and continue
if ( c == '\r' || c == '\n' ) {
continue;
}
// Get a key name
nPos = 0;
while ( !IsKeySeparator( c ) ) {
if ( nPos < MAX_KEY_NAME_LENGTH ) {
lpszKeyNameBuf[nPos] = c;
nPos++;
}
nReturn = GetNextByte( &pd, &c );
if ( nReturn == GNB_NOTHING_LEFT ) { // abrupt end!
break;
}
}
// If no equals sign or name too long,
// we have a browser formatting error
if ( c != '=' || nPos == MAX_KEY_NAME_LENGTH ) {
LOG( "BuildKeyList: Browser formatting error" );
MACRO_AbortCleanup;
return NULL;
}
// Truncate the name string, reset data info variables
lpszKeyNameBuf[nPos] = 0;
nPos++;
dwLength = 0;
bHasCtrlChars = FALSE;
//
// Move the data to the content buffer or file.
//
for ( nReturn = GetNextByte( &pd, &c );
!IsKeySeparator( c ) || nReturn == GNB_DECODED_CHAR;
nReturn = GetNextByte( &pd, &c ) ) {
lpbyContentBuf[nContentPos] = c;
nContentPos += sizeof ( char );
dwLength++;
// Check for ctrl chars
if ( c < 0x20 ) {
bHasCtrlChars = TRUE;
}
#ifdef USE_TEMPORARY_FILES
// If we have enough data, write buffer to disk
if ( nContentPos == CONTENT_BUF_LENGTH ) {
if ( !WriteFile( hDataFile, lpbyContentBuf,
nContentPos, &dwBytesWritten, NULL ) ) {
LOG( "BuildKeyList: Error writing to content file" );
MACRO_AbortCleanup;
return NULL;
}
nContentPos = 0;
}
#endif
} // for( nReturn
#ifdef USE_MEMORY
//
// Put a terminating NULL at the end of the key data.
//
lpbyContentBuf[nContentPos] = 0;
nContentPos++;
#elif defined USE_TEMPORARY_FILES
// Drain buffer
if ( nContentPos ) {
if ( !WriteFile( hDataFile, lpbyContentBuf,
nContentPos, &dwBytesWritten, NULL ) ) {
LOG( "BuildKeyList: Error writing to content file" );
MACRO_AbortCleanup;
return NULL;
}
nContentPos = 0;
}
#endif
// Allocate a POSTKEY object, allocate extra for first key
if ( pHead ) {
pNewPostKey = (PPOSTKEY) HeapAlloc(
GetProcessHeap( ),
HEAP_ZERO_MEMORY,
sizeof (POSTKEY) + nPos
);
}else{
pNewPostKey = (PPOSTKEY) HeapAlloc(
GetProcessHeap( ),
HEAP_ZERO_MEMORY,
sizeof (POSTKEY) + nPos +
sizeof (LISTPROP) );
pProp = (PLISTPROP) ( (LPBYTE)pNewPostKey +
sizeof (POSTKEY) + nPos );
}
// Check for valid pointer
if ( !pNewPostKey ) {
LOG( "BuildKeyList: POSTKEY memory allocation failure" );
MACRO_AbortCleanup;
return NULL;
}
//
// Set pNewPostKey members
//
// Set nInstance
pNewPostKey->nInstance = 0;
pListWalk = pHead;
while ( pListWalk ) {
// Check for duplicate key names
if ( !lstrcmpi( (LPCSTR) ( &pListWalk[1] ), lpszKeyNameBuf )) {
pNewPostKey->nInstance++;
}
pListWalk = pListWalk->pNext;
}
// Set dwOffset, dwLength, bHasCtrlChars, lpbyBuf
pNewPostKey->dwOffset = dwOffset;
pNewPostKey->dwLength = dwLength;
pNewPostKey->bHasCtrlChars = bHasCtrlChars;
#ifdef USE_MEMORY
pNewPostKey->lpbyBuf = &lpbyContentBuf[dwOffset];
dwOffset += dwLength + 1;
#elif defined USE_TEMPORARY_FILES
pNewPostKey->lpbyBuf = NULL;
dwOffset += dwLength;
#endif
// Copy key name
lstrcpy( (LPSTR) ( &pNewPostKey[1] ), lpszKeyNameBuf );
// Link
if ( pTail ) {
pTail->pNext = pNewPostKey;
}else{
#ifdef USE_TEMPORARY_FILES
// Copy content file name to list properties
lstrcpy( pProp->szTempFileName, szTempPath );
// Set handle
pProp->hFile = hDataFile;
#elif defined USE_MEMORY
// Set content buffer pointer
pProp->lpbyBuf = lpbyContentBuf;
#endif
// Set head
pHead = pNewPostKey;
}
pNewPostKey->pNext = NULL;
pTail = pNewPostKey;
pNewPostKey->pHead = pHead; // may point to itself
} // for ( nReturn
#ifdef USE_TEMPORARY_FILES
//
// If content file is empty, close it and delete it
//
if ( !pHead ) {
LOG( "Empty content file is being deleted." );
CloseHandle( hDataFile );
DeleteFile( szTempPath );
}
// Free work buffer
BKL_Dealloc( &lpszKeyNameBuf, &lpbyContentBuf );
#elif defined USE_MEMORY
// Free work buffer
BKL_Dealloc( &lpszKeyNameBuf, pHead ? NULL : &lpbyContentBuf );
#endif
return pHead;
}
//
// We are now pretty much done with anything complex. BuildKeyList
// will do all our parse work, so now we need a few wrappers to
// make a nice, clean external interface.
//
// GetPostKeys calls BuildKeyList with GetPostedByte.
//
// GetUrlKeys calls BuildKeyList with GetQueryByte.
//
PPOSTKEY
GetPostKeys(
IN EXTENSION_CONTROL_BLOCK * pECB
)
{
return BuildKeyList( pECB, GetPostedByte );
}
PPOSTKEY
GetUrlKeys(
IN EXTENSION_CONTROL_BLOCK * pECB
)
{
return BuildKeyList( pECB, GetQueryByte );
}
PLISTPROP
GetPropAddr(
IN HKEYLIST hKey
)
/*++
Purpose:
GetPropAddr returns the address of the end of
the first key. We stuff list properties there.
This implementation of keys.cpp keeps a pointer
to the content buffer. The second version ( used
in IS2WCGI ) appends a temporary file name
to the first key.
Arguments:
hKey - pointer to a key list
Returns:
The address of the end of the first key
--*/
{
LPCSTR lpszKeyName;
PPOSTKEY pHead;
// Safety
if ( !hKey ) {
return NULL;
}
// ContentPath follows POSTKEY struct and key name
pHead = (PPOSTKEY) hKey;
pHead = pHead->pHead;
lpszKeyName = (LPCSTR) ( &pHead[1] );
return (PLISTPROP) ( lpszKeyName + lstrlen( lpszKeyName ) + 1 );
}
HKEYLIST
GetKeyList(
IN EXTENSION_CONTROL_BLOCK * pECB
)
/*++
Purpose:
Examines the method and calls GetPostKeys or GetUrlKeys,
whichever is relevant.
Arguments:
pECB - points to the extension control block
Returns:
GetPropAddr returns the address of the end of
the first key. We stuff list properties there.
This implementation of keys.cpp keeps a pointer
to the content buffer. The second version ( used
in IS2WCGI ) appends a temporary file name
to the first key.
--*/
{
if ( !lstrcmpi( pECB->lpszMethod, "POST" ) ) {
LOG( "Method=POST" );
return (HKEYLIST) GetPostKeys( pECB );
}else if ( !lstrcmpi( pECB->lpszMethod, "GET" ) ) {
LOG( "Method=GET" );
return (HKEYLIST) GetUrlKeys( pECB );
}
LOG( "Unknown method" );
return NULL;
}
HKEYLIST
GetKeyInfo(
IN HKEYLIST hKey,
OUT LPCSTR * plpszKeyName,
OUT LPDWORD pdwLength,
OUT BOOL * pbHasCtrlChars,
OUT LPINT pnInstance
)
//
// GetKeyInfo is a wrapper for the POSTKEY linked list.
// It returns the members of the supplied POSTKEY object.
//
{
PPOSTKEY pPostKey;
// Safety
if ( !hKey ) {
return NULL;
}
pPostKey = (PPOSTKEY) hKey;
// Set the data members
if ( plpszKeyName )
*plpszKeyName = ( LPCSTR ) ( &pPostKey[1] );
if ( pdwLength )
*pdwLength = pPostKey->dwLength;
if ( pbHasCtrlChars )
*pbHasCtrlChars = pPostKey->bHasCtrlChars;
if ( pnInstance )
*pnInstance = pPostKey->nInstance;
// Return a handle to the next object in the list
return ( ( HKEYLIST ) pPostKey->pNext );
}
#ifdef USE_MEMORY
LPBYTE
GetKeyBuffer(
IN HKEYLIST hKey
)
{
//
// We have two versions of this function because
// we may want to use file i/o when the extension
// deals with massive amounts of inbound data
// ( like multi-megabyte uploads ).
//
//
// This version uses a memory buffer.
//
PPOSTKEY pKey;
// Safety
if ( !hKey ) {
return NULL;
}
pKey = (PPOSTKEY) hKey;
return (LPBYTE) pKey->lpbyBuf;
}
#elif defined USE_TEMPORARY_FILES
LPBYTE
GetKeyBuffer(
IN HKEYLIST hKey
)
{
//
// This version uses slow temporary files.
//
PLISTPROP pProp;
PPOSTKEY pKey;
DWORD dwRead;
// Get pointer to list properties
pProp = GetPropAddr( hKey );
// Safety
if ( !pProp ) {
return NULL;
}
pKey = (PPOSTKEY) hKey;
// Check if memory was already loaded for this key
if ( pKey->lpbyBuf ) {
return pKey->lpbyBuf;
}
// If not, let's allocate memory and do a ReadFile
pKey->lpbyBuf = (LPBYTE) HeapAlloc( GetProcessHeap( ),
HEAP_ZERO_MEMORY,
pKey->dwLength + 1 );
if ( !pKey->lpbyBuf ) {
LOG( "GetKeyBuffer: HeapAlloc failed" );
return NULL;
}
// Do the ReadFile
SetFilePointer( pProp->hFile, pKey->dwOffset, NULL, FILE_BEGIN );
if ( !ReadFile( pProp->hFile, pKey->lpbyBuf,
pKey->dwLength, &dwRead, NULL ) ||
dwRead != pKey->dwLength ) {
HeapFree( GetProcessHeap( ), 0, (LPVOID) pKey->lpbyBuf );
pKey->lpbyBuf = NULL;
LOG( "GetKeyBuffer: ReadFile failed" );
return NULL;
}
return pKey->lpbyBuf;
}
#endif
HKEYLIST
FindKey(
IN HKEYLIST hKeyList,
IN LPCSTR lpszSearchName
)
/*++
Purpose:
FindKey sequentially searches the linked list for a given key.
Arguments:
hKeyList - points to key list
lpszSearchName - points to a key name to find
Returns:
The return handle points to the element within the linked list.
Use it in GetKeyInfo, but not FreeKeyList.
--*/
{
PPOSTKEY pFindKey;
pFindKey = (PPOSTKEY) hKeyList;
while ( pFindKey ) {
if ( !lstrcmpi( lpszSearchName, ( LPCSTR ) ( &pFindKey[1] ) ) ) {
return ( ( HKEYLIST ) pFindKey );
}
pFindKey = pFindKey->pNext;
}
return NULL;
}
void
FreeKeyList(
IN HKEYLIST hHeadKey
)
/*++
Purpose:
FreeKeyList deallocates all the objects in the key list.
The content file is also deleted.
Arguments:
hHeadKey - points to the list head
--*/
{
PPOSTKEY pObject;
PPOSTKEY pDel;
PLISTPROP pProp;
// Safety
if ( !hHeadKey ) {
return;
}
#ifdef USE_TEMPORARY_FILES
// Close the content file
CloseContentFile( hHeadKey );
// delete the content file
pProp = GetPropAddr( hHeadKey );
DeleteFile( pProp->szTempFileName );
#elif defined USE_MEMORY
// delete content
pProp = GetPropAddr( hHeadKey );
HeapFree( GetProcessHeap( ), 0, (LPVOID) pProp->lpbyBuf );
#endif
// delete all objects in the list
pObject = (PPOSTKEY) hHeadKey;
pObject = pObject->pHead;
while ( pObject ) {
#ifdef USE_TEMPORARY_FILES
//
// Free each buffer when using temporary files
//
if ( pObject->lpbyBuf )
HeapFree( GetProcessHeap( ), 0, (LPVOID) pObject->lpbyBuf );
#endif
pDel = pObject;
pObject = pObject->pNext;
HeapFree( GetProcessHeap( ), 0, (LPVOID) pDel );
}
}
DWORD
GetKeyOffset(
IN HKEYLIST hKey
)
/*++
Purpose:
GetKeyOffset returns the offset of a key into the internal
buffer or temporary file. This is provided for IS2WCGI
so it can return an offset within the content file.
Arguments:
hKey - points to a key
Returns:
Offset of a key or NULL if no key provided
--*/
{
// Safety
if ( !hKey )
return NULL;
return ( (PPOSTKEY) hKey )->dwOffset;
}
#ifdef USE_TEMPORARY_FILES
LPCSTR
GetContentFile(
IN HKEYLIST hKeyList
)
/*++
Purpose:
GetContentFile returns a pointer to the name of the
temporary file. This is provided for the IS2WCGI
sample.
Arguments:
Returns:
--*/
{
PLISTPROP pProp;
// safety
if ( !hKeyList )
return NULL;
pProp = GetPropAddr( hKeyList );
return ( LPCSTR ) pProp->szTempFileName;
}
void
CloseContentFile(
IN HKEYLIST hKey
)
/*++
Purpose:
CloseContentFile forces the content file to be closed. This
allows you to pass the file to something else that may open
it. Call OpenContentFile before calling any other key
function.
Arguments:
--*/
{
PLISTPROP pProp;
if ( !hKey )
return;
pProp = GetPropAddr( hKey );
if ( pProp->hFile != INVALID_HANDLE_VALUE ) {
CloseHandle( pProp->hFile );
pProp->hFile = INVALID_HANDLE_VALUE;
}
}
void
OpenContentFile(
IN HKEYLIST hKey
)
/*++
Purpose:
OpenContentFile forces the content file to be reopened.
GetKeyBuffer will fail if the content file was closed by
CloseContentFile, but not reopened.
Arguments:
Returns:
--*/
{
PLISTPROP pProp;
if ( !hKey )
return;
pProp = GetPropAddr( hKey );
if ( pProp->hFile != INVALID_HANDLE_VALUE )
return;
// Create the content file
pProp->hFile = CreateFile( pProp->szTempFileName,
GENERIC_READ | GENERIC_WRITE,
0, // No sharing mode
NULL, // Default security attribs
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
}
#elif defined USE_MEMORY
LPBYTE
GetDataBuffer(
IN HKEYLIST hKeyList
)
/*++
Purpose:
GetBufferPointer returns a pointer to the buffer used
for content storage.
Arguments:
hKeyList - points to a key list
Returns:
pointer to the content buffer or NULL
--*/
{
PLISTPROP pProp;
// safety
if ( !hKeyList )
return NULL;
pProp = GetPropAddr( hKeyList );
return pProp->lpbyBuf;
}
#endif