1497 lines
46 KiB
C++
1497 lines
46 KiB
C++
/*++
|
||
|
||
Copyright (c) 1995 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
readhtml.cxx
|
||
|
||
Abstract:
|
||
|
||
Contains functions for returning files and directory listings (gopher and
|
||
FTP) as HTML documents
|
||
|
||
Contents:
|
||
ReadHtmlUrlData
|
||
QueryHtmlDataAvailable
|
||
(MakeHtmlDirEntry)
|
||
|
||
Author:
|
||
|
||
Richard L Firth (rfirth) 23-Jun-1995
|
||
|
||
Environment:
|
||
|
||
Win32 user-mode
|
||
|
||
Revision History:
|
||
|
||
23-Jun-1995 rfirth
|
||
Created
|
||
|
||
--*/
|
||
|
||
#include <wininetp.h>
|
||
|
||
//
|
||
// private manifests
|
||
//
|
||
|
||
//
|
||
// HTML encapsulation strings - we generate HTML documents using the following
|
||
// strings. Although we don't need carriage-return, line-feed at the end of each
|
||
// line, we add them anyway since it allows View Source and Save As commands in
|
||
// the viewer to create human-sensible documents
|
||
//
|
||
|
||
//
|
||
// HTML_DOCUMENT_HEADER - every HTML document should have a header. It must have
|
||
// a title. This string defines the header, title and start of the document body
|
||
//
|
||
|
||
#define HTML_DOCUMENT_HEADER "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\">\r\n" \
|
||
"<HTML>\r\n" \
|
||
"<HEAD>\r\n" \
|
||
"<TITLE>%s</TITLE>\r\n" \
|
||
"</HEAD>\r\n" \
|
||
"<BODY>\r\n" \
|
||
"<H2>%s</H2>\r\n"
|
||
|
||
#ifdef EXTENDED_ERROR_HTML
|
||
|
||
//
|
||
// HTML_ERROR_DOCUMENT_HEADER - error variant of standard document header
|
||
//
|
||
|
||
#define HTML_ERROR_DOCUMENT_HEADER "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\">\r\n" \
|
||
"<HTML>\r\n" \
|
||
"<HEAD>\r\n" \
|
||
"<TITLE>%s</TITLE>\r\n" \
|
||
"</HEAD>\r\n" \
|
||
"<BODY>\r\n" \
|
||
"<H2>%s</H2>\r\n" \
|
||
"<HR>\r\n"
|
||
|
||
#endif
|
||
|
||
//
|
||
// HTML_DOCUMENT_PREFORMAT - directory entries are preformatted to stop the HTML
|
||
// viewer putting its own interpretation on the listing
|
||
//
|
||
|
||
#define HTML_DOCUMENT_PREFORMAT "<PRE>\r\n"
|
||
|
||
//
|
||
// HTML_DOCUMENT_END_PREFORMAT - this is required after the last directory entry
|
||
// to allow the viewer to resume HTML formatting
|
||
//
|
||
|
||
#define HTML_DOCUMENT_END_PREFORMAT "</PRE>\r\n"
|
||
|
||
//
|
||
// HTML_HORIZONTAL_RULE - we separate each part of the document with a horizontal
|
||
// rule line
|
||
//
|
||
|
||
#define HTML_HORIZONTAL_RULE "<HR>\r\n"
|
||
|
||
//
|
||
// HTML_FTP_WELCOME_START - for FTP directories, we display the FTP welcome
|
||
// message
|
||
//
|
||
|
||
#define HTML_FTP_WELCOME_START HTML_HORIZONTAL_RULE \
|
||
"<H4><PRE>\r\n"
|
||
|
||
//
|
||
// HTML_FTP_WELCOME_END - finish off at end of FTP welcome message
|
||
//
|
||
|
||
#define HTML_FTP_WELCOME_END "</PRE></H4>\r\n"
|
||
|
||
//
|
||
// HTML_DOCUMENT_DIR_START - when creating a directory listing document, we
|
||
// follow the header with a Horizontal Rule (<HR>)
|
||
//
|
||
|
||
#define HTML_DOCUMENT_DIR_START HTML_HORIZONTAL_RULE \
|
||
HTML_DOCUMENT_PREFORMAT
|
||
|
||
//
|
||
// HTML_DOCUMENT_FTP_DIR_START - same as HTML_DOCUMENT_DIR_START, but used to
|
||
// add an additional "back up one level" if FTP and not the root
|
||
//
|
||
|
||
#define HTML_DOCUMENT_FTP_DIR_START HTML_HORIZONTAL_RULE \
|
||
"%s" \
|
||
HTML_DOCUMENT_PREFORMAT
|
||
|
||
//
|
||
// HTML_DOCUMENT_DIR_END - string that appears at the end of the preformatted
|
||
// directory list, but before the end of the document
|
||
//
|
||
|
||
#define HTML_DOCUMENT_DIR_END HTML_DOCUMENT_END_PREFORMAT \
|
||
HTML_HORIZONTAL_RULE
|
||
|
||
//
|
||
// HTML_ISINDEX - string that causes browser to display search form
|
||
//
|
||
#define HTML_ISINDEX "<ISINDEX>"
|
||
|
||
//
|
||
// HTML_DOCUMENT_FOOTER - this goes at the end of every HTML document we create
|
||
//
|
||
|
||
#define HTML_DOCUMENT_FOOTER "</BODY>\r\n" \
|
||
"</HTML>\r\n"
|
||
|
||
//
|
||
// HTML_DOCUMENT_DIR_ENTRY - each directory entry is formatted using the
|
||
// following string. Directories are bold
|
||
//
|
||
|
||
#define HTML_DOCUMENT_DIR_ENTRY "%s %s <A HREF=\"%s\"><B>%s</B></A>\r\n"
|
||
|
||
//
|
||
// HTML_DOCUMENT_FILE_ENTRY - same as HTML_DOCUMENT_DIR_ENTRY, except link is
|
||
// not bold
|
||
//
|
||
|
||
#define HTML_DOCUMENT_FILE_ENTRY "%s %s <A HREF=\"%s\">%s</A>\r\n"
|
||
|
||
#define SCRATCH_PAD_SIZE 1024
|
||
|
||
#define FTP_WELCOME_INTRO "230-"
|
||
#define FTP_WELCOME_INTRO_LENGTH (sizeof(FTP_WELCOME_INTRO) - 1)
|
||
|
||
#define MAX_FMT_BUF 200 // size of buffer for loading title format string resource
|
||
char szDir[32];
|
||
char szSearch[32];
|
||
|
||
//
|
||
// private prototypes
|
||
//
|
||
|
||
PRIVATE
|
||
DWORD
|
||
MakeHtmlDirEntry(
|
||
IN HINTERNET_HANDLE_TYPE HandleType,
|
||
IN LPSTR PathPrefix,
|
||
IN LPVOID DirBuffer,
|
||
IN LPBYTE EntryBuffer,
|
||
IN OUT LPDWORD BufferLength,
|
||
OUT LPSTR* DirEntry
|
||
);
|
||
|
||
//
|
||
// functions
|
||
//
|
||
|
||
|
||
BOOL
|
||
ReadHtmlUrlData(
|
||
IN HINTERNET hInternet,
|
||
IN LPVOID lpBuffer,
|
||
IN DWORD dwBufferLength,
|
||
OUT LPDWORD lpdwBytesReturned
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Converts an FTP or gopher file or directory listing to a HTML document. This
|
||
function is a wrapper for InternetReadFile() and InternetFindNext(), and so
|
||
returns BOOL: the error code proper is set by the appropriate API
|
||
|
||
Arguments:
|
||
|
||
hInternet - handle of file or find object
|
||
|
||
lpBuffer - pointer to caller's buffer
|
||
|
||
dwBufferLength - size of lpBuffer on input
|
||
|
||
lpdwBytesReturned - pointer to returned number of bytes read into lpBuffer
|
||
|
||
Return Value:
|
||
|
||
BOOL
|
||
Success - TRUE
|
||
|
||
Failure - FALSE. Call GetLastError() for more info
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_INET,
|
||
Bool,
|
||
"ReadHtmlUrlData",
|
||
"%#x, %#x, %d, %#x",
|
||
hInternet,
|
||
lpBuffer,
|
||
dwBufferLength,
|
||
lpdwBytesReturned
|
||
));
|
||
|
||
DWORD error;
|
||
HINTERNET_HANDLE_TYPE handleType;
|
||
BOOL success;
|
||
LPSTR url;
|
||
DWORD charsCopied;
|
||
LPBYTE buffer;
|
||
BYTE dirBuffer[max(sizeof(WIN32_FIND_DATA), sizeof(GOPHER_FIND_DATA))];
|
||
BOOL done;
|
||
HTML_STATE htmlState;
|
||
HTML_STATE previousHtmlState;
|
||
BYTE scratchPad[SCRATCH_PAD_SIZE];
|
||
BOOL dataCopied;
|
||
LPSTR lastDirEntry;
|
||
LPSTR urlCopy;
|
||
|
||
//
|
||
// initialize variables in case we quit early
|
||
//
|
||
|
||
htmlState = previousHtmlState = HTML_STATE_INVALID;
|
||
urlCopy = NULL;
|
||
|
||
//
|
||
// retrieve some information from the file/find handle - the handle type,
|
||
// URL string, current HTML document state and previous failed dir entry
|
||
//
|
||
|
||
error = RGetHandleType(hInternet, &handleType);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
|
||
error = RGetUrl(hInternet, &url);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
|
||
error = RGetHtmlState(hInternet, &htmlState);
|
||
previousHtmlState = htmlState;
|
||
if (error != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
|
||
error = RGetDirEntry(hInternet, &lastDirEntry);
|
||
if (error != ERROR_SUCCESS) {
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// initialize variables for loop
|
||
//
|
||
|
||
*lpdwBytesReturned = dwBufferLength;
|
||
charsCopied = 0;
|
||
buffer = (LPBYTE)lpBuffer;
|
||
done = FALSE;
|
||
success = TRUE;
|
||
dataCopied = FALSE;
|
||
|
||
//
|
||
// first, maybe we already have data available from a previous
|
||
// QueryDataAvailable operation
|
||
//
|
||
|
||
#ifdef EXTENDED_ERROR_HTML
|
||
INET_ASSERT((handleType == TypeFtpFindHandleHtml)
|
||
|| (handleType == TypeFtpFileHandleHtml)
|
||
|| (handleType == TypeGopherFindHandleHtml));
|
||
#else
|
||
INET_ASSERT((handleType == TypeFtpFindHandleHtml)
|
||
|| (handleType == TypeGopherFindHandleHtml));
|
||
#endif
|
||
|
||
if (handleType == TypeFtpFindHandleHtml) {
|
||
|
||
FTP_FIND_HANDLE_OBJECT * pObject = (FTP_FIND_HANDLE_OBJECT *)hInternet;
|
||
|
||
if (pObject->HaveQueryData()) {
|
||
dwBufferLength -= pObject->CopyQueriedData(lpBuffer, dwBufferLength);
|
||
goto quit;
|
||
}
|
||
}
|
||
#ifdef EXTENDED_ERROR_HTML
|
||
else if (handleType == TypeFtpFileHandleHtml) {
|
||
|
||
FTP_ERROR_HANDLE_OBJECT * pObject = (FTP_ERROR_HANDLE_OBJECT *)hInternet;
|
||
|
||
if (pObject->HaveQueryData()) {
|
||
dwBufferLength -= pObject->CopyQueriedData(lpBuffer, dwBufferLength);
|
||
goto quit;
|
||
}
|
||
}
|
||
#endif
|
||
else
|
||
{
|
||
GOPHER_FIND_HANDLE_OBJECT * pObject = (GOPHER_FIND_HANDLE_OBJECT *)hInternet;
|
||
|
||
if (pObject->HaveQueryData()) {
|
||
dwBufferLength -= pObject->CopyQueriedData(lpBuffer, dwBufferLength);
|
||
goto quit;
|
||
}
|
||
}
|
||
|
||
//
|
||
// loop round, writing as much data as we are able to the caller's buffer
|
||
//
|
||
|
||
do {
|
||
switch (htmlState) {
|
||
case HTML_STATE_START:
|
||
|
||
//
|
||
// if we are dealing with files then we go straight to copying the
|
||
// file contents - we don't encapsulate files in HTML
|
||
//
|
||
|
||
#ifdef EXTENDED_ERROR_HTML
|
||
if (handleType == TypeFtpFileHandleHtml) {
|
||
|
||
//
|
||
// FTP file handle is used for FTP errors
|
||
//
|
||
|
||
charsCopied = (DWORD)wsprintf((LPSTR)scratchPad,
|
||
HTML_ERROR_DOCUMENT_HEADER,
|
||
"FTP Error",
|
||
"FTP Error"
|
||
);
|
||
if (charsCopied > dwBufferLength) {
|
||
|
||
//
|
||
// caller's buffer not large enough to fit header - clean up
|
||
// and allow the caller to retry
|
||
//
|
||
|
||
success = FALSE;
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
done = TRUE;
|
||
} else {
|
||
|
||
//
|
||
// copy the header to the caller's buffer
|
||
//
|
||
|
||
memcpy(buffer, scratchPad, charsCopied);
|
||
dataCopied = TRUE;
|
||
}
|
||
htmlState = HTML_STATE_ERROR_BODY;
|
||
} else if (handleType == TypeGopherFileHandleHtml)
|
||
#else
|
||
if ((handleType == TypeFtpFileHandleHtml)
|
||
|| (handleType == TypeGopherFileHandleHtml))
|
||
#endif
|
||
{
|
||
htmlState = HTML_STATE_BODY;
|
||
}
|
||
else
|
||
{
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
}
|
||
break;
|
||
|
||
case HTML_STATE_HEADER: {
|
||
|
||
//
|
||
// crack the URL for the info we need (i) for the header (ii) for
|
||
// FTP file paths
|
||
//
|
||
|
||
DWORD urlLength;
|
||
LPSTR host;
|
||
DWORD hostLength;
|
||
char title[MAX_FMT_BUF + INTERNET_MAX_PATH_LENGTH + 1];
|
||
char hostName[INTERNET_MAX_HOST_NAME_LENGTH + 1];
|
||
|
||
//
|
||
// first, make a copy of the URL, reserving 2 extra characters in
|
||
// case this is an FTP request and we need to add a root directory
|
||
// path
|
||
//
|
||
|
||
urlLength = strlen(url);
|
||
urlCopy = NEW_MEMORY(urlLength + 2, char);
|
||
if (urlCopy == NULL) {
|
||
error = ERROR_NOT_ENOUGH_MEMORY;
|
||
goto quit;
|
||
}
|
||
memcpy(urlCopy, url, urlLength + 1);
|
||
|
||
//
|
||
// get the start of the URL path and the host name. CrackUrl() will
|
||
// destroy url but leave urlCopy intact
|
||
//
|
||
|
||
error = CrackUrl(urlCopy,
|
||
0, // dwUrlLength
|
||
FALSE, // decode the url-path
|
||
NULL, // we don't care about the scheme
|
||
NULL, // or scheme name
|
||
NULL,
|
||
&host, // we want the host name (for title)
|
||
&hostLength,
|
||
NULL, // or the port
|
||
NULL, // or the user name
|
||
NULL,
|
||
NULL, // or the password
|
||
NULL,
|
||
&url, // we want the url-path
|
||
&urlLength,
|
||
NULL,
|
||
NULL,
|
||
NULL
|
||
);
|
||
if (error != ERROR_SUCCESS) {
|
||
|
||
//
|
||
// handle still has previous URL pointer, but it will be deleted
|
||
// when the handle is closed
|
||
//
|
||
|
||
goto quit;
|
||
}
|
||
|
||
//
|
||
// ensure the host name is zero-terminated
|
||
//
|
||
|
||
hostLength = (DWORD)min(hostLength, sizeof(hostName) - 1);
|
||
memcpy(hostName, host, hostLength);
|
||
hostName[hostLength] = '\0';
|
||
|
||
//
|
||
// same for the URL-path
|
||
//
|
||
|
||
url[urlLength] = '\0';
|
||
|
||
//
|
||
// create the header/title
|
||
//
|
||
|
||
char szFmt[MAX_FMT_BUF];
|
||
szFmt[0] = 0; // guard against LoadString failing (why would it?)
|
||
|
||
if (handleType == TypeGopherFindHandleHtml) {
|
||
|
||
GOPHER_FIND_HANDLE_OBJECT* pGopherFind =
|
||
(GOPHER_FIND_HANDLE_OBJECT *) hInternet;
|
||
|
||
switch (pGopherFind->GetFixedType()) {
|
||
|
||
case GOPHER_TYPE_CSO:
|
||
LoadString (GlobalDllHandle, IDS_GOPHER_CSO,
|
||
szFmt, sizeof(szFmt));
|
||
wsprintf (title, szFmt, hostName);
|
||
break;
|
||
|
||
case GOPHER_TYPE_INDEX_SERVER:
|
||
LoadString (GlobalDllHandle, IDS_GOPHER_INDEX,
|
||
szFmt, sizeof(szFmt));
|
||
wsprintf (title, szFmt, hostName);
|
||
break;
|
||
|
||
default:
|
||
if ((*url == '\0') || (memcmp(url, "/", 2) == 0)) {
|
||
LoadString (GlobalDllHandle, IDS_GOPHER_ROOT,
|
||
szFmt, sizeof(szFmt));
|
||
wsprintf(title, szFmt, hostName);
|
||
} else {
|
||
LoadString (GlobalDllHandle, IDS_GOPHER_DIR,
|
||
szFmt, sizeof(szFmt));
|
||
wsprintf(title, szFmt, hostName);
|
||
}
|
||
}
|
||
|
||
} else if (handleType == TypeFtpFindHandleHtml) {
|
||
if ((*url == '\0') || (memcmp(url, "/", 2) == 0)) {
|
||
LoadString (GlobalDllHandle, IDS_FTP_ROOT,
|
||
szFmt, sizeof(szFmt));
|
||
wsprintf(title, szFmt, hostName);
|
||
} else {
|
||
LoadString (GlobalDllHandle, IDS_FTP_DIR,
|
||
szFmt, sizeof(szFmt));
|
||
wsprintf(title, szFmt, url, hostName);
|
||
}
|
||
} else {
|
||
title[0] = '\0';
|
||
}
|
||
charsCopied = (DWORD)wsprintf((LPSTR)scratchPad,
|
||
HTML_DOCUMENT_HEADER,
|
||
title,
|
||
title
|
||
);
|
||
if (charsCopied > dwBufferLength) {
|
||
|
||
//
|
||
// caller's buffer not large enough to fit header - clean up
|
||
// and allow the caller to retry
|
||
//
|
||
|
||
success = FALSE;
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
done = TRUE;
|
||
} else {
|
||
|
||
//
|
||
// copy the header to the caller's buffer
|
||
//
|
||
|
||
memcpy(buffer, scratchPad, charsCopied);
|
||
dataCopied = TRUE;
|
||
|
||
//
|
||
// if the URL contains a NULL path then point it at the FTP
|
||
// root. Likewise, end any and all directory paths with '/'
|
||
//
|
||
|
||
if (handleType == TypeFtpFindHandleHtml) {
|
||
if (urlLength == 0) {
|
||
*url = '/';
|
||
++urlLength;
|
||
} else if ((url[urlLength - 1] != '/')
|
||
&& (url[urlLength - 1] != '\\')) {
|
||
url[urlLength++] = '/';
|
||
}
|
||
url[urlLength] = '\0';
|
||
} else {
|
||
url = NULL;
|
||
}
|
||
|
||
//
|
||
// free the URL in the handle object if gopher, else (FTP) set
|
||
// it to be the path part of the URL. The previous string will
|
||
// be deleted, and a new one allocated
|
||
//
|
||
|
||
RSetUrl(hInternet, url);
|
||
|
||
//
|
||
// we can now start on the dir header
|
||
//
|
||
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
}
|
||
break;
|
||
}
|
||
|
||
case HTML_STATE_WELCOME: {
|
||
|
||
LPSTR lastInfo;
|
||
DWORD lastInfoLength;
|
||
INTERNET_CONNECT_HANDLE_OBJECT * pConnect;
|
||
BOOL freeLastResponseInfo;
|
||
|
||
if ( handleType == TypeGopherFindHandleHtml
|
||
&& ((GOPHER_FIND_HANDLE_OBJECT *) hInternet)->GetFixedType()) {
|
||
|
||
//
|
||
// BUGBUG - wimp out on CSO searches for now.
|
||
//
|
||
|
||
if (((GOPHER_FIND_HANDLE_OBJECT *) hInternet)->GetFixedType()
|
||
== GOPHER_TYPE_CSO) {
|
||
success = TRUE;
|
||
dataCopied = FALSE;
|
||
htmlState = HTML_STATE_FOOTER;
|
||
break;
|
||
}
|
||
|
||
|
||
charsCopied = sizeof(HTML_ISINDEX);
|
||
if (dwBufferLength < charsCopied) {
|
||
|
||
success = FALSE;
|
||
|
||
} else {
|
||
|
||
memcpy (buffer, HTML_ISINDEX, charsCopied);
|
||
dataCopied = TRUE;
|
||
success = TRUE;
|
||
htmlState = HTML_STATE_FOOTER;
|
||
}
|
||
break;
|
||
}
|
||
|
||
pConnect = (INTERNET_CONNECT_HANDLE_OBJECT *)
|
||
((HANDLE_OBJECT *)hInternet)->GetParent();
|
||
lastInfo = pConnect->GetLastResponseInfo(&lastInfoLength);
|
||
|
||
//
|
||
// if not an FTP find operation then we don't check for any welcome
|
||
// message, or other text from the server. Just go to the next state
|
||
//
|
||
|
||
if ((handleType == TypeFtpFindHandleHtml) && (lastInfo != NULL)) {
|
||
|
||
//
|
||
// find the welcome message. This starts with "230-" and can
|
||
// continue over multiple lines, each of which may start with
|
||
// "230-", or each may start with a line beginning only with a
|
||
// space
|
||
//
|
||
|
||
LPSTR p = strstr(lastInfo, FTP_WELCOME_INTRO);
|
||
|
||
if (p != NULL) {
|
||
|
||
//
|
||
// first, copy the separator
|
||
//
|
||
|
||
LPBYTE pBuffer = buffer;
|
||
DWORD bufferLeft = dwBufferLength;
|
||
|
||
if (bufferLeft >= (sizeof(HTML_FTP_WELCOME_START) - 1)) {
|
||
memcpy(pBuffer,
|
||
HTML_FTP_WELCOME_START,
|
||
sizeof(HTML_FTP_WELCOME_START) - 1
|
||
);
|
||
pBuffer += sizeof(HTML_FTP_WELCOME_START) - 1;
|
||
bufferLeft -= sizeof(HTML_FTP_WELCOME_START) - 1;
|
||
charsCopied = sizeof(HTML_FTP_WELCOME_START) - 1;
|
||
} else {
|
||
|
||
//
|
||
// caller's buffer not large enough to fit header -
|
||
// clean up and allow the caller to retry
|
||
//
|
||
|
||
success = FALSE;
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
done = TRUE;
|
||
freeLastResponseInfo = FALSE;
|
||
goto quit_welcome;
|
||
}
|
||
|
||
//
|
||
// then copy each welcome message line, dropping the "230-"
|
||
// from each
|
||
//
|
||
|
||
do {
|
||
if (!strncmp(p, FTP_WELCOME_INTRO, FTP_WELCOME_INTRO_LENGTH)) {
|
||
p += FTP_WELCOME_INTRO_LENGTH;
|
||
} else if (*p != ' ') {
|
||
|
||
//
|
||
// line doesn't start with "230-" or a space. We're
|
||
// done
|
||
//
|
||
|
||
break;
|
||
}
|
||
|
||
LPSTR lastChar;
|
||
DWORD len;
|
||
|
||
lastChar = strchr(p, '\n');
|
||
if (lastChar != NULL) {
|
||
len = (DWORD)(lastChar - p) + 1;
|
||
} else {
|
||
len = strlen(p);
|
||
}
|
||
|
||
if (bufferLeft >= len) {
|
||
memcpy(pBuffer, p, len);
|
||
pBuffer += len;
|
||
p += len;
|
||
bufferLeft -= len;
|
||
charsCopied += len;
|
||
|
||
//
|
||
// find start of next line, or end of buffer, in
|
||
// case there are multiple line terminators
|
||
//
|
||
|
||
while ((*p == '\r') || (*p == '\n')) {
|
||
++p;
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// caller's buffer not large enough to fit header -
|
||
// clean up and allow the caller to retry
|
||
//
|
||
|
||
success = FALSE;
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
done = TRUE;
|
||
freeLastResponseInfo = FALSE;
|
||
break;
|
||
}
|
||
} while (TRUE);
|
||
|
||
//
|
||
// finish off
|
||
//
|
||
|
||
if (bufferLeft >= (sizeof(HTML_FTP_WELCOME_END) - 1)) {
|
||
memcpy(pBuffer,
|
||
HTML_FTP_WELCOME_END,
|
||
sizeof(HTML_FTP_WELCOME_END) - 1
|
||
);
|
||
pBuffer += sizeof(HTML_FTP_WELCOME_END) - 1;
|
||
bufferLeft -= sizeof(HTML_FTP_WELCOME_END) - 1;
|
||
charsCopied += sizeof(HTML_FTP_WELCOME_END) - 1;
|
||
|
||
//
|
||
// successfully completed welcome message part
|
||
//
|
||
|
||
dataCopied = TRUE;
|
||
freeLastResponseInfo = TRUE;
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
} else {
|
||
|
||
//
|
||
// caller's buffer not large enough to fit header -
|
||
// clean up and allow the caller to retry
|
||
//
|
||
|
||
success = FALSE;
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
done = TRUE;
|
||
freeLastResponseInfo = FALSE;
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// last response info, but no welcome text. Continue
|
||
//
|
||
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
freeLastResponseInfo = TRUE;
|
||
charsCopied = 0;
|
||
}
|
||
} else {
|
||
|
||
//
|
||
// no info from server. Continue
|
||
//
|
||
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
freeLastResponseInfo = FALSE;
|
||
charsCopied = 0;
|
||
}
|
||
|
||
quit_welcome:
|
||
|
||
if (freeLastResponseInfo) {
|
||
pConnect->FreeLastResponseInfo();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case HTML_STATE_DIR_HEADER:
|
||
|
||
//
|
||
// copy the directory listing introduction. N.B. this is mainly here
|
||
// from the time when we had directory listings AND files being HTML
|
||
// encapsulated. This is no longer true, so I could change things
|
||
// somewhat
|
||
//
|
||
|
||
//
|
||
// if FTP directory AND not root directory, display link to higher
|
||
// level
|
||
//
|
||
|
||
DWORD cbTotal;
|
||
char szUp[64];
|
||
LPSTR lpszHtml;
|
||
|
||
szUp[0] = 0;
|
||
|
||
if (handleType == TypeFtpFindHandleHtml) {
|
||
lpszHtml = HTML_DOCUMENT_FTP_DIR_START;
|
||
cbTotal = sizeof(HTML_DOCUMENT_FTP_DIR_START);
|
||
if ((*url != '\0') && (memcmp(url, "/", 2) != 0)) {
|
||
cbTotal += LoadString(GlobalDllHandle,
|
||
IDS_FTP_UPLEVEL,
|
||
szUp,
|
||
sizeof(szUp)
|
||
);
|
||
}
|
||
} else {
|
||
lpszHtml = HTML_DOCUMENT_DIR_START;
|
||
cbTotal = sizeof(HTML_DOCUMENT_DIR_START);
|
||
}
|
||
if (dwBufferLength >= cbTotal) {
|
||
charsCopied = wsprintf((char *)buffer, lpszHtml, szUp);
|
||
dataCopied = TRUE;
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
} else {
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
success = FALSE;
|
||
}
|
||
break;
|
||
|
||
case HTML_STATE_BODY:
|
||
|
||
//
|
||
// if we already have a formatted dir entry from last time (it
|
||
// wouldn't fit in the buffer), then copy it now
|
||
//
|
||
|
||
if (lastDirEntry != NULL) {
|
||
charsCopied = strlen(lastDirEntry);
|
||
if (dwBufferLength >= charsCopied) {
|
||
memcpy(buffer, lastDirEntry, charsCopied);
|
||
|
||
//
|
||
// we no longer require the string
|
||
//
|
||
|
||
RSetDirEntry(hInternet, NULL);
|
||
lastDirEntry = NULL;
|
||
success = TRUE;
|
||
} else {
|
||
|
||
//
|
||
// still not enough room
|
||
//
|
||
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
success = FALSE;
|
||
done = TRUE;
|
||
}
|
||
|
||
//
|
||
// in both cases fall out of the switch()
|
||
//
|
||
|
||
break;
|
||
}
|
||
|
||
//
|
||
// read the next part of the HTML document
|
||
//
|
||
|
||
switch (handleType) {
|
||
case TypeFtpFindHandleHtml:
|
||
success = FtpFindNextFileA(hInternet,
|
||
(LPWIN32_FIND_DATA)dirBuffer
|
||
);
|
||
goto create_dir_entry;
|
||
|
||
case TypeGopherFindHandleHtml:
|
||
|
||
//
|
||
// Check if we simply can return fixed text for a search
|
||
//
|
||
|
||
success = GopherFindNextA(hInternet,
|
||
(LPGOPHER_FIND_DATA)dirBuffer
|
||
);
|
||
|
||
//
|
||
// directory listing - get the next directory entry, convert
|
||
// to HTML and write to the caller's buffer. If there's not
|
||
// enough space, return an error
|
||
//
|
||
|
||
create_dir_entry:
|
||
|
||
if (success) {
|
||
charsCopied = dwBufferLength;
|
||
error = MakeHtmlDirEntry(handleType,
|
||
url,
|
||
dirBuffer,
|
||
buffer,
|
||
&charsCopied,
|
||
&lastDirEntry
|
||
);
|
||
if (error != ERROR_SUCCESS) {
|
||
|
||
//
|
||
// if MakeHtmlDirEntry() created a copy of the directory
|
||
// entry then store it in the handle object for next
|
||
// time
|
||
//
|
||
|
||
if (lastDirEntry != NULL) {
|
||
RSetDirEntry(hInternet, lastDirEntry);
|
||
|
||
//
|
||
// no longer need our copy of the string -
|
||
// RSetLastDirEntry() also makes a copy and adds it
|
||
// to the handle object
|
||
//
|
||
|
||
DEL_STRING(lastDirEntry);
|
||
}
|
||
|
||
//
|
||
// probably out of buffer space - we're done
|
||
//
|
||
|
||
success = FALSE;
|
||
done = TRUE;
|
||
} else {
|
||
dataCopied = TRUE;
|
||
}
|
||
} else if (GetLastError() == ERROR_NO_MORE_FILES) {
|
||
|
||
//
|
||
// change the error to success - ReadFile() doesn't return
|
||
// ERROR_NO_MORE_FILES
|
||
//
|
||
|
||
SetLastError(ERROR_SUCCESS);
|
||
|
||
//
|
||
// reached the end of the directory listing - time to
|
||
// add the footer
|
||
//
|
||
|
||
charsCopied = 0;
|
||
success = TRUE;
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
}
|
||
break;
|
||
|
||
case TypeFtpFileHandleHtml:
|
||
case TypeGopherFileHandleHtml:
|
||
|
||
//
|
||
// BUGBUG - this path never taken because we do not encapsulate
|
||
// files?
|
||
//
|
||
|
||
//
|
||
// file data - just read the next chunk
|
||
//
|
||
|
||
success = InternetReadFile(hInternet,
|
||
(LPVOID)buffer,
|
||
dwBufferLength,
|
||
&charsCopied
|
||
);
|
||
if (success) {
|
||
if (charsCopied == 0) {
|
||
|
||
//
|
||
// read all of file - we're done (no HTML to add for
|
||
// files)
|
||
//
|
||
|
||
htmlState = HTML_STATE_END;
|
||
} else {
|
||
buffer += charsCopied;
|
||
dwBufferLength -= charsCopied;
|
||
dataCopied = TRUE;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case HTML_STATE_DIR_FOOTER:
|
||
if (dwBufferLength >= sizeof(HTML_DOCUMENT_DIR_END) - 1) {
|
||
memcpy(buffer,
|
||
HTML_DOCUMENT_DIR_END,
|
||
sizeof(HTML_DOCUMENT_DIR_END) - 1
|
||
);
|
||
charsCopied = sizeof(HTML_DOCUMENT_DIR_END) - 1;
|
||
dataCopied = TRUE;
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
} else {
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
success = FALSE;
|
||
}
|
||
break;
|
||
|
||
case HTML_STATE_FOOTER:
|
||
|
||
//
|
||
// copy the HTML document footer - don't copy the end-of-string
|
||
// character ('\0')
|
||
//
|
||
|
||
if (dwBufferLength >= sizeof(HTML_DOCUMENT_FOOTER) - 1) {
|
||
memcpy(buffer,
|
||
HTML_DOCUMENT_FOOTER,
|
||
sizeof(HTML_DOCUMENT_FOOTER) - 1
|
||
);
|
||
charsCopied = sizeof(HTML_DOCUMENT_FOOTER) - 1;
|
||
|
||
//
|
||
// the document is done
|
||
//
|
||
|
||
htmlState = (HTML_STATE)((int)htmlState + 1);
|
||
dataCopied = TRUE;
|
||
done = TRUE;
|
||
} else if (charsCopied==0) {
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
success = FALSE;
|
||
} else {
|
||
// We're out of buffer space. but we've got everything else
|
||
// so we'll just leave
|
||
done = TRUE;
|
||
}
|
||
break;
|
||
|
||
case HTML_STATE_END:
|
||
done = TRUE;
|
||
break;
|
||
|
||
#ifdef EXTENDED_ERROR_HTML
|
||
case HTML_STATE_ERROR_BODY:
|
||
htmlState = HTML_STATE_FOOTER;
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
break;
|
||
}
|
||
|
||
if (success) {
|
||
|
||
//
|
||
// update the buffer pointer and remaining length by the number of
|
||
// bytes read this time round the loop
|
||
//
|
||
|
||
buffer += charsCopied;
|
||
dwBufferLength -= charsCopied;
|
||
}
|
||
} while ((dwBufferLength != 0) && success && !done);
|
||
|
||
//
|
||
// if we succeeded, update the amount of data returned, else set the last
|
||
// error, which may be different from the last error set by the underlying
|
||
// API (if any were called)
|
||
//
|
||
|
||
quit:
|
||
|
||
//
|
||
// remember the current state
|
||
//
|
||
|
||
if (htmlState != previousHtmlState) {
|
||
RSetHtmlState(hInternet, htmlState);
|
||
}
|
||
|
||
//
|
||
// if we quit because we ran out of buffer then only return an error if we
|
||
// didn't copy *any* data
|
||
//
|
||
|
||
if ((error == ERROR_INSUFFICIENT_BUFFER) && dataCopied) {
|
||
error = ERROR_SUCCESS;
|
||
success = TRUE;
|
||
}
|
||
|
||
//
|
||
// if we succeeded then return the amount of data read, else reset the last
|
||
// error
|
||
//
|
||
|
||
if (error == ERROR_SUCCESS) {
|
||
*lpdwBytesReturned -= dwBufferLength;
|
||
} else {
|
||
*lpdwBytesReturned = 0;
|
||
SetLastError(error);
|
||
success = FALSE;
|
||
|
||
DEBUG_ERROR(INET, error);
|
||
|
||
}
|
||
|
||
//
|
||
// clean up
|
||
//
|
||
|
||
if (urlCopy != NULL) {
|
||
DEL(urlCopy);
|
||
}
|
||
|
||
//
|
||
// return API-level success or failure indication
|
||
//
|
||
|
||
DEBUG_LEAVE(success);
|
||
|
||
return success;
|
||
}
|
||
|
||
|
||
DWORD
|
||
QueryHtmlDataAvailable(
|
||
IN HINTERNET hInternet,
|
||
OUT LPDWORD lpdwNumberOfBytesAvailable
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function is called when the app is querying available data for a cooked
|
||
(HTML) find handle. Because we have to cook the data before we can determine
|
||
how much there is, we need to allocate a buffer and cook the data there
|
||
|
||
Arguments:
|
||
|
||
hInternet - MAPPED address of handle object
|
||
|
||
lpdwNumberOfBytesAvailable - pointer to returned bytes available
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - ERROR_INTERNET_INCORRECT_HANDLE_TYPE
|
||
Can only handle TypeFtpFindHandleHtml and
|
||
TypeGopherFindHandleHtml
|
||
|
||
ERROR_NOT_ENOUGH_MEMORY
|
||
Ran out of memory allocating HTML buffer
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_INET,
|
||
Dword,
|
||
"QueryHtmlDataAvailable",
|
||
"%#x, %#x",
|
||
hInternet,
|
||
lpdwNumberOfBytesAvailable
|
||
));
|
||
|
||
DWORD error;
|
||
|
||
switch (((HANDLE_OBJECT *)hInternet)->GetHandleType()) {
|
||
case TypeFtpFindHandleHtml:
|
||
error = ((FTP_FIND_HANDLE_OBJECT *)hInternet)->
|
||
QueryHtmlDataAvailable(lpdwNumberOfBytesAvailable);
|
||
break;
|
||
|
||
#ifdef EXTENDED_ERROR_HTML
|
||
case TypeFtpFileHandleHtml:
|
||
error = ((FTP_ERROR_HANDLE_OBJECT *)hInternet)->
|
||
QueryHtmlDataAvailable(lpdwNumberOfBytesAvailable);
|
||
break;
|
||
#endif
|
||
|
||
case TypeGopherFindHandleHtml:
|
||
error = ((GOPHER_FIND_HANDLE_OBJECT *)hInternet)->
|
||
QueryHtmlDataAvailable(lpdwNumberOfBytesAvailable);
|
||
break;
|
||
|
||
default:
|
||
error = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
|
||
|
||
INET_ASSERT(FALSE);
|
||
|
||
break;
|
||
}
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|
||
|
||
//
|
||
// private functions
|
||
//
|
||
|
||
|
||
PRIVATE
|
||
DWORD
|
||
MakeHtmlDirEntry(
|
||
IN HINTERNET_HANDLE_TYPE HandleType,
|
||
IN LPSTR PathPrefix,
|
||
IN LPVOID DirBuffer,
|
||
IN LPBYTE EntryBuffer,
|
||
IN OUT LPDWORD BufferLength,
|
||
OUT LPSTR* DirEntry
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Creates a single-line directory entry for a HTML document. The line is
|
||
formatted thus (e.g.):
|
||
|
||
" 12,345,678 Fri Jun 23 95 4:43pm pagefile.sys "
|
||
" Directory Fri Jun 23 95 10:00am foobar.directory "
|
||
" unknown.filesize "
|
||
|
||
Arguments:
|
||
|
||
HandleType - type of the handle - gopher or FTP (find + HTML)
|
||
|
||
PathPrefix - string used to build (FTP) absolute paths
|
||
|
||
DirBuffer - pointer to buffer containing GOPHER_FIND_DATA or
|
||
WIN32_FIND_DATA
|
||
|
||
EntryBuffer - pointer to buffer where HTML dir entry will be written
|
||
|
||
BufferLength - IN: number of bytes available in EntryBuffer
|
||
OUT: number of bytes written to EntryBuffer
|
||
|
||
DirEntry - if we couldn't copy the directory entry to the HTML buffer
|
||
then we return a pointer to a copy of the formatted
|
||
directory entry. The caller should remember this and use
|
||
it the next time the function is called, before getting
|
||
the next dir entry
|
||
|
||
Return Value:
|
||
|
||
DWORD
|
||
Success - ERROR_SUCCESS
|
||
|
||
Failure - ERROR_INSUFFICIENT_BUFFER
|
||
EntryBuffer is not large enough to hold this entry
|
||
|
||
--*/
|
||
|
||
{
|
||
DEBUG_ENTER((DBG_INET,
|
||
Dword,
|
||
"MakeHtmlDirEntry",
|
||
"%s (%d), %q, %#x, %#x, %#x [%d], %#x",
|
||
InternetMapHandleType(HandleType),
|
||
HandleType,
|
||
PathPrefix,
|
||
DirBuffer,
|
||
EntryBuffer,
|
||
BufferLength,
|
||
*BufferLength,
|
||
DirEntry
|
||
));
|
||
|
||
BOOL isDir;
|
||
BOOL isSearch;
|
||
LPSTR entryName;
|
||
DWORD entrySize;
|
||
FILETIME entryTime;
|
||
SYSTEMTIME systemTime;
|
||
char timeBuf[80];
|
||
char sizeBuf[15]; // 4,294,967,295
|
||
char entryBuf[sizeof(HTML_DOCUMENT_DIR_ENTRY) + INTERNET_MAX_PATH_LENGTH];
|
||
char urlBuf[INTERNET_MAX_URL_LENGTH];
|
||
LPSTR url;
|
||
LPSTR pSizeDir;
|
||
DWORD nPrinted;
|
||
DWORD error;
|
||
BOOL haveTimeAndSize;
|
||
DWORD urlLength;
|
||
|
||
//
|
||
// ensure we are dealing with the correct handle type
|
||
//
|
||
|
||
INET_ASSERT((HandleType == TypeFtpFindHandleHtml)
|
||
|| (HandleType == TypeGopherFindHandleHtml));
|
||
|
||
//
|
||
// get the common information we will use to create a directory entry line
|
||
//
|
||
|
||
if (HandleType == TypeFtpFindHandleHtml) {
|
||
isDir = ((LPWIN32_FIND_DATA)DirBuffer)->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
|
||
isSearch = FALSE;
|
||
entryName = ((LPWIN32_FIND_DATA)DirBuffer)->cFileName;
|
||
entryTime = ((LPWIN32_FIND_DATA)DirBuffer)->ftLastWriteTime;
|
||
entrySize = ((LPWIN32_FIND_DATA)DirBuffer)->nFileSizeLow;
|
||
haveTimeAndSize = TRUE;
|
||
|
||
DWORD slen = strlen(PathPrefix);
|
||
DWORD len = (DWORD)min(slen, sizeof(urlBuf) - 1);
|
||
|
||
memcpy(urlBuf, PathPrefix, len);
|
||
slen = strlen(entryName);
|
||
slen = (DWORD)min(slen, (sizeof(urlBuf) - 1) - len);
|
||
memcpy(&urlBuf[len], entryName, slen);
|
||
len += slen;
|
||
if (isDir && (len < sizeof(urlBuf) - 1)) {
|
||
urlBuf[len] = '/';
|
||
++len;
|
||
}
|
||
urlBuf[len] = '\0';
|
||
url = urlBuf;
|
||
} else {
|
||
isDir = IS_GOPHER_DIRECTORY(((LPGOPHER_FIND_DATA)DirBuffer)->GopherType);
|
||
isSearch = IS_GOPHER_INDEX_SERVER(((LPGOPHER_FIND_DATA)DirBuffer)->GopherType);
|
||
entryName = ((LPGOPHER_FIND_DATA)DirBuffer)->DisplayString;
|
||
GopherLocatorToUrl(((LPGOPHER_FIND_DATA)DirBuffer)->Locator,
|
||
urlBuf,
|
||
sizeof(urlBuf),
|
||
&urlLength
|
||
);
|
||
url = urlBuf;
|
||
if (IS_GOPHER_PLUS(((LPGOPHER_FIND_DATA)DirBuffer)->GopherType)) {
|
||
haveTimeAndSize = TRUE;
|
||
entryTime = ((LPGOPHER_FIND_DATA)DirBuffer)->LastModificationTime;
|
||
entrySize = ((LPGOPHER_FIND_DATA)DirBuffer)->SizeLow;
|
||
} else {
|
||
haveTimeAndSize = FALSE;
|
||
entryTime.dwLowDateTime = 0;
|
||
entryTime.dwHighDateTime = 0;
|
||
entrySize = 0;
|
||
}
|
||
}
|
||
|
||
//
|
||
// if we have a non-zero entry time AND we can convert it to a system time
|
||
// then create an internationalized time string
|
||
//
|
||
|
||
if ((entryTime.dwLowDateTime != 0)
|
||
&& (entryTime.dwHighDateTime != 0)
|
||
&& FileTimeToSystemTime(&entryTime, &systemTime)) {
|
||
|
||
int n;
|
||
|
||
//
|
||
// BUGBUG - if either of these fail for any reason, we should fill the
|
||
// string with the requisite-t-t-t-t-t number of spaces
|
||
//
|
||
|
||
n = GetDateFormat(0, // lcid
|
||
0, // dwFlags
|
||
&systemTime,
|
||
"MM/dd/yyyy ",
|
||
timeBuf,
|
||
sizeof(timeBuf)
|
||
);
|
||
if (n > 0) {
|
||
|
||
//
|
||
// number of characters written to string becomes index in string
|
||
// at which to write time string
|
||
//
|
||
|
||
--n;
|
||
}
|
||
GetTimeFormat(0, // lcid
|
||
TIME_NOSECONDS,
|
||
&systemTime,
|
||
"hh:mmtt",
|
||
&timeBuf[n],
|
||
sizeof(timeBuf) - n
|
||
);
|
||
|
||
//
|
||
// convert any non-ANSI characters to the OEM charset
|
||
//
|
||
|
||
CharToOem(timeBuf, timeBuf);
|
||
} else {
|
||
memcpy(timeBuf, " ", 17);
|
||
}
|
||
|
||
//
|
||
// convert the entry size to a human-readable form
|
||
//
|
||
|
||
if (isDir) {
|
||
|
||
//
|
||
// directories show up as DOS-style <DIR> entries, except we use the
|
||
// full "Directory" text
|
||
//
|
||
|
||
//
|
||
// BUGBUG - needs to be in a resource. Also, if we are adding images
|
||
// <IMG> then we don't need to specify dir - it will be obvious
|
||
// from the display (but what about text-only? what about
|
||
// viewers that don't care to/can't load the image?)
|
||
//
|
||
|
||
if (!szDir[0]) {
|
||
LoadString(GlobalDllHandle, IDS_TAG_DIRECTORY, szDir, sizeof(szDir));
|
||
}
|
||
pSizeDir = szDir;
|
||
} else if (isSearch) {
|
||
|
||
//
|
||
// if this is a gopher item and it is an index server (7) then indicate
|
||
// the fact using this string
|
||
//
|
||
|
||
if (!szSearch[0]) {
|
||
LoadString(GlobalDllHandle, IDS_TAG_SEARCH, szSearch, sizeof(szSearch));
|
||
}
|
||
pSizeDir = szSearch;
|
||
} else if (haveTimeAndSize) {
|
||
pSizeDir = NiceNum(sizeBuf, entrySize, 14);
|
||
} else {
|
||
pSizeDir = " ";
|
||
}
|
||
|
||
//
|
||
// now create the HTML directory entry
|
||
//
|
||
|
||
//
|
||
// BUGBUG - at this point we need to call the MIME function to retrieve the
|
||
// URL for the image file that goes with this file type
|
||
//
|
||
|
||
nPrinted = wsprintf(entryBuf,
|
||
isDir
|
||
? HTML_DOCUMENT_DIR_ENTRY
|
||
: HTML_DOCUMENT_FILE_ENTRY,
|
||
timeBuf,
|
||
pSizeDir,
|
||
url,
|
||
entryName
|
||
);
|
||
if (nPrinted <= *BufferLength) {
|
||
memcpy(EntryBuffer, entryBuf, nPrinted);
|
||
*BufferLength = nPrinted;
|
||
error = ERROR_SUCCESS;
|
||
} else {
|
||
|
||
//
|
||
// there is not enough space in the buffer to store this formatted
|
||
// directory entry. So since we've gone to the trouble of creating
|
||
// the string, we make a copy of it and return it to the caller. If
|
||
// NEW_STRING fails, then we will lose this directory entry, but it's
|
||
// not really a problem. (The alternative would be to return e.g.
|
||
// ERROR_NOT_ENOUGH_MEMORY and probably fail the entire request)
|
||
//
|
||
|
||
DEBUG_PRINT(INET,
|
||
WARNING,
|
||
("failed to copy %q\n",
|
||
entryBuf
|
||
));
|
||
|
||
*DirEntry = NEW_STRING(entryBuf);
|
||
|
||
if (*DirEntry == NULL) {
|
||
|
||
DEBUG_PRINT(INET,
|
||
WARNING,
|
||
("failed to make copy of %q!\n",
|
||
entryBuf
|
||
));
|
||
|
||
}
|
||
error = ERROR_INSUFFICIENT_BUFFER;
|
||
}
|
||
|
||
DEBUG_LEAVE(error);
|
||
|
||
return error;
|
||
}
|