1390 lines
42 KiB
C++
1390 lines
42 KiB
C++
//
|
|
// Microsoft Corporation - Copyright 1997
|
|
//
|
|
|
|
//
|
|
// MULTPARS.CPP - Parses incoming stream for files
|
|
//
|
|
|
|
#include "pch.h"
|
|
|
|
// Local globals
|
|
const char g_cszBoundaryKeyword[] = "boundary="; // don't include space
|
|
const DWORD g_cbBoundaryKeyword = sizeof( g_cszBoundaryKeyword ) - 1;
|
|
const char g_cszCheck[] = "check="; // don't include space
|
|
const DWORD g_cbCheck = sizeof( g_cszCheck ) - 1;
|
|
const char g_cszBoundaryIndicator[] = "\r\n--";
|
|
const DWORD g_cbBoundaryIndicator = sizeof( g_cszBoundaryIndicator ) - 1;
|
|
|
|
const char g_cszExtraBytes[] = "Extra bytes";
|
|
const char g_cszBodyData[] = "Body Data";
|
|
|
|
//
|
|
// Parsing table
|
|
//
|
|
PARSETABLE g_LexTable[ ] = {
|
|
// Parser search string, Lexicon ,Length, Color , Comment
|
|
{ (LPSTR)g_cszBoundaryIndicator, LEX_BOUNDARY , 0, 0xFFFFFF, "Boundary String" },
|
|
{ (LPSTR)g_cszBoundaryIndicator, LEX_EOT , 0, 0xFFFFFF, "Ending Boundary" },
|
|
{ (LPSTR)g_cszBoundaryIndicator +2, LEX_STARTBOUNDARY, 0, 0xFFFFFF, "Starting Boundary" },
|
|
// must be after LEX_BOUNDARY
|
|
{ "\r\n", LEX_CRLF , 0, 0x7F7F7F, NULL },
|
|
{ "content-disposition:", LEX_CONTENTDISP , 0, 0x0000FF, "Header Field" },
|
|
{ "content-type:", LEX_CONTENTTYPE , 0, 0x0000FF, "Header Field" },
|
|
{ "name=", LEX_NAMEFIELD , 0, 0x0000FF, "Field Param" },
|
|
{ "filename=", LEX_FILENAMEFIELD , 0, 0x0000FF, "Field Param" },
|
|
// MIME types
|
|
{ "multipart", LEX_MULTIPART , 0, 0x003FFF, "MIME Type" },
|
|
{ "text", LEX_TEXT , 0, 0x003FFF, "MIME Type" },
|
|
{ "application", LEX_APPLICATION , 0, 0x003FFF, "MIME Type" },
|
|
{ "audio", LEX_AUDIO , 0, 0x003FFF, "MIME Type" },
|
|
{ "image", LEX_IMAGE , 0, 0x003FFF, "MIME Type" },
|
|
{ "message", LEX_MESSAGE , 0, 0x003FFF, "MIME Type" },
|
|
{ "video", LEX_VIDEO , 0, 0x003FFF, "MIME Type" },
|
|
{ "x-", LEX_MIMEEXTENSION , 0, 0x003FFF, "MIME Extension" },
|
|
{ "iana-", LEX_MIMEEXTENSION , 0, 0x003FFF, "MIME Extension" },
|
|
// MIME subtypes
|
|
{ "form-data", LEX_FORMDATA , 0, 0x003FFF, "MIME Subtype" },
|
|
{ "attachment", LEX_ATTACHMENT , 0, 0x003FFF, "MIME Subtype" },
|
|
{ "mixed", LEX_MIXED , 0, 0x003FFF, "MIME Subtype" },
|
|
{ "plain", LEX_PLAIN , 0, 0x003FFF, "MIME Subtype" },
|
|
{ "x-msdownload", LEX_XMSDOWNLOAD , 0, 0x003FFF, "MIME Subtype" },
|
|
{ "octet-stream", LEX_OCTETSTREAM , 0, 0x003FFF, "MIME Subtype" },
|
|
{ "binary", LEX_BINARY , 0, 0x003FFF, "MIME Subtype" },
|
|
// special chacacters
|
|
{ " ", LEX_SPACE , 0, 0x7F7F7F, NULL },
|
|
// tabs are treated as spaces
|
|
{ "\t", LEX_SPACE , 0, 0x7F7F7F, NULL },
|
|
{ "/", LEX_SLASH , 0, 0x003FFF, NULL },
|
|
{ "\"", LEX_QUOTE , 0, 0x000000, NULL },
|
|
{ ";", LEX_SEMICOLON , 0, 0x7F7F7F, NULL },
|
|
{ "(", LEX_BEGIN_COMMENT , 0, 0x7F7F7F, "Comment" },
|
|
{ ")", LEX_END_COMMENT , 0, 0x7F7F7F, NULL },
|
|
// end of table
|
|
{ NULL, LEX_UNKNOWN , 0, 0x7F7F7F, NULL }
|
|
// NOTE: Length should always be zero. We will calculate this the first
|
|
// time we encounter the string as save it here to be used on
|
|
// future passes.
|
|
};
|
|
|
|
//
|
|
// Constructor / Destructor
|
|
//
|
|
CMultipartParse::CMultipartParse(
|
|
LPECB lpEcb,
|
|
LPSTR *lppszOut,
|
|
LPSTR *lpszDebug,
|
|
LPDUMPTABLE lpDT )
|
|
:CBase( lpEcb, lppszOut, lpszDebug, lpDT )
|
|
{
|
|
DebugMsg( lpszOut, g_cszTableHeader, "\
|
|
(NOTE: To turn on detailed debugging information, add '?debug' to the end of action URL in the orginating HTML file.)\
|
|
<br>\
|
|
<H2>Multipart Form Data (METHOD=POST, ENCTYPE=MULTIPART/FORM-DATA)</H2>\
|
|
",
|
|
"TBLMULTIFORM" );
|
|
|
|
_cbDT = 0; // empty DUMPTABLE
|
|
|
|
} // CMultipartParse( )
|
|
|
|
CMultipartParse::~CMultipartParse( )
|
|
{
|
|
if ( _lpszBoundary )
|
|
{
|
|
GlobalFree( _lpszBoundary );
|
|
}
|
|
|
|
} // ~CMultipartParse( )
|
|
|
|
//
|
|
// METHODS
|
|
//
|
|
|
|
//
|
|
// What: PreParse
|
|
//
|
|
// Desc: Parses incoming form from the root header. It is assumed that by
|
|
// this point that we are parsing a MUTLIPART / FORM-DATA POST.
|
|
//
|
|
BOOL CMultipartParse::PreParse( LPBYTE lpbData, LPDWORD lpdwParsed )
|
|
{
|
|
BOOL fReturn;
|
|
LPSTR lpszHeader;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "PreParse( )" );
|
|
|
|
_lpbLastParse = _lpbParse = _lpbData = lpbData;
|
|
|
|
// Grab content_type from server header
|
|
fReturn = GetServerVarString( lpEcb, "CONTENT_TYPE", &lpszHeader, NULL );
|
|
if ( !fReturn )
|
|
goto Cleanup;
|
|
|
|
// Create the boundary string that we will be searching for
|
|
fReturn = GetBoundaryString( (LPBYTE) lpszHeader );
|
|
GlobalFree( lpszHeader );
|
|
if ( !fReturn )
|
|
goto Cleanup;
|
|
|
|
// Parse body headers
|
|
fReturn = ParseBody( );
|
|
|
|
Cleanup:
|
|
// End table output
|
|
StrCat( lpszOut, g_cszTableEnd );
|
|
|
|
// End the DUMPTABLE
|
|
lpDT[ _cbDT ].lpAddr = NULL; // indicates EOTable
|
|
|
|
*lpdwParsed = ( _lpbParse - _lpbData );
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "PreParse( ) Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
} // PreParse( )
|
|
|
|
//
|
|
// What: ParseBody
|
|
//
|
|
// Desc: Body header parsing state entered. We start by finding the
|
|
// next boundary string which indicates the beginning of a
|
|
// body header.
|
|
//
|
|
BOOL CMultipartParse::ParseBody( )
|
|
{
|
|
BOOL fReturn = TRUE; // assume success;
|
|
DWORD eLex;
|
|
BOOL fStartBoundaryOk = TRUE;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "ParseBody( )" );
|
|
|
|
// Bypass possible crap
|
|
eLex = Lex( );
|
|
while (( eLex != LEX_BOUNDARY ) && ( eLex !=LEX_EOT ) && ( eLex != LEX_STARTBOUNDARY ))
|
|
eLex = Lex( );
|
|
|
|
while (( fReturn) && ((DWORD) ( _lpbParse - _lpbData ) != lpEcb->cbTotalBytes ))
|
|
{
|
|
switch ( eLex )
|
|
{
|
|
case LEX_STARTBOUNDARY:
|
|
if ( !fStartBoundaryOk )
|
|
{
|
|
DebugMsg( lpszDebug, "Found a mulformed boundary string. Missing preceeding CRLF at %u (0x%x) bytes.\n",
|
|
( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
fReturn = FALSE;
|
|
break;
|
|
}
|
|
// fall thru
|
|
case LEX_BOUNDARY:
|
|
DebugMsg( lpszDebug, "Found boundary. Content starts at %u (0x%x) bytes.\n",
|
|
( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
fReturn = BodyHeader( );
|
|
break;
|
|
|
|
case LEX_EOT:
|
|
{
|
|
DWORD cbParsed = _lpbParse - _lpbData;
|
|
fReturn = ( cbParsed == lpEcb->cbTotalBytes );
|
|
DebugMsg( lpszDebug, "EOT found.\n" );
|
|
DebugMsg( lpszDebug, "TotalBytesReceived == BytesParsed? %s \n",
|
|
BOOLTOSTRING( fReturn ) );
|
|
if ( !fReturn )
|
|
{
|
|
DebugMsg( lpszDebug, "Header 'Content-length': %u bytes. Parsed: %u bytes\n",
|
|
lpEcb->cbTotalBytes, ( _lpbParse - _lpbData ) );
|
|
DebugMsg( lpszDebug, "( Note: If bytes parsed greater than 'content-length', it \
|
|
is possible that the server read the entire packet in its first pass and \
|
|
that the actual packet size is larger than indicated by the content-length \
|
|
header field entry. )\n");
|
|
}
|
|
}
|
|
goto Cleanup;
|
|
|
|
default:
|
|
DebugMsg( lpszDebug, "Did not find a boundary string after %u (0x%x) bytes.\n",
|
|
_lpbParse - _lpbData, _lpbParse - _lpbData );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
fStartBoundaryOk = FALSE;
|
|
eLex = Lex( );
|
|
|
|
} // while ( _lpbParse - _lpbData )
|
|
|
|
DebugMsg( lpszDebug, "Parsed %u (0x%x) bytes.\n", ( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
|
|
Cleanup:
|
|
TraceMsg( TF_FUNC | TF_PARSE, "ParseBody( ) Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
} // ParseBody( )
|
|
|
|
//
|
|
// What: BodyHeader
|
|
//
|
|
// Desc: State has entered the bodyheader.
|
|
//
|
|
// Return: TRUE unless a unrecognized token is found.
|
|
//
|
|
BOOL CMultipartParse::BodyHeader( )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
BODYHEADERINFO sBHI;
|
|
LEXICON eLex;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "BodyHeader()" );
|
|
|
|
// defaults
|
|
sBHI.eContentDisposition = LEX_FORMDATA;
|
|
sBHI.lpszNameField = NULL;
|
|
sBHI.lpszFilenameField = NULL;
|
|
sBHI.lpszBodyContents = NULL;
|
|
sBHI.dwContentType = LEX_TEXT;
|
|
sBHI.dwContentSubtype = LEX_PLAIN;
|
|
|
|
while ( fReturn )
|
|
{
|
|
eLex = Lex( );
|
|
switch ( eLex )
|
|
{
|
|
// expected
|
|
case LEX_CONTENTDISP:
|
|
fReturn = ContentDisposition( &sBHI );
|
|
break;
|
|
|
|
case LEX_CONTENTTYPE:
|
|
fReturn = ContentType( &sBHI );
|
|
break;
|
|
|
|
case LEX_CRLF: // indicate end of header
|
|
goto EndofHeader;
|
|
|
|
// ignored
|
|
case LEX_SPACE:
|
|
break;
|
|
case LEX_BEGIN_COMMENT:
|
|
fReturn = HandleComments( );
|
|
break; // ingored
|
|
|
|
default:
|
|
DebugMsg( lpszDebug, "Unexpected '%s' found at %u (0x%x) bytes.\n",
|
|
FindTokenName( eLex ), ( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
fReturn = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
EndofHeader:
|
|
// now retrieve the content...
|
|
if ( fReturn )
|
|
{
|
|
fReturn = BodyContent( &sBHI );
|
|
}
|
|
|
|
// add results to output table
|
|
if ( sBHI.lpszNameField )
|
|
{
|
|
DebugMsg( lpszOut, "<TR ID=TR%s><TD ID=TD%s>%s</TD><TD ID=%s>",
|
|
sBHI.lpszNameField, sBHI.lpszNameField,
|
|
sBHI.lpszNameField, sBHI.lpszNameField );
|
|
}
|
|
else
|
|
{
|
|
DebugMsg( lpszOut, "<TR><TD> 'not given' </TD><TD>" );
|
|
}
|
|
|
|
if ( sBHI.lpszFilenameField )
|
|
{
|
|
DebugMsg( lpszOut, "%s", sBHI.lpszFilenameField );
|
|
}
|
|
else if ( sBHI.lpszBodyContents )
|
|
{
|
|
DebugMsg( lpszOut, "%s", sBHI.lpszBodyContents );
|
|
}
|
|
else
|
|
{
|
|
DebugMsg( lpszOut, "'unknown'" );
|
|
}
|
|
|
|
DebugMsg( lpszOut, "</TD></TR>" );
|
|
|
|
// Free alloced memory
|
|
if ( sBHI.lpszFilenameField )
|
|
{
|
|
GlobalFree( sBHI.lpszFilenameField );
|
|
}
|
|
|
|
if ( sBHI.lpszNameField )
|
|
{
|
|
GlobalFree( sBHI.lpszNameField );
|
|
}
|
|
|
|
if ( sBHI.lpszBodyContents )
|
|
{
|
|
GlobalFree( sBHI.lpszBodyContents );
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "BodyHeader() Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // BodyHeader( )
|
|
|
|
|
|
//
|
|
// What: ContentDisposition
|
|
//
|
|
// Desc: Content-Disposition state reached. Parse header entry.
|
|
//
|
|
// In/Out: lpBHI is a pointer to the body header information structure
|
|
// that will be filled in as arguments are parsed.
|
|
//
|
|
// Return: TRUE unless a unrecognized token is found.
|
|
//
|
|
BOOL CMultipartParse::ContentDisposition( LPBODYHEADERINFO lpBHI )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
LEXICON eLex;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "ContentDisposition( lpBHI=0x%x )",
|
|
lpBHI );
|
|
|
|
// What forms do we support?
|
|
while ( fReturn )
|
|
{
|
|
eLex = Lex( );
|
|
switch ( eLex )
|
|
{
|
|
// supported
|
|
case LEX_FORMDATA:
|
|
lpBHI->eContentDisposition = eLex;
|
|
break; // LEX_FORMDATA
|
|
|
|
// unsupported
|
|
case LEX_ATTACHMENT:
|
|
DebugMsg( lpszDebug, "'%s' (Multiple files) not supported (yet). Aborting...\n",
|
|
FindTokenName( LEX_ATTACHMENT ) );
|
|
fReturn = FALSE;
|
|
break; // LEX_ATTACHMENT
|
|
|
|
// possible optional fields
|
|
case LEX_NAMEFIELD:
|
|
fReturn = GetQuotedString( &lpBHI->lpszNameField );
|
|
DebugMsg( lpszDebug, "Name Field='%s'\n", lpBHI->lpszNameField );
|
|
break;
|
|
|
|
case LEX_FILENAMEFIELD:
|
|
fReturn = GetQuotedString( &lpBHI->lpszFilenameField );
|
|
DebugMsg( lpszDebug, "Filename Field='%s'\n", lpBHI->lpszFilenameField );
|
|
break;
|
|
|
|
// ignored
|
|
case LEX_SPACE:
|
|
case LEX_SEMICOLON:
|
|
break;
|
|
|
|
case LEX_BEGIN_COMMENT:
|
|
fReturn = HandleComments( );
|
|
break; // ingored
|
|
|
|
case LEX_CRLF:
|
|
eLex = Lex( );
|
|
if ( eLex != LEX_SPACE )
|
|
{
|
|
fReturn = BackupLex( eLex );
|
|
goto Cleanup; // end of field
|
|
}
|
|
// otherwise we ignore the CRLF and keep going
|
|
break;
|
|
|
|
// unexpected things
|
|
default:
|
|
DebugMsg( lpszDebug, "Unexpected '%s' found at %u (0x%x) bytes.\n",
|
|
FindTokenName( eLex), ( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
fReturn = FALSE;
|
|
}
|
|
} // while eLex
|
|
|
|
Cleanup:
|
|
TraceMsg( TF_FUNC | TF_PARSE, "ContentDisposition() Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // ContentDisposition( )
|
|
|
|
//
|
|
// What: ContentType
|
|
//
|
|
// Desc: Content-Type state reached. Parse header entry.
|
|
//
|
|
// Return: TRUE unless a unrecognized token is found.
|
|
//
|
|
BOOL CMultipartParse::ContentType( LPBODYHEADERINFO lpBHI )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
BOOL fAfterSlash = FALSE;
|
|
LEXICON eLex;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "ContentType( lpBHI=0x%x )",
|
|
lpBHI );
|
|
|
|
while ( fReturn )
|
|
{
|
|
eLex = Lex( );
|
|
switch ( eLex )
|
|
{
|
|
// MIME types
|
|
case LEX_MULTIPART:
|
|
case LEX_TEXT:
|
|
case LEX_APPLICATION:
|
|
case LEX_AUDIO:
|
|
case LEX_IMAGE:
|
|
case LEX_MESSAGE:
|
|
case LEX_VIDEO:
|
|
lpBHI->dwContentType = eLex;
|
|
break;
|
|
|
|
// separator
|
|
case LEX_SLASH:
|
|
fAfterSlash = TRUE;
|
|
break;
|
|
|
|
// MIME subtypes
|
|
case LEX_FORMDATA:
|
|
case LEX_ATTACHMENT:
|
|
case LEX_MIXED:
|
|
case LEX_PLAIN:
|
|
case LEX_XMSDOWNLOAD:
|
|
case LEX_OCTETSTREAM:
|
|
case LEX_BINARY:
|
|
lpBHI->dwContentSubtype = eLex;
|
|
break;
|
|
|
|
// these are prefixes (like "x-") so we ignore the rest of the
|
|
// token name.
|
|
case LEX_MIMEEXTENSION:
|
|
fReturn = GetToken( ); // ignore
|
|
if ( !fAfterSlash )
|
|
{
|
|
lpBHI->dwContentType = eLex;
|
|
}
|
|
else
|
|
{
|
|
lpBHI->dwContentSubtype = eLex;
|
|
}
|
|
break;
|
|
|
|
// ignored
|
|
case LEX_SPACE:
|
|
case LEX_SEMICOLON:
|
|
break;
|
|
|
|
case LEX_BEGIN_COMMENT:
|
|
fReturn = HandleComments( );
|
|
break; // ingored
|
|
|
|
case LEX_CRLF:
|
|
eLex = Lex( );
|
|
if ( eLex != LEX_SPACE )
|
|
{
|
|
fReturn = BackupLex( eLex );
|
|
goto Cleanup; // end of field
|
|
}
|
|
// otherwise we ignore the CRLF and keep going
|
|
break;
|
|
|
|
default:
|
|
if ( !fAfterSlash )
|
|
{
|
|
DebugMsg( lpszDebug, "Unexpected '%s' found at %u (0x%x) bytes.\n",
|
|
FindTokenName( eLex ), ( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
fReturn = FALSE;
|
|
}
|
|
else
|
|
{
|
|
fReturn = GetToken( );
|
|
}
|
|
|
|
} // switch eLex
|
|
|
|
} // while fReturn
|
|
|
|
Cleanup:
|
|
TraceMsg( TF_FUNC | TF_PARSE, "ContentType() Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // ContentType( )
|
|
|
|
//
|
|
// What: GetBoundaryString
|
|
//
|
|
// Desc: Searches CONTENT_TYPE for boundary string and copies into
|
|
// buffer (GlobalAlloced).
|
|
//
|
|
// Return: TRUE is boundary found and copied, otherwise FALSE.
|
|
//
|
|
BOOL CMultipartParse::GetBoundaryString( LPBYTE lpbData )
|
|
{
|
|
BOOL fReturn;
|
|
LPSTR lpstr;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "GetBoundaryString( )" );
|
|
|
|
// assume failure
|
|
_lpszBoundary = NULL;
|
|
_cbBoundary = 0;
|
|
fReturn = FALSE;
|
|
|
|
// find the boundary keyword
|
|
lpstr = StrStrI( (LPSTR) lpbData, g_cszBoundaryKeyword );
|
|
if ( !lpstr )
|
|
goto Cleanup;
|
|
|
|
// move forward of keyword
|
|
lpstr += g_cbBoundaryKeyword;
|
|
|
|
// point to boundary string
|
|
_lpszBoundary = StrDup( lpstr );
|
|
_cbBoundary = lstrlen( _lpszBoundary );
|
|
|
|
DebugMsg( lpszDebug, "Boundary String : 'CRLF--%sCRLF' %u (0x%x) bytes\n",
|
|
_lpszBoundary, _cbBoundary + 6, _cbBoundary + 6 );
|
|
DebugMsg( lpszDebug, "EndOfContent Str: 'CRLF--%s--CRLF' %u (0x%x) bytes\n",
|
|
_lpszBoundary, _cbBoundary + 8, _cbBoundary + 8 );
|
|
|
|
fReturn = TRUE;
|
|
|
|
Cleanup:
|
|
// _lpszBoundary will be cleaned up on the destruction of the
|
|
// class.
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "GetBoundaryString( ) Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
} // GetBoundaryString( )
|
|
|
|
|
|
|
|
//
|
|
// What: HandleComments
|
|
//
|
|
// Desc: pull down comments and discard them.
|
|
// ISSUE: Doesn't handle embedded comments.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::HandleComments( )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
TraceMsg( TF_FUNC | TF_PARSE, "HandleComments( )" );
|
|
|
|
LEXICON eLex = LEX_UNKNOWN;
|
|
while( eLex != LEX_END_COMMENT )
|
|
eLex = Lex( ); // parse away...
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "HandleComments( ) Exit" );
|
|
return fReturn;
|
|
} // HandleComments( )
|
|
|
|
|
|
//
|
|
// What: BodyContent
|
|
//
|
|
// Desc: Handles the content part of the body.
|
|
//
|
|
// In: lpBHI is the body header information structure that
|
|
// contains arguments found in the body header.
|
|
//
|
|
// Return: TRUE unless a unrecognized token is found.
|
|
//
|
|
BOOL CMultipartParse::BodyContent( LPBODYHEADERINFO lpBHI )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "BodyContent( lpBHI=0x%x )",
|
|
lpBHI );
|
|
|
|
// Is it a file?
|
|
if (( lpBHI->lpszFilenameField )
|
|
&& ( lpBHI->lpszFilenameField[ 0 ] != 0 ))
|
|
{ // file content....
|
|
fReturn = HandleFile( lpBHI->lpszFilenameField );
|
|
if ( fReturn )
|
|
DebugMsg( lpszDebug, "Body Data= FILE CONTENTS\n" );
|
|
}
|
|
else
|
|
{ // TODO: we need to handle different "Content-Types".
|
|
// For now we will assume that it is text/plain.
|
|
LEXICON eLex = LEX_UNKNOWN;
|
|
|
|
LPBYTE lpbStart = _lpbParse;
|
|
DWORD dwSize;
|
|
fReturn = FindNextBoundary( &dwSize );
|
|
|
|
// neaten up to be displayed and copied
|
|
CHAR cTemp = *_lpbParse; // save
|
|
*_lpbParse = 0; // null to display
|
|
DebugMsg( lpszDebug, "Body Data='%s'\n", lpbStart );
|
|
lpBHI->lpszBodyContents = StrDup( (LPSTR) lpbStart );
|
|
*_lpbParse = cTemp; // restore
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "BodyContent( _lpbParse=0x%x ) Exit = %s",
|
|
_lpbParse, BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
} // BodyContent( )
|
|
|
|
//
|
|
// What: GetQuotedString
|
|
//
|
|
// Desc: Retrieves a quoted string from data.
|
|
//
|
|
// In/Out: lppszBuf is a passed in buffer pointer which will be assigned to
|
|
// to the field name.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::GetQuotedString( LPSTR *lppszBuf )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
LPBYTE lpbStart;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "GetQuotedString( )" );
|
|
|
|
LEXICON eLex = Lex( );
|
|
fReturn = ( eLex == LEX_QUOTE );
|
|
if ( !fReturn )
|
|
{
|
|
DebugMsg( lpszDebug, "Excepted the beginning of a quoted string at %u (0x%x) bytes.\n",
|
|
( _lpbParse - _lpbData ), ( _lpbParse - _lpbData ) );
|
|
goto Cleanup;
|
|
}
|
|
|
|
lpbStart = _lpbParse;
|
|
while (( (DWORD) ( _lpbParse - _lpbData ) < lpEcb->cbTotalBytes )
|
|
&& ( *_lpbParse != '\"' ))
|
|
_lpbParse++;
|
|
|
|
if ( _lpbParse == (LPBYTE) lpEcb->cbTotalBytes )
|
|
{
|
|
fReturn = FALSE;
|
|
*lppszBuf = StrDup( "Error!" );
|
|
}
|
|
else
|
|
{
|
|
CHAR cTmp = *_lpbParse;
|
|
*_lpbParse = 0; // save
|
|
*lppszBuf = StrDup( (LPSTR) lpbStart );
|
|
*_lpbParse = cTmp; // restore
|
|
_lpbParse++; // get past the quote
|
|
}
|
|
|
|
Cleanup:
|
|
TraceMsg( TF_FUNC | TF_PARSE, "GetQuoteString( ) Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // GetQuotedString( )
|
|
|
|
//
|
|
// What: GetToken
|
|
//
|
|
// Desc: Scans past unknow content and validates that the characters
|
|
// used are acceptable ( see RFC 1521, page 9 ). If an invalid
|
|
// character is found, it will exit (no error).
|
|
//
|
|
// Return: FALSE if we run past the end of the data buffer, otherwise TRUE.
|
|
//
|
|
BOOL CMultipartParse::GetToken( )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
|
|
static const char szInvalidChars[] = "()<>@,;:\\\"/[]?=";
|
|
// plus SPACE and CTLs (in if statement)
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "GetToken()" );
|
|
|
|
while ( (DWORD) ( _lpbParse - _lpbData ) < lpEcb->cbTotalBytes )
|
|
{
|
|
if (( *_lpbParse <= 32 )
|
|
|| ( StrChr( szInvalidChars, *_lpbParse ) ))
|
|
break;
|
|
|
|
_lpbParse++;
|
|
}
|
|
|
|
if ( (DWORD) ( _lpbParse - _lpbData ) == lpEcb->cbTotalBytes )
|
|
{
|
|
DebugMsg( lpszDebug, "Could not find the end of the token.\n" );
|
|
fReturn = FALSE;
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "GetToken() Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // GetToken( )
|
|
|
|
//
|
|
// What: HandleFile
|
|
//
|
|
// Desc: Retrieves "file" part of the body.
|
|
//
|
|
// In: lpszFilename is the name of the file from the form submission.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::HandleFile( LPSTR lpszFilename )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
DWORD eLex = LEX_UNKNOWN;
|
|
DWORD dwSize;
|
|
LPBYTE lpbStart;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "HandleFile( \"%s\" )", lpszFilename );
|
|
|
|
// find the end of the file
|
|
lpbStart = _lpbParse;
|
|
fReturn = FindNextBoundary( &dwSize );
|
|
|
|
// fix filename for server use
|
|
if ( fReturn )
|
|
{
|
|
DebugMsg( lpszDebug, "Filesize= %u (0x%x) bytes\n", dwSize, dwSize );
|
|
fReturn = FixFilename( lpszFilename, &lpszFilename );
|
|
}
|
|
|
|
// Check the filename for ""
|
|
if (( fReturn ) && ( StrCmp( lpszFilename, "" ) ))
|
|
{
|
|
#ifndef FILE_SAVE
|
|
fReturn = FileCompare( lpbStart, lpszFilename, dwSize );
|
|
#else // FILE_SAVE
|
|
fReturn = FileSave( lpbStart, lpszFilename, dwSize );
|
|
#endif // FILE_SAVE
|
|
}
|
|
|
|
if ( !fReturn )
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, NULL, "Error: File possibly corrupt." );
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "HandleFile( \"%s\" ) Exit = %s",
|
|
lpszFilename, BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
} // HandleFile( )
|
|
|
|
|
|
//
|
|
// What: FindNextBoundary
|
|
//
|
|
// Desc: Finds the next boundary in body content and the length of
|
|
// the block skipped.
|
|
//
|
|
// Out: *lpdwSize will contain the size of the block skipped.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::FindNextBoundary( LPDWORD lpdwSize )
|
|
{
|
|
BOOL fReturn = FALSE; // assume failure
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FindNextBoundary()" );
|
|
|
|
lpDT[ _cbDT ].lpAddr = _lpbParse;
|
|
lpDT[ _cbDT ].dwColor = 0x000000;
|
|
lpDT[ _cbDT ].lpszComment = (LPSTR) g_cszBodyData;
|
|
_cbDT++;
|
|
if ( _cbDT >= MAX_DT )
|
|
{
|
|
DebugMsg( lpszDebug, "*** DEBUG ERROR *** Exceeded Dump Table Limit\n" );
|
|
_cbDT = MAX_DT - 1;
|
|
}
|
|
|
|
// find the end of the file
|
|
LPBYTE lpbStart = _lpbParse;
|
|
while ( (DWORD) ( _lpbParse - _lpbData ) < lpEcb->cbTotalBytes )
|
|
{
|
|
// possible boundary?
|
|
if ( !StrCmpN( (LPSTR) _lpbParse, g_cszBoundaryIndicator, g_cbBoundaryIndicator ) )
|
|
{ // yes... check further
|
|
LPBYTE lpb = _lpbParse; // save
|
|
LEXICON eLex = Lex( );
|
|
_lpbParse = lpb; // restore
|
|
_cbDT--; // ignore this parse
|
|
if (( eLex == LEX_BOUNDARY ) || ( eLex == LEX_EOT ))
|
|
{
|
|
fReturn = TRUE;
|
|
break; // exit loop
|
|
}
|
|
}
|
|
_lpbParse++;
|
|
}
|
|
|
|
// figure out the size
|
|
*lpdwSize = _lpbParse - lpbStart;
|
|
|
|
if ( !fReturn )
|
|
{
|
|
DebugMsg( lpszDebug, "FindNextBoundary( ): Did not find boundary after %u (0x%x) bytes.\n",
|
|
lpbStart - _lpbData, lpbStart - _lpbData );
|
|
|
|
_lpbParse--; // back up one byte
|
|
_cbDT--; // back up one parse table entry
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FindNextBoundary( *lpdwSize = %u (0x%x) ) Exit = %s",
|
|
*lpdwSize, *lpdwSize, BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // FindNextBoundary( )
|
|
|
|
#ifndef FILE_SAVE
|
|
//
|
|
// What: MemoryCompare
|
|
//
|
|
// Desc: Compares memory chunks and determines if they match
|
|
//
|
|
// In: lpbSrc1 and lpbSrc2 and the memory blocks to compare.
|
|
// dwSize is the length of the blocks.
|
|
//
|
|
// Return: TRUE if they match, otherwise FALSE
|
|
//
|
|
BOOL CMultipartParse::MemoryCompare( LPBYTE lpbSrc1, LPBYTE lpbSrc2, DWORD dwSize )
|
|
{
|
|
DWORD cb = 0;
|
|
while (( cb < dwSize ) && ( *lpbSrc1 == *lpbSrc2 ))
|
|
{
|
|
lpbSrc1++;
|
|
lpbSrc2++;
|
|
cb++;
|
|
}
|
|
|
|
return ( cb == dwSize );
|
|
} // MemoryCompare( )
|
|
|
|
//
|
|
// What: FileCompare
|
|
//
|
|
// Desc: Compares bits in memory with contents of the file lpszFilename.
|
|
//
|
|
// In: lpbStart is the starting memory address.
|
|
// lpszFilename is the filename to use.
|
|
// dwSize is the length of valid bits after lpbStart.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::FileCompare( LPBYTE lpbStart, LPSTR lpszFilename, DWORD dwSize )
|
|
{
|
|
#define BIG_FILE_SIZE 4096
|
|
BOOL fReturn = TRUE;
|
|
DWORD dwRead;
|
|
LPBYTE lpBuffer;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FileCompare( lpbStart=0x%x, lpszFilename='%s', dwSize=%u )",
|
|
lpbStart, lpszFilename, dwSize );
|
|
|
|
HANDLE hFile = CreateFile( lpszFilename, GENERIC_READ,
|
|
FILE_SHARE_READ, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL );
|
|
if ( hFile == INVALID_HANDLE_VALUE )
|
|
{
|
|
DebugMsg( lpszDebug, "CreateFile() failed to open '%s'.\n",
|
|
lpszFilename );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwRead = GetFileSize( hFile, NULL );
|
|
if ( dwSize != dwRead )
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, lpszDebug, "FileChecking: File sizes don't match: '%s'",
|
|
lpszFilename );
|
|
DebugMsg( lpszDebug, "FileChecking: Client sent=%u (0x%x) bytes and File length=%u (0x%x) bytes.\n",
|
|
lpszFilename, dwSize, dwSize, dwRead, dwRead );
|
|
DebugMsg( lpszDebug, "FileChecking: I will compare the bits I can.\n" );
|
|
fReturn = FALSE;
|
|
|
|
// shorten if needed
|
|
dwSize = ( dwSize > dwRead ? dwRead : dwSize );
|
|
}
|
|
|
|
if ( dwSize > BIG_FILE_SIZE )
|
|
{ // read/compare only the beginning and the end bytes
|
|
DWORD dwShortSize = BIG_FILE_SIZE / 2;
|
|
|
|
DebugMsg( lpszDebug, "FileChecking: **** Very large file ( > %u (0x%x) bytes )****\n",
|
|
BIG_FILE_SIZE, BIG_FILE_SIZE );
|
|
DebugMsg( lpszDebug, "FileChecking: Checking only the beginning %u (0x%x) bytes and the last %u (0x%x) bytes.\n",
|
|
dwShortSize, dwShortSize, dwShortSize, dwShortSize);
|
|
|
|
lpBuffer = (LPBYTE) GlobalAlloc( GMEM_FIXED, dwShortSize );
|
|
if ( !lpBuffer )
|
|
{
|
|
DebugMsg( lpszDebug, "Out of memory(?).\n" );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
// read beginning bytes
|
|
if ( !ReadFile( hFile, lpBuffer, dwShortSize, &dwRead, NULL ) )
|
|
{
|
|
DebugMsg( lpszDebug, "begin bytes ReadFile() failed.\n" );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
if ( dwShortSize != dwRead )
|
|
{
|
|
DebugMsg( lpszDebug, "FileChecking(begin bytes): Unable to read %u (0x%x) bytes from file '%s'.\n",
|
|
dwShortSize, dwShortSize, lpszFilename );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
fReturn = MemoryCompare( lpBuffer, lpbStart, dwShortSize );
|
|
if ( !fReturn )
|
|
goto Cleanup;
|
|
|
|
// seek to end bytes
|
|
if ( 0xFFFFffff == SetFilePointer( hFile, dwSize - dwShortSize, NULL, FILE_BEGIN ) )
|
|
{ // error
|
|
DebugMsg( lpszDebug, "SetFilePointer() failed!\n" );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// read end bytes
|
|
if ( !ReadFile( hFile, lpBuffer, dwShortSize, &dwRead, NULL ) )
|
|
{
|
|
DebugMsg( lpszDebug, "end bytes ReadFile() failed.\n" );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
if ( dwShortSize != dwRead )
|
|
{
|
|
DebugMsg( lpszDebug, "FileChecking(end bytes): Unable to read %u (0x%x) bytes from file '%s'.\n",
|
|
dwShortSize, dwShortSize, lpszFilename );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
fReturn = MemoryCompare( lpBuffer, lpbStart + dwSize - dwShortSize, dwShortSize );
|
|
}
|
|
else // if ( dwSize > BIG_FILE_SIZE )
|
|
{ // read/compare entire file
|
|
lpBuffer = (LPBYTE) GlobalAlloc( GMEM_FIXED, dwSize );
|
|
if ( !lpBuffer )
|
|
{
|
|
DebugMsg( lpszDebug, "Out of memory(?).\n" );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if ( !ReadFile( hFile, lpBuffer, dwSize, &dwRead, NULL ) )
|
|
{
|
|
DebugMsg( lpszDebug, "ReadFile() failed.\n" );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if ( dwSize != dwRead )
|
|
{
|
|
DebugMsg( lpszDebug, "FileChecking: Unable to read %u (0x%x) bytes from file '%s'.\n",
|
|
dwSize, dwSize, lpszFilename );
|
|
fReturn = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
fReturn = MemoryCompare( lpBuffer, lpbStart, dwSize );
|
|
|
|
} // if ( dwSize > BIG_FILE_SIZE )
|
|
|
|
|
|
Cleanup:
|
|
if ( hFile != INVALID_HANDLE_VALUE )
|
|
CloseHandle( hFile ); // close file
|
|
|
|
GlobalFree( lpBuffer );
|
|
|
|
// Output to IIS log
|
|
if ( fReturn )
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, lpszDebug, "FileChecking: Files matched!" );
|
|
}
|
|
else
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, lpszDebug, "FileChecking: Files don't match or an error occured." );
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FileCompare( lpbStart=0x%x, lpszFilename='%s', dwSize=%u ) Exit = %s",
|
|
lpbStart, lpszFilename, dwSize, BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // FileCompare( )
|
|
|
|
#else // FILE_SAVE
|
|
|
|
//
|
|
// What: FileSave
|
|
//
|
|
// Desc: Save bits starting at lpbStart to a file called lpszFilename.
|
|
//
|
|
// In: lpbStart is the starting memory address.
|
|
// lpszFilename is the filename to use.
|
|
// dwSize is the length of valid bits after lpbStart.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::FileSave( LPBYTE lpbStart, LPSTR lpszFilename, DWORD dwSize )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FileSave( lpbStart=0x%x, lpszFilename='%s', dwSize=%u )",
|
|
lpbStart, lpszFilename, dwSize );
|
|
|
|
if ( fReturn )
|
|
{
|
|
HANDLE hFile = CreateFile( lpszFilename, GENERIC_WRITE,
|
|
FILE_SHARE_READ, NULL, CREATE_NEW,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
|
|
NULL );
|
|
if ( hFile != INVALID_HANDLE_VALUE )
|
|
{
|
|
DWORD dwWrote;
|
|
if ( WriteFile( hFile, lpbStart, dwSize, &dwWrote, NULL ) )
|
|
{
|
|
fReturn = ( dwSize == dwWrote );
|
|
if ( !fReturn )
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, lpszDebug, "Could not write entire file '%s'. Only wrote %u (0x%x) bytes.",
|
|
lpszFilename, dwWrote, dwWrote );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, lpszDebug, "Could not write file '%s'.",
|
|
lpszFilename );
|
|
fReturn = FALSE;
|
|
}
|
|
|
|
CloseHandle( hFile );
|
|
|
|
}
|
|
else
|
|
{
|
|
LogMsg( lpEcb->lpszLogData, lpszDebug, "CreateFile() failed to create '%s'.",
|
|
lpszFilename );
|
|
fReturn = FALSE;
|
|
|
|
} // if hFile
|
|
|
|
} // if fReturn
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FileSave( lpbStart=0x%x, lpszFilename='%s', dwSize=%u ) Exit = ",
|
|
lpbStart, lpszFilename, dwSize, BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // FileSave( )
|
|
|
|
#endif // FILE_SAVE
|
|
|
|
//
|
|
// What: FixFilename
|
|
//
|
|
// Desc: Adjusts filename to be used on the server. It creates a path
|
|
// to the same directory as the DLL. It then appends the just
|
|
// the filename ( not the path info ).
|
|
//
|
|
// In: lpszFilename is the filename submitted by user.
|
|
//
|
|
// In/Out: lppszNameFilename will return a pointer to the newly constructed
|
|
// filename.
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::FixFilename( LPSTR lpszFilename, LPSTR *lppszNewFilename )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
CHAR szFilename[ MAX_PATH ]; // temp buffer
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FixFilename( lpszFilename='%s', *lppszNewFilename=0x%x )",
|
|
lpszFilename, *lppszNewFilename );
|
|
|
|
// Strip c:\ stuff
|
|
LPSTR lpszShortFilename = StrRChr( lpszFilename, lpszFilename + lstrlen( lpszFilename ), '\\' );
|
|
if ( lpszShortFilename )
|
|
{
|
|
lpszShortFilename++; // move ahead of '\'
|
|
}
|
|
else
|
|
{
|
|
lpszShortFilename = lpszFilename; // maybe it's already short.
|
|
}
|
|
|
|
// retrieve download directory file URL info
|
|
LPSTR lpszPath;
|
|
fReturn = GetServerVarString( lpEcb, "PATH_TRANSLATED", &lpszPath, NULL );
|
|
if ( lpszPath )
|
|
{
|
|
StrCpy( szFilename, lpszPath );
|
|
DWORD cch = lstrlen( szFilename );
|
|
// check for '\' at the end...
|
|
if ( szFilename[ cch - 1 ] != '\\' )
|
|
{ // not there... add it
|
|
szFilename[ cch ] = '\\';
|
|
cch++;
|
|
}
|
|
// append filename
|
|
StrCpy( &szFilename[ cch ], lpszShortFilename );
|
|
}
|
|
else
|
|
{
|
|
StrCpy( szFilename, lpszShortFilename );
|
|
}
|
|
|
|
*lppszNewFilename = StrDup( szFilename );
|
|
fReturn = ( *lppszNewFilename != NULL );
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FixFilename( lpszFilename='%s', *lppszNewFilename=0x%x ) Exit = %s",
|
|
lpszFilename, *lppszNewFilename, BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // FixFilename( )
|
|
|
|
//
|
|
// What: Lex
|
|
//
|
|
// Desc: Turns the next bytes into a token
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
LEXICON CMultipartParse::Lex( )
|
|
{
|
|
TraceMsg( TF_FUNC | TF_PARSE | TF_LEX, "Lex( _lpbParse=0x%x )",
|
|
_lpbParse );
|
|
|
|
lpDT[ _cbDT ].lpAddr = _lpbParse;
|
|
lpDT[ _cbDT ].dwColor = 0xFFFFFF;
|
|
lpDT[ _cbDT ].lpszComment = (LPSTR) g_cszExtraBytes;
|
|
|
|
if ( _lpbParse > _lpbData + lpEcb->cbTotalBytes )
|
|
{
|
|
return LEX_EOT; // over the limit!
|
|
}
|
|
|
|
for( int i = 0; g_LexTable[ i ].lpszName != NULL; i++ )
|
|
{
|
|
// remember str length sizes to speed up on next pass
|
|
if ( !g_LexTable[ i ].cLength )
|
|
{
|
|
g_LexTable[ i ].cLength = lstrlen( g_LexTable[ i ].lpszName );
|
|
}
|
|
|
|
if ( !StrCmpNI( (LPSTR)_lpbParse, g_LexTable[ i ].lpszName, g_LexTable[ i ].cLength ) )
|
|
break; // found... exit
|
|
|
|
} // for i
|
|
|
|
// SPECIAL CASE
|
|
LEXICON eLex = g_LexTable[ i ].eLex;
|
|
if ( eLex == LEX_BOUNDARY )
|
|
{ // check for a specific boundary marker
|
|
_lpbParse += g_LexTable[ i ].cLength;
|
|
eLex = LEX_UNKNOWN;
|
|
|
|
if ( !StrCmpN( (LPSTR) _lpbParse , _lpszBoundary, _cbBoundary ) )
|
|
{ // match
|
|
// check to see if it is an EOT Marker
|
|
if ( !StrCmpN( (LPSTR) ( _lpbParse + _cbBoundary ), "--\r\n", 4 ) )
|
|
{
|
|
_lpbParse += _cbBoundary + 4;
|
|
eLex = LEX_EOT;
|
|
}
|
|
// else make sure that it ends with a CRLF - rfc1521 Page 30
|
|
else if ( !StrCmpN( (LPSTR) ( _lpbParse + _cbBoundary ), "\r\n", 2 ) )
|
|
{
|
|
_lpbParse += _cbBoundary + 2;
|
|
eLex = LEX_BOUNDARY;
|
|
}
|
|
// else it isn't a boundary
|
|
}
|
|
}
|
|
else if ( eLex == LEX_STARTBOUNDARY )
|
|
{ // check for a specific boundary marker
|
|
_lpbParse += g_LexTable[ i ].cLength;
|
|
eLex = LEX_UNKNOWN;
|
|
|
|
if ( !StrCmpN( (LPSTR) _lpbParse , _lpszBoundary, _cbBoundary ) )
|
|
{ // match
|
|
// check to see if it is an EOT Marker
|
|
if ( !StrCmpN( (LPSTR) ( _lpbParse + _cbBoundary ), "\r\n", 2 ) )
|
|
{
|
|
_lpbParse += _cbBoundary + 2;
|
|
eLex = LEX_STARTBOUNDARY;
|
|
}
|
|
// else it isn't a boundary
|
|
}
|
|
}
|
|
else if ( eLex == LEX_UNKNOWN )
|
|
{
|
|
_lpbParse++;
|
|
}
|
|
else // move past symbol
|
|
{
|
|
_lpbParse += g_LexTable[ i ].cLength;
|
|
}
|
|
|
|
|
|
lpDT[ _cbDT ].dwColor = g_LexTable[ i ].dwColor;
|
|
lpDT[ _cbDT ].lpszComment = g_LexTable[ i ].lpszComment;
|
|
_cbDT++;
|
|
if ( _cbDT >= MAX_DT )
|
|
{
|
|
DebugMsg( lpszDebug, "*** DEBUG ERROR *** Exceeded Dump Table Limit\n" );
|
|
_cbDT = MAX_DT - 1;
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE | TF_LEX, "Lex( _lpbParse=0x%x ) Exit = %u ( %u, '%s')",
|
|
_lpbParse, eLex, i,
|
|
( g_LexTable[ i ].lpszName ? g_LexTable[ i ].lpszName : "NULL" ) );
|
|
return eLex;
|
|
} // Lex( )
|
|
|
|
//
|
|
// What: Find Token
|
|
//
|
|
// Desc: Searches tokens and displays friendly name.
|
|
//
|
|
// In: eLex is the Lexicon to find
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
LPSTR CMultipartParse::FindTokenName( LEXICON eLex )
|
|
{
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FindTokenName( )" );
|
|
|
|
LPSTR lpszReturn = "<not found>"; // default
|
|
|
|
for( int i = 0; g_LexTable[ i ].lpszName != NULL; i++ )
|
|
{
|
|
if ( g_LexTable[ i ].eLex == eLex )
|
|
break; // found... exit
|
|
|
|
} // for i
|
|
|
|
// SPECIAL CASE
|
|
if ( eLex == LEX_BOUNDARY )
|
|
{
|
|
lpszReturn = _lpszBoundary;
|
|
}
|
|
else if ( eLex == LEX_EOT )
|
|
{
|
|
lpszReturn = _lpszBoundary;
|
|
}
|
|
else if ( eLex == LEX_UNKNOWN )
|
|
{
|
|
LPBYTE lpb = _lpbParse - 1;
|
|
while (( *lpb ) && ( *lpb > 32 ))
|
|
lpb++;
|
|
*lpb = 0;
|
|
lpszReturn = (LPSTR) _lpbParse;
|
|
}
|
|
else if ( g_LexTable[ i ].lpszName )
|
|
{
|
|
lpszReturn = g_LexTable[ i ].lpszName;
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "FindTokenName( ) Exit" );
|
|
return lpszReturn;
|
|
|
|
} // FindTokenName( )
|
|
|
|
//
|
|
// What: BackupLex
|
|
//
|
|
// Desc: Backs parser up eLex's byte count.
|
|
//
|
|
// In: eLex is the token ID to back up
|
|
//
|
|
// Return: TRUE unless an error occurs.
|
|
//
|
|
BOOL CMultipartParse::BackupLex( LEXICON eLex )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "BackupLex( eLex=%s )",
|
|
FindTokenName( eLex ) );
|
|
|
|
for( int i = 0; g_LexTable[ i ].lpszName != NULL; i++ )
|
|
{
|
|
if ( g_LexTable[ i ].eLex == eLex )
|
|
break; // found... exit
|
|
|
|
} // for i
|
|
|
|
// SPECIAL CASES
|
|
if ( eLex == LEX_BOUNDARY )
|
|
{
|
|
// "CRLF--" + boundary string + "CRLF"
|
|
_lpbParse -= ( g_LexTable[ i ].cLength + _cbBoundary + 2 );
|
|
}
|
|
else if ( eLex == LEX_EOT )
|
|
{
|
|
// "CRLF--" + boundary string + "--CRLF"
|
|
_lpbParse -= ( g_LexTable[ i ].cLength + _cbBoundary + 4 );
|
|
}
|
|
else if ( eLex == LEX_UNKNOWN )
|
|
{
|
|
_lpbParse--;
|
|
}
|
|
else if ( g_LexTable[ i ].lpszName )
|
|
{
|
|
_lpbParse -= g_LexTable[ i ].cLength;
|
|
}
|
|
|
|
if ( fReturn )
|
|
{
|
|
_cbDT--; // remove one
|
|
}
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "BackupLex( eLex=%s ) Exit",
|
|
FindTokenName( eLex ) );
|
|
return fReturn;
|
|
|
|
} // BackupLex( )
|
|
|
|
/*****************************************************************************
|
|
//
|
|
// FUNCTION TEMPLATE
|
|
//
|
|
// ***************************************************************************
|
|
//
|
|
// What:
|
|
//
|
|
// Desc:
|
|
//
|
|
// In:
|
|
//
|
|
// Out:
|
|
//
|
|
// Return:
|
|
//
|
|
BOOL CMultipartParse::( )
|
|
{
|
|
BOOL fReturn = TRUE;
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "()" );
|
|
|
|
|
|
TraceMsg( TF_FUNC | TF_PARSE, "() Exit = %s",
|
|
BOOLTOSTRING( fReturn ) );
|
|
return fReturn;
|
|
|
|
} // ( )
|
|
|
|
******************************************************************************/
|