CTETEST.C
/*++
Copyright (c) 1997 Microsoft Corporation
Module Name: ctetest.c
Abstract:
ISAPI Extension sample illustrating Chunked Transfer Encoding.
--*/
#include "ctetest.h"
//
// if chunksize= is not specified, use this value
//
#define DEFAULT_CHUNK_SIZE 1024
//
// auxiliary functions prototypes
//
static BOOL SendChunkedFile( EXTENSION_CONTROL_BLOCK *, DWORD, LPCSTR );
static BOOL SendHttpHeaders( EXTENSION_CONTROL_BLOCK *, LPCSTR, LPCSTR, BOOL );
static BOOL GetFileMimeType( LPCSTR, LPSTR, DWORD );
static BOOL GetQueryStringField( LPCSTR, LPCSTR, LPSTR, DWORD );
static void DisplayExampleUsage( EXTENSION_CONTROL_BLOCK * );
DWORD WINAPI
HttpExtensionProc(
IN EXTENSION_CONTROL_BLOCK *pECB
)
/*++
Purpose:
Illustrate chunk transfer encoding in ISAPI HTTP Extension DLL.
Process "GET" requests that specify a filename and transfer
chunk size.
Arguments:
pECB - pointer to the extenstion control block
Returns:
HSE_STATUS_SUCCESS on successful transmission completion
HSE_STATUS_ERROR on failure
--*/
{
DWORD dwChunksize = 0;
char szPath[MAX_PATH];
char szHeaders[1024];
DWORD cchPath, cchHeaders;
char szChunkSize[32];
//
// if request method is not "GET", bail out
//
if( _stricmp( pECB->lpszMethod, "GET" ) != 0 ) {
return HSE_STATUS_ERROR;
}
//
// process chunksize= query argument, if any
//
if( GetQueryStringField( pECB->lpszQueryString, "chunksize",
szChunkSize, sizeof szChunkSize )) {
dwChunksize = atoi( szChunkSize );
}
if( dwChunksize == 0 ) {
dwChunksize = DEFAULT_CHUNK_SIZE;
}
//
// process file= query argument
//
cchPath = sizeof szPath;
if( !GetQueryStringField(
pECB->lpszQueryString,
"file",
szPath,
cchPath )) {
//
// no file specified - display usage and report success
//
DisplayExampleUsage( pECB );
return HSE_STATUS_SUCCESS;
}
//
// use ServerSupportFunction to map virtual file name to local
// path (otherwise users get access to any file on the system)
//
if( !pECB->ServerSupportFunction(
pECB->ConnID,
HSE_REQ_MAP_URL_TO_PATH,
szPath,
&cchPath,
NULL ) ) {
return HSE_STATUS_ERROR;
}
//
// see if we can get file attributes, report error if not
//
if( GetFileAttributes( szPath ) == 0xFFFFFFFF ) {
return HSE_STATUS_ERROR;
}
//
// begin preparing the headers
//
strcpy( szHeaders, "Transfer-encoding: chunked\r\nContent-type: " );
//
// obtain MIME type for this file and append it to the headers
//
cchHeaders = strlen( szHeaders );
GetFileMimeType(
szPath,
szHeaders + cchHeaders,
sizeof szHeaders - cchHeaders
);
//
// terminate headers with empty line
//
strcat( szHeaders, "\r\n\r\n" );
//
// try sending headers to the client
//
if( !SendHttpHeaders( pECB, "200 OK", szHeaders, TRUE ) ) {
return HSE_STATUS_ERROR;
}
//
// try sending the file using CTE encoding
//
if( !SendChunkedFile( pECB, dwChunksize, szPath ) ) {
return HSE_STATUS_ERROR;
}
return HSE_STATUS_SUCCESS;
}
BOOL WINAPI
GetExtensionVersion(
OUT HSE_VERSION_INFO *pVer
)
/*++
Purpose:
This is required ISAPI Extension DLL entry point.
Arguments:
pVer - poins to extension version info structure
Returns:
always returns TRUE
--*/
{
//
// tell the server our version number and extension description
//
pVer->dwExtensionVersion =
MAKELONG( HSE_VERSION_MINOR, HSE_VERSION_MAJOR );
lstrcpyn(
pVer->lpszExtensionDesc,
"ISAPI CTE test",
HSE_MAX_EXT_DLL_NAME_LEN);
return TRUE;
}
BOOL WINAPI
TerminateExtension(
DWORD dwFlags
)
/*++
Purpose:
This is optional ISAPI extension DLL entry point.
If present, it will be called before unloading the DLL,
giving it a chance to perform any shutdown procedures.
Arguments:
dwFlags - specifies whether the DLL can refuse to unload or not
Returns:
TRUE, if the DLL can be unloaded
--*/
{
return TRUE;
}
BOOL WINAPI
DllMain (
IN HINSTANCE hInstance,
IN DWORD fdwReason,
IN LPVOID lpvReserved
)
/*++
Purpose:
Perform any required DLL initialization here.
Returns:
TRUE if DLL was successfully initialized
FALSE otherwise
--*/
{
//
// Nothing needs to be done. This function exists a template.
//
return TRUE;
}
static BOOL
SendChunkedFile(
EXTENSION_CONTROL_BLOCK *pECB,
DWORD dwChunkSize,
LPCSTR pszPath
)
/*++
Purpose:
Transfer the specified file using chunked encoding.
Illustrates the usage of CteBeginWrite(), CteWrite() and
CteEndWrite() functions.
Arguments:
pECB - pointer to extenstion control block
dwChunkSize - chunk size for transfer encoding
pszPath - local file path
Returns:
TRUE if the file was successfully transfered,
FALSE otherwise
--*/
{
HANDLE hFile;
HCTE_ENCODER hCteWrite;
BOOL fSuccess = FALSE;
//
// try accessing file
//
hFile = CreateFile(
pszPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_FLAG_SEQUENTIAL_SCAN,
NULL);
if( hFile != INVALID_HANDLE_VALUE ) {
BYTE buf[4096];
DWORD cbread;
//
// prepare chunk transfer encoder
//
hCteWrite = CteBeginWrite( pECB, dwChunkSize );
if ( hCteWrite ) {
for( ;; ) {
if( !ReadFile( hFile, buf, sizeof buf, &cbread, NULL ) ) {
//
// if ReadFile fails, break out of loop and cause
// the function to return FALSE (failure)
//
break;
}
if( cbread == 0 ) {
//
// ReadFile succeded, but read 0 bytes -
// we've achieved EOF and everything is transmitted.
// break out and return success!
//
fSuccess = TRUE;
break;
}
//
// transmit one buffer full of data,
//
if( !CteWrite( hCteWrite, buf, cbread ) ) {
//
// CteWrite failed - break out and return FALSE
//
break;
}
}
//
// finish transfer and release encoder context
//
if( !CteEndWrite( hCteWrite ) ) {
fSuccess = FALSE;
}
}
CloseHandle( hFile );
}
return fSuccess;
}
static BOOL
SendHttpHeaders(
EXTENSION_CONTROL_BLOCK *pECB,
LPCSTR pszStatus,
LPCSTR pszHeaders,
BOOL fKeepConn
)
/*++
Purpose:
Send specified HTTP status string and any additional header strings
using new ServerSupportFunction() request HSE_SEND_HEADER_EX_INFO
Arguments:
pECB - pointer to the extension control block
pszStatus - HTTP status string (e.g. "200 OK")
pszHeaders - any additional headers, separated by CRLFs and
terminated by empty line
fKeepConn - specifies whether to keep TCP connection open or close it
after request is processed.
Returns:
TRUE if headers were successfully sent
FALSE otherwise
--*/
{
HSE_SEND_HEADER_EX_INFO header_ex_info;
BOOL success;
header_ex_info.pszStatus = pszStatus;
header_ex_info.pszHeader = pszHeaders;
header_ex_info.cchStatus = strlen( pszStatus );
header_ex_info.cchHeader = strlen( pszHeaders );
header_ex_info.fKeepConn = fKeepConn;
success = pECB->ServerSupportFunction(
pECB->ConnID,
HSE_REQ_SEND_RESPONSE_HEADER_EX,
&header_ex_info,
NULL,
NULL
);
return success;
}
static BOOL
GetFileMimeType(
LPCSTR pszPath,
LPSTR pszType,
DWORD cbMax
)
/*++
Purpose:
Given the file name, obtain MIME type for "Content-type:" header field.
We try to find MIME type string under HCR\.xyz key, "Content Type" value.
If that fails, we return default "application/ocetet-stream".
Arguments:
pszPath - file path
pszType - points to the buffer that will receive MIME type string
cbMax - specifies the maximum number of characters to copy to the buffer,
including the NUL character. If the text exceed this limit, it
will be truncated.
Returns:
TRUE, because we can always use default MIME type.
--*/
{
LPSTR pszExt;
HKEY hKey;
DWORD value_type;
LONG result;
//
// set MIME type to empty string
//
*pszType = '\0';
//
// try to locate file extension
//
pszExt = strrchr( pszPath, '.' );
if( pszExt != NULL ) {
//
// for file extension .xyz, MIME Type can be found
// HKEY_CLASSES_ROOT\.xyz key in the registry
//
result = RegOpenKeyEx(
HKEY_CLASSES_ROOT,
pszExt,
0L,
KEY_READ,
&hKey
);
if( result == ERROR_SUCCESS) {
//
// we sucessfully opened the key.
// try getting the "Content Type" value
//
result = RegQueryValueEx(
hKey,
"Content Type",
NULL,
&value_type,
(BYTE *)pszType,
&cbMax );
//
// if we failed to get the value or it is not string,
// clear content-type field
//
if( result != ERROR_SUCCESS || value_type != REG_SZ ) {
*pszType = '\0';
}
RegCloseKey( hKey );
}
}
//
// if at this point we don't have MIME type, use default
//
if( *pszType == '\0' ) {
strncpy( pszType, "application/octet_stream", cbMax );
}
return TRUE;
}
static void
DisplayExampleUsage(
EXTENSION_CONTROL_BLOCK *pECB
)
/*++
Purpose:
Send short plaintext description of our usage to the user.
Arguments:
pECB - pointer to the extension control block
--*/
{
DWORD dwLength;
static char szUsage[] =
"Example usage:\r\n"
"http://localhost/scripts/ctetest.dll"
"?file=/default.htm+chunksize=512\r\n";
char szHeaders[1024];
//
// send simple headers and sample usage instruction
//
dwLength = sizeof szUsage - 1;
sprintf(
szHeaders,
"Content-Length: %u\r\n"
"Content-Type: text/plain\r\n\r\n",
dwLength
);
if( SendHttpHeaders( pECB, "200 OK", szHeaders, FALSE ) ) {
pECB->WriteClient(
pECB->ConnID,
szUsage,
&dwLength,
HSE_IO_SYNC
);
}
}
BOOL
GetQueryStringField(
LPCSTR pszQueryString,
LPCSTR pszKey,
LPSTR buf,
DWORD cbuf
)
/*++
Purpose:
Assuming "key1=value1+key2=value2" syntax,
extract the value for specified key.
Arguments:
pszQueryString - query string provided by ECB
pszKey - key name
buf - buffer for parameter value
cbuf - buffer size
Returns:
TRUE if the value was successfully extracted
FALSE otherwise
--*/
{
int len, keylen;
LPCSTR p = pszQueryString;
//
// compute key and query lengths, bail out if either is missing
//
keylen = strlen( pszKey );
len = strlen( p );
if( keylen == 0 || len == 0 ) return FALSE;
//
// process one "+" delimited section at a time
//
for( ;; ) {
//
// skip any leading blanks, bail out if end of line found
//
while( *p <= ' ' ) {
if( *p == '\0' ) {
return FALSE;
}
p++;
len--;
}
//
// if the key won't fit into the rest of the command line, bail out
//
if( keylen + 1 > len ) {
return FALSE;
}
//
// is this the key we are looking for?
//
if( _memicmp( p, pszKey, keylen ) == 0 && p[keylen] == '=' ) {
//
// found it - skip '=' and break out of the loop
//
p += keylen + 1;
break;
}
//
// no match, try advancing to next '+' section
//
while( *p != '+' ) {
if( *p == '\0' ) {
return FALSE;
}
p++;
len--;
}
//
// found '+', skip it
//
p++;
len--;
}
//
// copy the value up to: the end of line, cbuf chars, or
// '+' separator, whichever comes first
//
while( *p && *p != '+' ) {
if( cbuf <= 1 ) {
break;
}
*(buf++) = *(p++);
cbuf--;
}
//
// zero-terminate the value, report success
//
*buf = '\0';
return TRUE;
}