2141 lines
49 KiB
C++
2141 lines
49 KiB
C++
/*++
|
||
|
||
Copyright (c) 1994 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
dirlist.cxx
|
||
|
||
Abstract:
|
||
|
||
Contains functions for parsing directory output from LIST command
|
||
|
||
Contents:
|
||
ParseDirList
|
||
IsFilespecWild
|
||
ClearFindList
|
||
(DetermineDirectoryFormat)
|
||
(IsNtDateFormat)
|
||
(GetToken)
|
||
(IsUnixAttributeFormat)
|
||
(ParseNtDirectory)
|
||
(ParseUnixDirectory)
|
||
(ParseOs2Directory)
|
||
(ParseMacDirectory)
|
||
(ExtractFileSize)
|
||
(_ExtractFilename)
|
||
(ExtractNtDate)
|
||
(ExtractUnixDate)
|
||
(ExtractOs2Attributes)
|
||
(ParseWord)
|
||
(ExtractInteger)
|
||
|
||
Author:
|
||
|
||
Richard L Firth (rfirth) 26-Jul-1995
|
||
|
||
Environment:
|
||
|
||
Win32(s) user-mode DLL
|
||
|
||
Revision History:
|
||
|
||
26-Jul-1995 rfirth
|
||
Created
|
||
|
||
--*/
|
||
|
||
#include <wininetp.h>
|
||
#include "ftpapih.h"
|
||
|
||
//
|
||
// private manifests
|
||
//
|
||
|
||
#define MAX_YEAR_SUPPORTED 2100
|
||
#define TOKEN_BUFFER_LENGTH 128
|
||
#define RELATIVELY_SMALL_AMOUNT_OF_LS_DATA 512 // arbitrary, but allow for
|
||
// prolix error text
|
||
|
||
//
|
||
// private types
|
||
//
|
||
|
||
typedef enum {
|
||
State_Start,
|
||
State_Error,
|
||
State_Continue,
|
||
State_Done
|
||
} PARSE_STATE;
|
||
|
||
typedef PARSE_STATE (*DIR_PARSER)(LPSTR*, LPDWORD, LPWIN32_FIND_DATA);
|
||
|
||
//
|
||
// private macros
|
||
//
|
||
|
||
#define ClearFileTime(fileTime) \
|
||
(fileTime).dwLowDateTime = 0; \
|
||
(fileTime).dwHighDateTime = 0;
|
||
|
||
#define ClearFindDataFields(lpFind) \
|
||
ClearFileTime((lpFind)->ftCreationTime); \
|
||
ClearFileTime((lpFind)->ftLastAccessTime); \
|
||
(lpFind)->dwReserved0 = 0; \
|
||
(lpFind)->dwReserved1 = 0; \
|
||
(lpFind)->cAlternateFileName[0] = '\0';
|
||
|
||
//
|
||
// private prototypes
|
||
//
|
||
|
||
PRIVATE
|
||
BOOL
|
||
DetermineDirectoryFormat(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
OUT DIR_PARSER* ParserFunction
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
IsNtDateFormat(
|
||
IN LPSTR lpBuffer,
|
||
IN DWORD dwBufferLength
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
GetToken(
|
||
IN LPSTR lpszBuffer,
|
||
IN DWORD dwBufferLength,
|
||
OUT LPSTR lpszToken,
|
||
IN OUT LPDWORD lpdwTokenLength
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
IsUnixAttributeFormat(
|
||
IN LPSTR lpBuffer,
|
||
IN DWORD dwBufferLength
|
||
);
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseNtDirectory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseUnixDirectory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseOs2Directory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseMacDirectory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractFileSize(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
_ExtractFilename(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractNtDate(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractUnixDate(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractOs2Attributes(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ParseWord(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN WORD LowerBound,
|
||
IN WORD UpperBound,
|
||
OUT LPWORD lpNumber
|
||
);
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractInteger(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
OUT LPINT lpNumber
|
||
);
|
||
|
||
//
|
||
// private data
|
||
//
|
||
|
||
//
|
||
// DefaultSystemTime - if we fail to parse the time/date field for any reason,
|
||
// we will return this default time
|
||
//
|
||
|
||
PRIVATE static SYSTEMTIME DefaultSystemTime = {1980, 1, 0, 1, 12, 0, 0, 0};
|
||
|
||
//
|
||
// functions
|
||
//
|
||
|
||
DWORD
|
||
ParseDirList(
|
||
IN LPSTR lpBuffer,
|
||
IN DWORD dwBufferLength,
|
||
IN LPSTR lpszFilespec OPTIONAL,
|
||
IN OUT PLIST_ENTRY lpList
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Creates a list of WIN32_FIND_DATA structures given the output from the LIST
|
||
command run at the FTP server
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to buffer containing LIST output
|
||
|
||
lpBufferLength - length of Buffer - no trailing \0
|
||
|
||
lpszFilespec - pointer to file specification used to generate listing.
|
||
May contain path components. May be NULL, in which case
|
||
we perform no filtering based on name (results should be
|
||
an exact match with request)
|
||
|
||
lpList - pointer to LIST_ENTRY list to add to
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - ERROR_NOT_ENOUGH_MEMORY
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Dword,
|
||
"ParseDirList",
|
||
"%x, %d, %x",
|
||
lpBuffer,
|
||
dwBufferLength,
|
||
lpList
|
||
));
|
||
|
||
DWORD error;
|
||
DIR_PARSER directoryParser;
|
||
BOOL needBuffer;
|
||
LPSTR lpszOriginalBuffer;
|
||
DWORD dwOriginalBufferLength;
|
||
|
||
//
|
||
// remember the initial buffer pointer and length, in case we can't determine
|
||
// the format - DetermineDirectoryFormat() will alter the input buffer pointer
|
||
// and length
|
||
//
|
||
|
||
lpszOriginalBuffer = lpBuffer;
|
||
dwOriginalBufferLength = dwBufferLength;
|
||
|
||
//
|
||
// find out the format of the directory listing. Currently we understand
|
||
// NT and the basic Unix directory listing formats
|
||
//
|
||
|
||
if (!DetermineDirectoryFormat(&lpBuffer, &dwBufferLength, &directoryParser)) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
ERROR,
|
||
("Can't determine directory format\n"
|
||
));
|
||
|
||
//
|
||
// if we received a relatively small amount of data, then there is a
|
||
// good chance that what we actually received is an error message from
|
||
// the ls command, or operating system, etc. Make it an extended error.
|
||
// This will reduce (but not eliminate) the chances of getting back an
|
||
// internal error
|
||
//
|
||
|
||
if (dwBufferLength <= RELATIVELY_SMALL_AMOUNT_OF_LS_DATA) {
|
||
error = InternetSetLastError(0,
|
||
lpszOriginalBuffer,
|
||
dwOriginalBufferLength,
|
||
SLE_APPEND | SLE_ZERO_TERMINATE
|
||
);
|
||
|
||
//
|
||
// return internal error if we failed to add the text for any reason
|
||
//
|
||
|
||
error = (error == ERROR_SUCCESS)
|
||
? ERROR_INTERNET_EXTENDED_ERROR
|
||
: ERROR_INTERNET_INTERNAL_ERROR
|
||
;
|
||
} else {
|
||
|
||
//
|
||
// BUGBUG - error code?
|
||
//
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
}
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// the list must be currently empty
|
||
//
|
||
|
||
INET_ASSERT(IsListEmpty(lpList));
|
||
|
||
//
|
||
// the app may have specified a path. Chances are that if there are
|
||
// wildcards within the path then the server would have returned an
|
||
// error. But if the app requested e.g. foo\bar\*.exe then the server
|
||
// would have returned the directory results for foo\bar. Therefore,
|
||
// we must skip any path components, or all tests against the filespec
|
||
// will fail
|
||
//
|
||
|
||
if (ARGUMENT_PRESENT(lpszFilespec)) {
|
||
|
||
LPSTR lpszSpec;
|
||
|
||
lpszSpec = strrchr(lpszFilespec, '\\');
|
||
if (lpszSpec == NULL) {
|
||
lpszSpec = strrchr(lpszFilespec, '/');
|
||
}
|
||
if (lpszSpec != NULL) {
|
||
lpszFilespec = lpszSpec + 1;
|
||
}
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("lpszFilespec = %s\n",
|
||
lpszFilespec
|
||
));
|
||
|
||
}
|
||
|
||
//
|
||
// loop round, parsing the listing until we reach the end or get an
|
||
// error
|
||
//
|
||
|
||
needBuffer = TRUE;
|
||
error = ERROR_SUCCESS;
|
||
while ((dwBufferLength != 0) && (error == ERROR_SUCCESS)) {
|
||
|
||
PLIST_ENTRY dirEntry;
|
||
LPWIN32_FIND_DATA lpFind;
|
||
|
||
//
|
||
// we need to allocate a buffer for the WIN32_FIND_DATA structure
|
||
// unless we already have one from the previous iteration (because
|
||
// the filename didn't match our target criteria)
|
||
//
|
||
|
||
if (needBuffer) {
|
||
dirEntry = (PLIST_ENTRY)ALLOCATE_FIXED_MEMORY(
|
||
sizeof(LIST_ENTRY) + sizeof(WIN32_FIND_DATA)
|
||
);
|
||
lpFind = (LPWIN32_FIND_DATA)(dirEntry + 1);
|
||
needBuffer = FALSE;
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("Allocated WIN32_FIND_DATA @ %x\n",
|
||
lpFind
|
||
));
|
||
|
||
}
|
||
if (dirEntry == NULL) {
|
||
error = ERROR_NOT_ENOUGH_MEMORY;
|
||
|
||
DEBUG_PRINT(FTP,
|
||
ERROR,
|
||
("Failed to allocate WIN32_FIND_DATA\n"
|
||
));
|
||
|
||
} else {
|
||
|
||
PARSE_STATE state;
|
||
|
||
//
|
||
// zero initialize the WIN32_FIND_DATA fields we don't fill in
|
||
// below
|
||
//
|
||
|
||
ClearFindDataFields(lpFind);
|
||
|
||
//
|
||
// and parse the rest of the information out of the returned FTP
|
||
// directory listing
|
||
//
|
||
|
||
state = directoryParser(&lpBuffer, &dwBufferLength, lpFind);
|
||
|
||
//
|
||
// if the parser returns State_Continue or State_Done then we need
|
||
// to add the structure to the list if the caller wants it, else we
|
||
// free it and quit
|
||
//
|
||
|
||
if (state != State_Error) {
|
||
|
||
BOOL addIt;
|
||
|
||
//
|
||
// before we put this entry on the list, see if the caller wants
|
||
// it
|
||
//
|
||
|
||
if (ARGUMENT_PRESENT(lpszFilespec)) {
|
||
addIt = MyFsRtlIsNameInExpression(lpszFilespec,
|
||
lpFind->cFileName,
|
||
TRUE // case-sensitive
|
||
);
|
||
} else {
|
||
addIt = TRUE;
|
||
}
|
||
if (addIt) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("Match: file %q, target %q\n",
|
||
lpFind->cFileName,
|
||
lpszFilespec
|
||
));
|
||
|
||
InsertTailList(lpList, (PLIST_ENTRY)dirEntry);
|
||
needBuffer = TRUE;
|
||
} else {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("No match: file %q, target %q\n",
|
||
lpFind->cFileName,
|
||
lpszFilespec
|
||
));
|
||
|
||
}
|
||
}
|
||
|
||
//
|
||
// if we had an error or there's no more buffer to parse but we
|
||
// didn't keep the last entry, then we need to free the unused
|
||
// WIN32_FIND_DATA and get out
|
||
//
|
||
|
||
if ((state == State_Error) || ((state == State_Done) && !needBuffer)) {
|
||
FREE_MEMORY(dirEntry);
|
||
if (state == State_Error) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
ERROR,
|
||
("State_Error\n"
|
||
));
|
||
|
||
//
|
||
// BUGBUG - error code
|
||
//
|
||
|
||
error = ERROR_INTERNET_INTERNAL_ERROR;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
quit:
|
||
|
||
//
|
||
// if we had an error then free up any data structures that we allocated
|
||
//
|
||
|
||
if (error != ERROR_SUCCESS) {
|
||
ClearFindList(lpList);
|
||
}
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
|
||
BOOL
|
||
IsFilespecWild(
|
||
IN LPCSTR lpszFilespec
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Returns TRUE if lpszFilespec is a wild-card file specifier
|
||
|
||
Arguments:
|
||
|
||
lpszFilespec - pointer to string containing file specification. Cannot
|
||
be a NULL string
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
|
||
--*/
|
||
|
||
{
|
||
int len;
|
||
int i;
|
||
|
||
INET_ASSERT(ARGUMENT_PRESENT(lpszFilespec));
|
||
|
||
//
|
||
// check if the file specifier contains a '*' or a '?'. If so, then the
|
||
// caller is making a DOS-style search request and we have to perform our
|
||
// own filtering, otherwise, we can leave the server to return what the
|
||
// caller asked for
|
||
//
|
||
|
||
for (i = 0, len = strlen(lpszFilespec); i < len; ++i) {
|
||
if ((lpszFilespec[i] == '*') || (lpszFilespec[i] == '?')) {
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
VOID
|
||
ClearFindList(
|
||
IN PLIST_ENTRY lpList
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Dequeues and deallocates all WIN32_FIND_DATA structures on a directory list
|
||
|
||
Arguments:
|
||
|
||
lpList - pointer to list to clear
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
None,
|
||
"ClearFindList",
|
||
"%x",
|
||
lpList
|
||
));
|
||
|
||
while (!IsListEmpty(lpList)) {
|
||
|
||
PLIST_ENTRY lpHead;
|
||
|
||
lpHead = RemoveHeadList(lpList);
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("Freeing WIN32_FIND_DATA @ %x, FileName=%q\n",
|
||
lpHead,
|
||
((LPWIN32_FIND_DATA)(lpHead + 1))->cFileName
|
||
));
|
||
|
||
FREE_MEMORY(lpHead);
|
||
}
|
||
|
||
DEBUG_LEAVE(0);
|
||
}
|
||
|
||
//
|
||
// private functions
|
||
//
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
DetermineDirectoryFormat(
|
||
IN LPSTR* lpBuffer,
|
||
IN LPDWORD lpdwBufferLength,
|
||
OUT DIR_PARSER* lpfnParserFunction
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Determines whether the directory listing is in Unix or NT (or other?) format
|
||
and returns a pointer to the parser function to use
|
||
|
||
The buffer pointer and length may be adjusted past any prologue information
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to buffer containing directory
|
||
listing
|
||
|
||
lpdwBufferLength - pointer to length of Buffer
|
||
|
||
lpfnParserFunction - returned directory parser function
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_FTP,
|
||
Bool,
|
||
"DetermineDirectoryFormat",
|
||
"%x [%.40q], %x [%d], %x",
|
||
lpBuffer,
|
||
*lpBuffer,
|
||
lpdwBufferLength,
|
||
*lpdwBufferLength,
|
||
lpfnParserFunction
|
||
));
|
||
|
||
BOOL success;
|
||
|
||
if (!SkipWhitespace(lpBuffer, lpdwBufferLength)) {
|
||
success = FALSE;
|
||
goto quit;
|
||
}
|
||
|
||
if (IsNtDateFormat(*lpBuffer, *lpdwBufferLength)) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("format is NT\n"
|
||
));
|
||
|
||
*lpfnParserFunction = ParseNtDirectory;
|
||
success = TRUE;
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// we think the directory output is from Unix. The listing probably
|
||
// starts with "total #" or a number, or other random garbage. We
|
||
// know that a Unix dir listing starts with the ls attributes, so
|
||
// we'll search for those, but keep our search within a reasonable
|
||
// distance of the start
|
||
//
|
||
|
||
LPSTR buffer;
|
||
DWORD length;
|
||
char tokenBuffer[TOKEN_BUFFER_LENGTH];
|
||
int lengthChecked;
|
||
int iteration;
|
||
int dataLength;
|
||
|
||
buffer = *lpBuffer;
|
||
length = *lpdwBufferLength;
|
||
lengthChecked = 0;
|
||
iteration = 0;
|
||
dataLength = min((int)*lpdwBufferLength, RELATIVELY_SMALL_AMOUNT_OF_LS_DATA);
|
||
|
||
while (lengthChecked < dataLength) {
|
||
|
||
DWORD tokenLength;
|
||
DWORD previousLength;
|
||
|
||
tokenLength = sizeof(tokenBuffer);
|
||
if (!GetToken(buffer,
|
||
length,
|
||
tokenBuffer,
|
||
&tokenLength)) {
|
||
success = FALSE;
|
||
goto quit;
|
||
}
|
||
lengthChecked += tokenLength;
|
||
if (IsUnixAttributeFormat(tokenBuffer, tokenLength)) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("format is Unix\n"
|
||
));
|
||
|
||
*lpfnParserFunction = ParseUnixDirectory;
|
||
*lpBuffer = buffer;
|
||
*lpdwBufferLength = length;
|
||
success = TRUE;
|
||
goto quit;
|
||
} else if ((iteration == 0)
|
||
&& (tokenLength == 5)
|
||
&& !strnicmp(tokenBuffer, "total", 5)) {
|
||
|
||
//
|
||
// there may be nothing in the directory listing, except
|
||
// "total 0". If this is this case, then we recognize the
|
||
// format
|
||
//
|
||
|
||
buffer += tokenLength;
|
||
length -= tokenLength;
|
||
tokenLength = sizeof(tokenBuffer) - 1; // for '\0'
|
||
if (!GetToken(buffer,
|
||
length,
|
||
tokenBuffer,
|
||
&tokenLength)) {
|
||
success = FALSE;
|
||
goto quit;
|
||
}
|
||
tokenBuffer[tokenLength] = '\0';
|
||
if (isdigit(tokenBuffer[0]) && (atoi(tokenBuffer) == 0)) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("format is Unix - empty directory\n"
|
||
));
|
||
|
||
*lpfnParserFunction = ParseUnixDirectory;
|
||
SkipLine(&buffer, &length);
|
||
*lpBuffer = buffer;
|
||
*lpdwBufferLength = length;
|
||
success = TRUE;
|
||
goto quit;
|
||
}
|
||
}
|
||
|
||
//
|
||
// try the next line
|
||
//
|
||
|
||
previousLength = length;
|
||
SkipLine(&buffer, &length);
|
||
lengthChecked += previousLength - length;
|
||
++iteration;
|
||
}
|
||
|
||
//
|
||
// not NT or Unix. Lets try for OS/2. The format of an OS/2 directory entry
|
||
// is:
|
||
//
|
||
// [<ws>]<length>[DIR|<attribute>]<date><time><filename>
|
||
//
|
||
// we just try to parse the first line. If this succeeds, we assume OS/2
|
||
// format
|
||
//
|
||
|
||
WIN32_FIND_DATA findData;
|
||
PARSE_STATE state;
|
||
|
||
buffer = *lpBuffer;
|
||
length = *lpdwBufferLength;
|
||
state = ParseOs2Directory(&buffer, &length, &findData);
|
||
if ((state == State_Continue) || (state == State_Done)) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("format is OS/2\n"
|
||
));
|
||
|
||
success = TRUE;
|
||
*lpfnParserFunction = ParseOs2Directory;
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// Mac? Mac servers return Unix-like output which will (should) have already
|
||
// been handled by the Unix listing check, and a very simple format which
|
||
// just consists of names with an optional '/' appended, indicating a
|
||
// directory
|
||
//
|
||
|
||
//
|
||
// the Telnet 2.6 FTP server (which just reports the ultra-simple listing
|
||
// format) returns a weird 'hidden' entry at the start of the listing which
|
||
// consists of "\x03\x02\x01". We will skip all leading control characters
|
||
//
|
||
|
||
buffer = *lpBuffer;
|
||
length = *lpdwBufferLength;
|
||
while (length && (*buffer < ' ')) {
|
||
++buffer;
|
||
--length;
|
||
}
|
||
|
||
LPSTR buffer_;
|
||
DWORD length_;
|
||
|
||
buffer_ = buffer;
|
||
length_ = length;
|
||
|
||
state = ParseMacDirectory(&buffer, &length, &findData);
|
||
if ((state == State_Continue) || (state == State_Done)) {
|
||
|
||
DEBUG_PRINT(FTP,
|
||
INFO,
|
||
("format is Mac\n"
|
||
));
|
||
|
||
*lpBuffer = buffer_;
|
||
*lpdwBufferLength = length_;
|
||
success = TRUE;
|
||
*lpfnParserFunction = ParseMacDirectory;
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// failed to determine the format
|
||
//
|
||
|
||
success = FALSE;
|
||
|
||
quit:
|
||
|
||
DEBUG_LEAVE(success);
|
||
|
||
return success;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
IsNtDateFormat(
|
||
IN LPSTR lpBuffer,
|
||
IN DWORD dwBufferLength
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Determines if the directory listing starts with an NT-style date field:
|
||
|
||
MM-DD-YY
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to buffer containing listing
|
||
|
||
dwBufferLength - number of bytes in lpBuffer
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
TRUE - buffer starts with NT-style date format
|
||
|
||
FALSE - not NT-listing
|
||
|
||
--*/
|
||
|
||
{
|
||
if (dwBufferLength > 8) {
|
||
|
||
LPSTR buffer;
|
||
WORD number;
|
||
|
||
buffer = lpBuffer;
|
||
if (!ParseWord(&buffer, &dwBufferLength, 1, 12, &number)) {
|
||
return FALSE;
|
||
}
|
||
if (!((dwBufferLength > 0) && (*buffer == '-'))) {
|
||
return FALSE;
|
||
}
|
||
++buffer;
|
||
--dwBufferLength;
|
||
if (!ParseWord(&buffer, &dwBufferLength, 1, 31, &number)) {
|
||
return FALSE;
|
||
}
|
||
if (!((dwBufferLength > 0) && (*buffer == '-'))) {
|
||
return FALSE;
|
||
}
|
||
++buffer;
|
||
--dwBufferLength;
|
||
return ParseWord(&buffer, &dwBufferLength, 0, MAX_YEAR_SUPPORTED, &number);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
GetToken(
|
||
IN LPSTR lpszBuffer,
|
||
IN DWORD dwBufferLength,
|
||
OUT LPSTR lpszToken,
|
||
IN OUT LPDWORD lpdwTokenLength
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Copies a token out of the buffer without updating the buffer pointer or length
|
||
|
||
Arguments:
|
||
|
||
lpszBuffer - pointer to buffer to copy from
|
||
|
||
lpBufferLength - length of buffer
|
||
|
||
lpszToken - buffer to copy to
|
||
|
||
lpdwTokenLength - length of buffer on input, length of token on output
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
|
||
--*/
|
||
|
||
{
|
||
DWORD length;
|
||
|
||
if (!SkipSpaces(&lpszBuffer, &dwBufferLength)) {
|
||
return FALSE;
|
||
}
|
||
|
||
if (dwBufferLength == 0) {
|
||
return FALSE;
|
||
}
|
||
|
||
length = *lpdwTokenLength;
|
||
while (!isspace(*lpszBuffer) && (dwBufferLength != 0) && (length != 0)) {
|
||
*lpszToken++ = *lpszBuffer++;
|
||
--dwBufferLength;
|
||
--length;
|
||
}
|
||
*lpdwTokenLength -= length;
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
IsUnixAttributeFormat(
|
||
IN LPSTR lpBuffer,
|
||
IN DWORD dwBufferLength
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Checks if the buffer contains a Unix ls attribute field format
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to buffer containing token to check
|
||
|
||
dwBufferLength - length of buffer
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
TRUE - lpBuffer *probably* contained a Unix attribute field
|
||
FALSE - lpBuffer *probably didn't* contain a Unix attribute field
|
||
|
||
--*/
|
||
|
||
{
|
||
int i;
|
||
int hits;
|
||
|
||
if (dwBufferLength != 10) {
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// the first character contains 'd' for directory, 'l' for link, '-' for
|
||
// file, and may contain other, unspecified characters, so we just ignore
|
||
// it. So long as the next 9 characters are in the set [-rwx] then we have
|
||
// a Unix ls attribute field.
|
||
//
|
||
// N.B. it turns out that the first character can be in the set [-bcdlp]
|
||
// and the attribute characters can be in the set [-lrsStTwx] (as of
|
||
// 08/18/95)
|
||
//
|
||
|
||
++lpBuffer;
|
||
hits = 0;
|
||
for (i = 0; i < 9; ++i) {
|
||
|
||
char ch;
|
||
|
||
ch = tolower(*lpBuffer);
|
||
++lpBuffer;
|
||
|
||
if ((ch == '-')
|
||
|| (ch == 'l')
|
||
|| (ch == 'r')
|
||
|| (ch == 's')
|
||
|| (ch == 't')
|
||
|| (ch == 'w')
|
||
|| (ch == 'x')) {
|
||
++hits;
|
||
}
|
||
}
|
||
|
||
//
|
||
// new scheme: we decide if the token was a Unix attribute field based on
|
||
// probability. If the hit rate was greater than 1 in 2 (5 out of 9 or
|
||
// higher) then we say that the field was probably a Unix attribute. This
|
||
// scheme allows us to accept future enhancements or non-standard Unix
|
||
// implementations without changing this code (for a while) (Make the
|
||
// attribute set a registry value (!))
|
||
//
|
||
|
||
return hits >= 5;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseNtDirectory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Parses a single line of an NT directory listing (output from DIR) into a
|
||
WIN32_FIND_DATA structure
|
||
|
||
The format of an NT directory list line is:
|
||
|
||
<date> <time> <'<DIR>'|<size>> <filename>
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to directory listing
|
||
|
||
lpBufferLength - pointer to number of bytes remaining in lpBuffer
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
PARSE_STATE
|
||
State_Continue - more listing to parse
|
||
|
||
State_Done - fin!
|
||
|
||
--*/
|
||
|
||
{
|
||
//
|
||
// not expecting the line to start with spaces, but we check anyway
|
||
//
|
||
|
||
if (!SkipSpaces(lpBuffer, lpBufferLength)) {
|
||
goto done;
|
||
}
|
||
|
||
if (!ExtractNtDate(lpBuffer, lpBufferLength, lpFindData)) {
|
||
goto done;
|
||
}
|
||
|
||
if (!strnicmp(*lpBuffer, "<DIR>", 5)) {
|
||
lpFindData->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
||
lpFindData->nFileSizeHigh = 0;
|
||
lpFindData->nFileSizeLow = 0;
|
||
FindToken(lpBuffer, lpBufferLength);
|
||
} else {
|
||
lpFindData->dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
|
||
ExtractFileSize(lpBuffer, lpBufferLength, lpFindData);
|
||
SkipSpaces(lpBuffer, lpBufferLength);
|
||
}
|
||
|
||
_ExtractFilename(lpBuffer, lpBufferLength, lpFindData);
|
||
|
||
//
|
||
// we expect the filename to be the last thing on the line
|
||
//
|
||
|
||
done:
|
||
|
||
return SkipLine(lpBuffer, lpBufferLength) ? State_Continue : State_Done;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
void
|
||
ReadUnixPermissions(
|
||
IN LPCSTR pszBuffer,
|
||
IN DWORD cbBufferSize,
|
||
OUT LPDWORD pdwPermissions)
|
||
{
|
||
// Format: rwxrwxrwx <Owner><Group><All>
|
||
*pdwPermissions = 0;
|
||
|
||
if (cbBufferSize > 10)
|
||
{
|
||
if ('r' == pszBuffer[1])
|
||
*pdwPermissions |= 0x00000400;
|
||
|
||
if ('w' == pszBuffer[2])
|
||
*pdwPermissions |= 0x00000200;
|
||
|
||
if ('x' == pszBuffer[3])
|
||
*pdwPermissions |= 0x00000100;
|
||
|
||
if ('r' == pszBuffer[4])
|
||
*pdwPermissions |= 0x00000040;
|
||
|
||
if ('w' == pszBuffer[5])
|
||
*pdwPermissions |= 0x00000020;
|
||
|
||
if ('x' == pszBuffer[6])
|
||
*pdwPermissions |= 0x00000010;
|
||
|
||
if ('r' == pszBuffer[7])
|
||
*pdwPermissions |= 0x00000004;
|
||
|
||
if ('w' == pszBuffer[8])
|
||
*pdwPermissions |= 0x00000002;
|
||
|
||
if ('x' == pszBuffer[9])
|
||
*pdwPermissions |= 0x00000001;
|
||
}
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseUnixDirectory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Parses a single line of a Unix directory listing (output from ls) into a
|
||
WIN32_FIND_DATA structure
|
||
|
||
The format of a Unix directory list line is:
|
||
|
||
<attributes> <link-count> <owner> <group> <size> <date-time> <filename>
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to directory listing
|
||
|
||
lpBufferLength - pointer to number of bytes remaining in lpBuffer
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
PARSE_STATE
|
||
State_Continue - more listing to parse
|
||
|
||
State_Done - fin!
|
||
|
||
--*/
|
||
|
||
{
|
||
DWORD error;
|
||
int i;
|
||
BOOL symbolicLink;
|
||
char ch;
|
||
|
||
//
|
||
// not expecting the line to start with spaces, but we check anyway
|
||
//
|
||
|
||
if (!SkipSpaces(lpBuffer, lpBufferLength)) {
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// if the item is a symbolic link then we have to trim the 'filename' below
|
||
//
|
||
|
||
ch = tolower(**lpBuffer);
|
||
symbolicLink = (ch == 'l');
|
||
|
||
//
|
||
// attributes are first thing on line
|
||
//
|
||
|
||
lpFindData->dwFileAttributes = (ch == 'd') ? FILE_ATTRIBUTE_DIRECTORY
|
||
: (ch == '-') ? FILE_ATTRIBUTE_NORMAL
|
||
: 0;
|
||
|
||
//
|
||
// skip over the attributes and over the owner/creator fields to the file
|
||
// size
|
||
//
|
||
|
||
// Read the Attributes and put them in the WIN32_FIND_DATA.dwReserved0 attributes.
|
||
// It's OK to use FILE_ATTRIBUTE_REPARSE_POINT because it's unused unless
|
||
// WIN32_FIND_DATA.dwFileAttributes contains yyy, which we don't set.
|
||
ReadUnixPermissions(*lpBuffer, *lpBufferLength, &(lpFindData->dwReserved0));
|
||
|
||
LPSTR lpszLastToken;
|
||
DWORD dwLastToken;
|
||
|
||
for (i = 0; i < 4; ++i) {
|
||
lpszLastToken = *lpBuffer;
|
||
dwLastToken = *lpBufferLength;
|
||
if (!FindToken(lpBuffer, lpBufferLength)) {
|
||
goto done;
|
||
}
|
||
}
|
||
|
||
if (!ExtractFileSize(lpBuffer, lpBufferLength, lpFindData)) {
|
||
ExtractFileSize(&lpszLastToken, &dwLastToken, lpFindData);
|
||
}
|
||
|
||
SkipSpaces(lpBuffer, lpBufferLength);
|
||
|
||
if (!ExtractUnixDate(lpBuffer, lpBufferLength, lpFindData)) {
|
||
goto done;
|
||
}
|
||
|
||
SkipSpaces(lpBuffer, lpBufferLength);
|
||
|
||
//
|
||
// we expect the filename to be the last thing on the line
|
||
//
|
||
|
||
_ExtractFilename(lpBuffer, lpBufferLength, lpFindData);
|
||
|
||
//
|
||
// if the item is a symbolic link, then remove everything after the " -> "
|
||
//
|
||
|
||
if (symbolicLink) {
|
||
|
||
LPSTR lpArrow;
|
||
|
||
lpArrow = strstr(lpFindData->cFileName, " -> ");
|
||
if (lpArrow != NULL) {
|
||
*lpArrow = '\0';
|
||
}
|
||
}
|
||
|
||
done:
|
||
|
||
return SkipLine(lpBuffer, lpBufferLength) ? State_Continue : State_Done;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseOs2Directory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Parses a single line of an OS/2 directory listing (output from dir) into a
|
||
WIN32_FIND_DATA structure
|
||
|
||
The format of an OS/2 directory list line is:
|
||
|
||
<size> <attributes> <date> <time> <filename>
|
||
|
||
This function is also used to determine OS/2 directory format
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to directory listing
|
||
|
||
lpBufferLength - pointer to number of bytes remaining in lpBuffer
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
PARSE_STATE
|
||
State_Continue - more listing to parse
|
||
|
||
State_Done - fin!
|
||
|
||
State_Error - directory format not recognized
|
||
--*/
|
||
|
||
{
|
||
PARSE_STATE state;
|
||
|
||
if (!SkipSpaces(lpBuffer, lpBufferLength)) {
|
||
goto skip;
|
||
}
|
||
|
||
if (!ExtractFileSize(lpBuffer, lpBufferLength, lpFindData)) {
|
||
state = State_Error;
|
||
goto done;
|
||
}
|
||
|
||
if (!SkipSpaces(lpBuffer, lpBufferLength)) {
|
||
goto skip;
|
||
}
|
||
|
||
if (!strnicmp(*lpBuffer, "DIR", 3)) {
|
||
lpFindData->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
||
FindToken(lpBuffer, lpBufferLength);
|
||
} else if (!isdigit(**lpBuffer)) {
|
||
if (!ExtractOs2Attributes(lpBuffer, lpBufferLength, lpFindData)) {
|
||
state = State_Error;
|
||
goto done;
|
||
}
|
||
SkipSpaces(lpBuffer, lpBufferLength);
|
||
} else {
|
||
lpFindData->dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
|
||
}
|
||
|
||
if (!ExtractNtDate(lpBuffer, lpBufferLength, lpFindData)) {
|
||
state = State_Error;
|
||
goto done;
|
||
}
|
||
|
||
_ExtractFilename(lpBuffer, lpBufferLength, lpFindData);
|
||
|
||
//
|
||
// we expect the filename to be the last thing on the line
|
||
//
|
||
|
||
skip:
|
||
|
||
state = SkipLine(lpBuffer, lpBufferLength) ? State_Continue : State_Done;
|
||
|
||
done:
|
||
|
||
return state;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
PARSE_STATE
|
||
ParseMacDirectory(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Parses a single line of a Mac directory listing (output from ls) into a
|
||
WIN32_FIND_DATA structure
|
||
|
||
The format of a Mac directory list line is:
|
||
|
||
<dir-or-file-name>[/]
|
||
|
||
This function is also used to determine Mac directory format
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to directory listing
|
||
|
||
lpBufferLength - pointer to number of bytes remaining in lpBuffer
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
PARSE_STATE
|
||
State_Continue - more listing to parse
|
||
|
||
State_Done - fin!
|
||
|
||
State_Error - directory format not recognized
|
||
|
||
--*/
|
||
|
||
{
|
||
PARSE_STATE state;
|
||
|
||
if (!SkipSpaces(lpBuffer, lpBufferLength)) {
|
||
goto skip;
|
||
}
|
||
|
||
_ExtractFilename(lpBuffer, lpBufferLength, lpFindData);
|
||
|
||
int len;
|
||
|
||
len = lstrlen(lpFindData->cFileName);
|
||
if (lpFindData->cFileName[len - 1] == '/') {
|
||
lpFindData->cFileName[len - 1] = '\0';
|
||
lpFindData->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
|
||
} else {
|
||
lpFindData->dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
|
||
}
|
||
if ((*lpBufferLength != 0)
|
||
&& !((**lpBuffer == '\r') || (**lpBuffer == '\n'))) {
|
||
state = State_Error;
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// this directory format has no size or time information
|
||
//
|
||
|
||
lpFindData->nFileSizeLow = 0;
|
||
lpFindData->nFileSizeHigh = 0;
|
||
SystemTimeToFileTime(&DefaultSystemTime, &lpFindData->ftLastWriteTime);
|
||
|
||
//
|
||
// we expect the filename to be the last thing on the line
|
||
//
|
||
|
||
skip:
|
||
|
||
state = SkipLine(lpBuffer, lpBufferLength) ? State_Continue : State_Done;
|
||
|
||
done:
|
||
|
||
return state;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractFileSize(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Extracts the the next token in the directory listing. The next token is
|
||
expected to be the file size. It is extracted to the WIN32_FIND_DATA
|
||
structure
|
||
|
||
Assumes: 1. The file size is <= 32 bits
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to directory listing buffer
|
||
|
||
lpBufferLength - pointer to remaining buffer length
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
|
||
--*/
|
||
|
||
{
|
||
INET_ASSERT(*lpBufferLength != 0);
|
||
|
||
LPSTR buffer;
|
||
char ch = **lpBuffer;
|
||
|
||
if (isdigit(ch)) {
|
||
lpFindData->nFileSizeLow = strtoul(*lpBuffer, &buffer, 10);
|
||
lpFindData->nFileSizeHigh = 0;
|
||
*lpBufferLength -= (DWORD) (buffer - *lpBuffer);
|
||
*lpBuffer = buffer;
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
_ExtractFilename(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Extracts the filename from the current directory listing position into the
|
||
WIN32_FIND_DATA structure
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to directory listing buffer
|
||
|
||
lpBufferLength - pointer to remaining buffer length
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
|
||
--*/
|
||
|
||
{
|
||
LPSTR dest;
|
||
DWORD destLength;
|
||
|
||
dest = lpFindData->cFileName;
|
||
destLength = sizeof(lpFindData->cFileName) - 1;
|
||
while ((*lpBufferLength != 0)
|
||
&& (destLength != 0)
|
||
&& !((**lpBuffer == '\r') || (**lpBuffer == '\n'))) {
|
||
*dest++ = *(*lpBuffer)++;
|
||
--*lpBufferLength;
|
||
--destLength;
|
||
}
|
||
*dest = '\0';
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractNtDate(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Extracts an NT date and time from the directory listing. NT dates have a
|
||
specific format:
|
||
|
||
MM-DD-YY hh:mmPP
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to current position in directory list
|
||
|
||
lpBufferLength - number of bytes til end of directory list
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE
|
||
|
||
--*/
|
||
|
||
{
|
||
SYSTEMTIME systemTime;
|
||
LPSTR buffer;
|
||
DWORD buflen;
|
||
int number;
|
||
LPSTR stop;
|
||
LPSYSTEMTIME lpSystemTime;
|
||
|
||
lpSystemTime = &DefaultSystemTime;
|
||
|
||
//
|
||
// BUGBUG - what about internationalization? E.g. does UK FTP server return
|
||
// the date as e.g. 27/07/95? Other formats?
|
||
//
|
||
|
||
//
|
||
// month ::= 1..12
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 1, 12, &systemTime.wMonth)) {
|
||
goto done;
|
||
}
|
||
if (!((*lpBufferLength > 0) && (**lpBuffer == '-'))) {
|
||
goto done;
|
||
}
|
||
++*lpBuffer;
|
||
--*lpBufferLength;
|
||
|
||
//
|
||
// date ::= 1..31
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 1, 31, &systemTime.wDay)) {
|
||
goto done;
|
||
}
|
||
if (!((*lpBufferLength > 0) && (**lpBuffer == '-'))) {
|
||
goto done;
|
||
}
|
||
++*lpBuffer;
|
||
--*lpBufferLength;
|
||
|
||
//
|
||
// year ::= 0..2100
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 0, MAX_YEAR_SUPPORTED, &systemTime.wYear)) {
|
||
goto done;
|
||
}
|
||
if (!((*lpBufferLength > 0) && (**lpBuffer == ' '))) {
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// the oldest file can be dated 1980. We allow the following:
|
||
//
|
||
// 1-1-79 => 1-1-2079
|
||
// 1-1-80..12-31-99 => 1-1-1980..12-31-1999
|
||
// 1-1-00 => 1-1-2000
|
||
// 1-1-1995 => 1-1-1995
|
||
// 1-1-2001 => 1-1-2001
|
||
// etc.
|
||
//
|
||
|
||
systemTime.wYear += (systemTime.wYear < 80)
|
||
? 2000
|
||
: (systemTime.wYear <= 99)
|
||
? 1900
|
||
: 0
|
||
;
|
||
|
||
//
|
||
// find start of time (er, Professor Hawking..?)
|
||
//
|
||
|
||
if (!FindToken(lpBuffer, lpBufferLength)) {
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// hour ::= 0..23 | 1..12
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 0, 23, &systemTime.wHour)) {
|
||
goto done;
|
||
}
|
||
if (!((*lpBufferLength > 0) && (**lpBuffer == ':'))) {
|
||
goto done;
|
||
}
|
||
++*lpBuffer;
|
||
--*lpBufferLength;
|
||
|
||
//
|
||
// minute ::= 0..59
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 0, 59, &systemTime.wMinute)) {
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// if the time is followed by AM or PM then convert to 24-hour time if PM
|
||
// and skip to end of token in both cases
|
||
//
|
||
|
||
if (*lpBufferLength >= 2) {
|
||
|
||
char ch_p;
|
||
|
||
ch_p = tolower(**lpBuffer);
|
||
if ((ch_p == 'p') || (ch_p == 'a')) {
|
||
|
||
char ch_m;
|
||
|
||
ch_m = tolower(*(*lpBuffer + 1));
|
||
if ((ch_p == 'p') && (ch_m == 'm')) {
|
||
// 12 PM = 12, 1PM = 13, 2PM = 14, etc
|
||
if ( systemTime.wHour < 12 ) {
|
||
systemTime.wHour += 12;
|
||
}
|
||
} else if ( systemTime.wHour == 12 ) {
|
||
// 12 AM == 0:00 24hr
|
||
INET_ASSERT((ch_p == 'a') && (ch_m == 'm'));
|
||
systemTime.wHour = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// seconds, milliseconds and weekday always zero
|
||
//
|
||
|
||
systemTime.wSecond = 0;
|
||
systemTime.wMilliseconds = 0;
|
||
systemTime.wDayOfWeek = 0;
|
||
|
||
//
|
||
// get ready to convert the parsed date/time to a FILETIME
|
||
//
|
||
|
||
lpSystemTime = &systemTime;
|
||
|
||
done:
|
||
|
||
//
|
||
// convert the system time to file time and move the buffer pointer/length
|
||
// to the next line
|
||
//
|
||
|
||
if (!SystemTimeToFileTime(lpSystemTime, &lpFindData->ftLastWriteTime)) {
|
||
SystemTimeToFileTime(&DefaultSystemTime, &lpFindData->ftLastWriteTime);
|
||
}
|
||
FindToken(lpBuffer, lpBufferLength);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractUnixDate(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Extracts a Unix date and time from the directory listing. Unix dates have a
|
||
multitude of formats:
|
||
|
||
Jul 3 14:52
|
||
Oct 7 1994
|
||
Jul 26 4:05
|
||
Jul 26 03:51
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to current position in directory list
|
||
|
||
lpBufferLength - number of bytes til end of directory list
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE
|
||
|
||
--*/
|
||
|
||
{
|
||
SYSTEMTIME systemTime;
|
||
LPSYSTEMTIME lpSystemTime;
|
||
static LPSTR Months = "janfebmaraprmayjunjulaugsepoctnovdec";
|
||
char monthStr[4];
|
||
int i;
|
||
LPSTR offset;
|
||
WORD wnum;
|
||
|
||
lpSystemTime = &DefaultSystemTime;
|
||
|
||
//
|
||
// month ::= Jan..Dec
|
||
//
|
||
|
||
for (i = 0; i < 3; ++i) {
|
||
if (*lpBufferLength == 0) {
|
||
goto done;
|
||
}
|
||
monthStr[i] = *(*lpBuffer)++;
|
||
monthStr[i] = tolower(monthStr[i]);
|
||
--*lpBufferLength;
|
||
}
|
||
monthStr[i] = '\0';
|
||
offset = strstr(Months, monthStr);
|
||
if (offset == NULL) {
|
||
goto done;
|
||
}
|
||
systemTime.wMonth = (unsigned short) ((offset-Months) / 3 + 1);
|
||
|
||
FindToken(lpBuffer, lpBufferLength);
|
||
|
||
//
|
||
// date ::= 1..31
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 1, 31, &systemTime.wDay)) {
|
||
goto done;
|
||
}
|
||
|
||
SkipSpaces(lpBuffer, lpBufferLength);
|
||
|
||
//
|
||
// year or hour
|
||
//
|
||
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 0, 65535, &wnum)) {
|
||
goto done;
|
||
}
|
||
|
||
if ((*lpBufferLength != 0) && (**lpBuffer == ':')) {
|
||
|
||
SYSTEMTIME timeNow;
|
||
|
||
systemTime.wHour = wnum;
|
||
|
||
//
|
||
// we found the hour field, now get the minutes
|
||
//
|
||
|
||
++*lpBuffer;
|
||
--*lpBufferLength;
|
||
if (!ParseWord(lpBuffer, lpBufferLength, 0, 59, &systemTime.wMinute)) {
|
||
goto done;
|
||
}
|
||
|
||
//
|
||
// a date-time with an hour:minute field is based in this year. We need
|
||
// to get the current year from the system. There is a slight problem in
|
||
// that if this machine's just had a new year and the FTP server is
|
||
// behind us, then the file can be a year out of date.
|
||
//
|
||
// There is no guarantees about the basis of time used by the FTP server,
|
||
// so we'll get the UTC (aka Greenwich Mean Time) time
|
||
//
|
||
|
||
GetSystemTime(&timeNow);
|
||
systemTime.wYear = timeNow.wYear;
|
||
|
||
if(!GlobalBypassFtpTimeCheck)
|
||
{
|
||
//
|
||
// apparently its not quite as straightforward as first we'd believed.
|
||
// If the date/month is in the future then the year is last year
|
||
//
|
||
|
||
BOOL bLastYear = FALSE;
|
||
|
||
if (systemTime.wMonth > timeNow.wMonth) {
|
||
bLastYear = TRUE;
|
||
} else if (systemTime.wMonth == timeNow.wMonth) {
|
||
|
||
//
|
||
// BUGBUG - leap year? I believe that in this case, because the time
|
||
// difference is 1 year minus 1 day, then that is great
|
||
// enough for the date format including year to have been
|
||
// used and thus making this moot. Need to prove it.
|
||
// Note, by that logic, everything from here on down should
|
||
// also be moot - we should only have to concern ourselves
|
||
// with the month
|
||
//
|
||
|
||
if (systemTime.wDay > timeNow.wDay) {
|
||
bLastYear = TRUE;
|
||
} else if (systemTime.wDay == timeNow.wDay) {
|
||
if (systemTime.wHour > timeNow.wHour) {
|
||
bLastYear = TRUE;
|
||
} else if (systemTime.wHour == timeNow.wHour) {
|
||
if (systemTime.wMinute > timeNow.wMinute) {
|
||
bLastYear = TRUE;
|
||
} else if (systemTime.wMinute == timeNow.wMinute) {
|
||
if (systemTime.wSecond > timeNow.wSecond) {
|
||
bLastYear = TRUE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (bLastYear) {
|
||
--systemTime.wYear;
|
||
}
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// next field is the year
|
||
//
|
||
|
||
systemTime.wYear = wnum;
|
||
|
||
//
|
||
// time for a file with only a year is 00:00 (mitternacht)
|
||
//
|
||
|
||
systemTime.wHour = 0;
|
||
systemTime.wMinute = 0;
|
||
}
|
||
|
||
//
|
||
// seconds, milliseconds and weekday always zero
|
||
//
|
||
|
||
systemTime.wSecond = 0;
|
||
systemTime.wMilliseconds = 0;
|
||
systemTime.wDayOfWeek = 0;
|
||
|
||
//
|
||
// get ready to convert the parsed date/time to a FILETIME
|
||
//
|
||
|
||
lpSystemTime = &systemTime;
|
||
|
||
done:
|
||
|
||
//
|
||
// convert the system time to file time and move the buffer pointer/length
|
||
// to the next line
|
||
//
|
||
|
||
if (!SystemTimeToFileTime(lpSystemTime, &lpFindData->ftLastWriteTime)) {
|
||
SystemTimeToFileTime(&DefaultSystemTime, &lpFindData->ftLastWriteTime);
|
||
}
|
||
FindToken(lpBuffer, lpBufferLength);
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractOs2Attributes(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN OUT LPWIN32_FIND_DATA lpFindData
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Converts an OS/2 attribute string into Win32 file attribute flags in the
|
||
WIN32_FIND_DATA structure
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to current position in directory list
|
||
|
||
lpBufferLength - number of bytes til end of directory list
|
||
|
||
lpFindData - pointer to WIN32_FIND_DATA to update
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE
|
||
|
||
--*/
|
||
|
||
{
|
||
DWORD attributes = 0;
|
||
BOOL done = FALSE;
|
||
|
||
while (*lpBufferLength && !done) {
|
||
|
||
char ch = **lpBuffer;
|
||
|
||
switch (toupper(ch)) {
|
||
case 'A':
|
||
attributes |= FILE_ATTRIBUTE_ARCHIVE;
|
||
break;
|
||
|
||
case 'H':
|
||
attributes |= FILE_ATTRIBUTE_HIDDEN;
|
||
break;
|
||
|
||
case 'R':
|
||
attributes |= FILE_ATTRIBUTE_READONLY;
|
||
break;
|
||
|
||
case 'S':
|
||
attributes |= FILE_ATTRIBUTE_SYSTEM;
|
||
break;
|
||
|
||
case ' ':
|
||
|
||
//
|
||
// if there is only one space, we will be pointing at the next token
|
||
// after this function completes. Okay so long as we will be calling
|
||
// SkipSpaces() next (which doesn't expect to be pointing at a space)
|
||
//
|
||
|
||
done = TRUE;
|
||
break;
|
||
}
|
||
--*lpBufferLength;
|
||
++*lpBuffer;
|
||
}
|
||
|
||
//
|
||
// if we are here there must have been some characters which looked like
|
||
// OS/2 file attributes
|
||
//
|
||
|
||
INET_ASSERT(attributes != 0);
|
||
|
||
lpFindData->dwFileAttributes = attributes;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ParseWord(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
IN WORD LowerBound,
|
||
IN WORD UpperBound,
|
||
OUT LPWORD lpNumber
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Extract a WORD value out of the buffer. To be correctly parsed the number
|
||
field must:
|
||
|
||
* start with numeric characters
|
||
* not be negative
|
||
* be >= LowerBound and <= UpperBound
|
||
* must end with a non-numeric character or when the buffer is exhausted
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to buffer containing number to parse
|
||
|
||
lpBufferLength - pointer to remaining length in buffer
|
||
|
||
LowerBound - lowest value converted number can have
|
||
|
||
UpperBound - highest value converted number can have
|
||
|
||
lpNumber - pointer to returned WORD value
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE
|
||
|
||
--*/
|
||
|
||
{
|
||
int number;
|
||
|
||
if (ExtractInteger(lpBuffer, lpBufferLength, &number)) {
|
||
if ((number >= (int)LowerBound) && (number <= (int)UpperBound)) {
|
||
*lpNumber = (WORD)number;
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
PRIVATE
|
||
BOOL
|
||
ExtractInteger(
|
||
IN OUT LPSTR* lpBuffer,
|
||
IN OUT LPDWORD lpBufferLength,
|
||
OUT LPINT lpNumber
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Performs a strtoul type function, but the input string is not terminated by
|
||
\0. It has an associated length
|
||
|
||
Arguments:
|
||
|
||
lpBuffer - pointer to pointer to string containing number to extract
|
||
|
||
lpBufferLength - pointer to length of string remaining in lpBuffer
|
||
|
||
lpNumber - pointer to returned value
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOL success;
|
||
int number;
|
||
|
||
number = 0;
|
||
if ((*lpBufferLength > 0) && isdigit(**lpBuffer)) {
|
||
while (isdigit(**lpBuffer) && (*lpBufferLength != 0)) {
|
||
number = number * 10 + (int)(**lpBuffer - '0');
|
||
++*lpBuffer;
|
||
--*lpBufferLength;
|
||
}
|
||
success = TRUE;
|
||
} else {
|
||
success = FALSE;
|
||
}
|
||
*lpNumber = number;
|
||
return success;
|
||
}
|