ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move all FTP functions to unicode. 

Improve FTP LIST parsing.
This commit is contained in:
Kevin Koltzau 2004-05-25 04:02:05 +00:00 committed by Alexandre Julliard
parent 94d74b5fed
commit 1d2d2d6bf1
5 changed files with 1066 additions and 864 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1474
dlls/wininet/ftp.c
View File

File diff suppressed because it is too large Load Diff

208
dlls/wininet/internet.c
View File

@ -72,7 +72,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(wininet);
#define RESPONSE_TIMEOUT 30 #define RESPONSE_TIMEOUT 30
#define GET_HWININET_FROM_LPWININETFINDNEXT(lpwh) \ #define GET_HWININET_FROM_LPWININETFINDNEXT(lpwh) \
(LPWININETAPPINFOW)(((LPWININETFTPSESSIONA)(lpwh->hdr.lpwhparent))->hdr.lpwhparent) (LPWININETAPPINFOW)(((LPWININETFTPSESSIONW)(lpwh->hdr.lpwhparent))->hdr.lpwhparent)
typedef struct typedef struct
@ -81,7 +81,7 @@ typedef struct
CHAR response[MAX_REPLY_LEN]; CHAR response[MAX_REPLY_LEN];
} WITHREADERROR, *LPWITHREADERROR; } WITHREADERROR, *LPWITHREADERROR;
BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData); BOOL WINAPI INTERNET_FindNextFileW(HINTERNET hFind, LPVOID lpvFindData);
HINTERNET WINAPI INTERNET_InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl, HINTERNET WINAPI INTERNET_InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext); LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD dwContext);
VOID INTERNET_ExecuteWork(); VOID INTERNET_ExecuteWork();
@ -745,13 +745,34 @@ HINTERNET WINAPI InternetConnectA(HINTERNET hInternet,
* *
*/ */
BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData) BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
{
BOOL ret;
WIN32_FIND_DATAW fd;
ret = InternetFindNextFileW(hFind, lpvFindData?&fd:NULL);
if(lpvFindData)
WININET_find_data_WtoA(&fd, (LPWIN32_FIND_DATAA)lpvFindData);
return ret;
}
/***********************************************************************
* InternetFindNextFileW (WININET.@)
*
* Continues a file search from a previous call to FindFirstFile
*
* RETURNS
* TRUE on success
* FALSE on failure
*
*/
BOOL WINAPI InternetFindNextFileW(HINTERNET hFind, LPVOID lpvFindData)
{ {
LPWININETAPPINFOW hIC = NULL; LPWININETAPPINFOW hIC = NULL;
LPWININETFINDNEXTA lpwh; LPWININETFINDNEXTW lpwh;
TRACE("\n"); TRACE("\n");
lpwh = (LPWININETFINDNEXTA) WININET_GetObject( hFind ); lpwh = (LPWININETFINDNEXTW) WININET_GetObject( hFind );
if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT) if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
{ {
@ -763,23 +784,23 @@ BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC) if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
{ {
WORKREQUEST workRequest; WORKREQUEST workRequest;
struct WORKREQ_INTERNETFINDNEXTA *req; struct WORKREQ_INTERNETFINDNEXTW *req;
workRequest.asyncall = INTERNETFINDNEXTA; workRequest.asyncall = INTERNETFINDNEXTW;
workRequest.handle = hFind; workRequest.handle = hFind;
req = &workRequest.u.InternetFindNextA; req = &workRequest.u.InternetFindNextW;
req->lpFindFileData = lpvFindData; req->lpFindFileData = lpvFindData;
return INTERNET_AsyncCall(&workRequest); return INTERNET_AsyncCall(&workRequest);
} }
else else
{ {
return INTERNET_FindNextFileA(hFind, lpvFindData); return INTERNET_FindNextFileW(hFind, lpvFindData);
} }
} }
/*********************************************************************** /***********************************************************************
* INTERNET_FindNextFileA (Internal) * INTERNET_FindNextFileW (Internal)
* *
* Continues a file search from a previous call to FindFirstFile * Continues a file search from a previous call to FindFirstFile
* *
@ -788,16 +809,16 @@ BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
* FALSE on failure * FALSE on failure
* *
*/ */
BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData) BOOL WINAPI INTERNET_FindNextFileW(HINTERNET hFind, LPVOID lpvFindData)
{ {
BOOL bSuccess = TRUE; BOOL bSuccess = TRUE;
LPWININETAPPINFOW hIC = NULL; LPWININETAPPINFOW hIC = NULL;
LPWIN32_FIND_DATAA lpFindFileData; LPWIN32_FIND_DATAW lpFindFileData;
LPWININETFINDNEXTA lpwh; LPWININETFINDNEXTW lpwh;
TRACE("\n"); TRACE("\n");
lpwh = (LPWININETFINDNEXTA) WININET_GetObject( hFind ); lpwh = (LPWININETFINDNEXTW) WININET_GetObject( hFind );
if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT) if (NULL == lpwh || lpwh->hdr.htype != WH_HFINDNEXT)
{ {
INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE); INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
@ -816,7 +837,7 @@ BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
TRACE("index(%d) size(%ld)\n", lpwh->index, lpwh->size); TRACE("index(%d) size(%ld)\n", lpwh->index, lpwh->size);
lpFindFileData = (LPWIN32_FIND_DATAA) lpvFindData; lpFindFileData = (LPWIN32_FIND_DATAW) lpvFindData;
ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA)); ZeroMemory(lpFindFileData, sizeof(WIN32_FIND_DATAA));
if (lpwh->index >= lpwh->size) if (lpwh->index >= lpwh->size)
@ -829,12 +850,12 @@ BOOL WINAPI INTERNET_FindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
FTP_ConvertFileProp(&lpwh->lpafp[lpwh->index], lpFindFileData); FTP_ConvertFileProp(&lpwh->lpafp[lpwh->index], lpFindFileData);
lpwh->index++; lpwh->index++;
TRACE("\nName: %s\nSize: %ld\n", lpFindFileData->cFileName, lpFindFileData->nFileSizeLow); TRACE("\nName: %s\nSize: %ld\n", debugstr_w(lpFindFileData->cFileName), lpFindFileData->nFileSizeLow);
lend: lend:
hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh); hIC = GET_HWININET_FROM_LPWININETFINDNEXT(lpwh);
if (hIC->lpfnStatusCB) if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC && hIC->lpfnStatusCB)
{ {
INTERNET_ASYNC_RESULT iar; INTERNET_ASYNC_RESULT iar;
@ -933,11 +954,11 @@ BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
break; break;
case WH_HFTPSESSION: case WH_HFTPSESSION:
retval = FTP_CloseSessionHandle((LPWININETFTPSESSIONA) lpwh); retval = FTP_CloseSessionHandle((LPWININETFTPSESSIONW) lpwh);
break; break;
case WH_HFINDNEXT: case WH_HFINDNEXT:
retval = FTP_CloseFindNextHandle((LPWININETFINDNEXTA) lpwh); retval = FTP_CloseFindNextHandle((LPWININETFINDNEXTW) lpwh);
break; break;
case WH_HFILE: case WH_HFILE:
@ -1460,14 +1481,49 @@ INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackA(
INTERNET_STATUS_CALLBACK retVal; INTERNET_STATUS_CALLBACK retVal;
LPWININETAPPINFOW lpwai; LPWININETAPPINFOW lpwai;
TRACE("0x%08lx\n", (ULONG)hInternet);
lpwai = (LPWININETAPPINFOW)WININET_GetObject(hInternet); lpwai = (LPWININETAPPINFOW)WININET_GetObject(hInternet);
if (!lpwai) if (!lpwai)
return NULL; return NULL;
TRACE("0x%08lx\n", (ULONG)hInternet);
if (lpwai->hdr.htype != WH_HINIT) if (lpwai->hdr.htype != WH_HINIT)
return INTERNET_INVALID_STATUS_CALLBACK; return INTERNET_INVALID_STATUS_CALLBACK;
lpwai->hdr.dwInternalFlags &= ~INET_CALLBACKW;
retVal = lpwai->lpfnStatusCB;
lpwai->lpfnStatusCB = lpfnIntCB;
return retVal;
}
/***********************************************************************
* InternetSetStatusCallbackW (WININET.@)
*
* Sets up a callback function which is called as progress is made
* during an operation.
*
* RETURNS
* Previous callback or NULL on success
* INTERNET_INVALID_STATUS_CALLBACK on failure
*
*/
INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackW(
HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
{
INTERNET_STATUS_CALLBACK retVal;
LPWININETAPPINFOW lpwai;
TRACE("0x%08lx\n", (ULONG)hInternet);
lpwai = (LPWININETAPPINFOW)WININET_GetObject(hInternet);
if (!lpwai)
return NULL;
if (lpwai->hdr.htype != WH_HINIT)
return INTERNET_INVALID_STATUS_CALLBACK;
lpwai->hdr.dwInternalFlags |= INET_CALLBACKW;
retVal = lpwai->lpfnStatusCB; retVal = lpwai->lpfnStatusCB;
lpwai->lpfnStatusCB = lpfnIntCB; lpwai->lpfnStatusCB = lpfnIntCB;
@ -2071,7 +2127,13 @@ HINTERNET WINAPI INTERNET_InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
urlComponents.nPort = INTERNET_DEFAULT_FTP_PORT; urlComponents.nPort = INTERNET_DEFAULT_FTP_PORT;
client = FTP_Connect(hInternet, hostName, urlComponents.nPort, client = FTP_Connect(hInternet, hostName, urlComponents.nPort,
userName, password, dwFlags, dwContext, INET_OPENURL); userName, password, dwFlags, dwContext, INET_OPENURL);
if(client == NULL)
break;
client1 = FtpOpenFileW(client, path, GENERIC_READ, dwFlags, dwContext); client1 = FtpOpenFileW(client, path, GENERIC_READ, dwFlags, dwContext);
if(client1 == NULL) {
InternetCloseHandle(client);
break;
}
break; break;
case INTERNET_SCHEME_HTTP: case INTERNET_SCHEME_HTTP:
@ -2096,7 +2158,6 @@ HINTERNET WINAPI INTERNET_InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
HttpAddRequestHeadersW(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD); HttpAddRequestHeadersW(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD);
if (!HTTP_HttpSendRequestW(client1, NULL, 0, NULL, 0)) { if (!HTTP_HttpSendRequestW(client1, NULL, 0, NULL, 0)) {
InternetCloseHandle(client1); InternetCloseHandle(client1);
InternetCloseHandle(client);
client1 = NULL; client1 = NULL;
break; break;
} }
@ -2425,17 +2486,17 @@ VOID INTERNET_ExecuteWork()
if (TRACE_ON(wininet)) { if (TRACE_ON(wininet)) {
static const wininet_flag_info work_request_types[] = { static const wininet_flag_info work_request_types[] = {
#define FE(x) { x, #x } #define FE(x) { x, #x }
FE(FTPPUTFILEA), FE(FTPPUTFILEW),
FE(FTPSETCURRENTDIRECTORYA), FE(FTPSETCURRENTDIRECTORYW),
FE(FTPCREATEDIRECTORYA), FE(FTPCREATEDIRECTORYW),
FE(FTPFINDFIRSTFILEA), FE(FTPFINDFIRSTFILEW),
FE(FTPGETCURRENTDIRECTORYA), FE(FTPGETCURRENTDIRECTORYW),
FE(FTPOPENFILEA), FE(FTPOPENFILEW),
FE(FTPGETFILEA), FE(FTPGETFILEW),
FE(FTPDELETEFILEA), FE(FTPDELETEFILEW),
FE(FTPREMOVEDIRECTORYA), FE(FTPREMOVEDIRECTORYW),
FE(FTPRENAMEFILEA), FE(FTPRENAMEFILEW),
FE(INTERNETFINDNEXTA), FE(INTERNETFINDNEXTW),
FE(HTTPSENDREQUESTW), FE(HTTPSENDREQUESTW),
FE(HTTPOPENREQUESTW), FE(HTTPOPENREQUESTW),
FE(SENDCALLBACK), FE(SENDCALLBACK),
@ -2456,11 +2517,11 @@ VOID INTERNET_ExecuteWork()
} }
switch (workRequest.asyncall) switch (workRequest.asyncall)
{ {
case FTPPUTFILEA: case FTPPUTFILEW:
{ {
struct WORKREQ_FTPPUTFILEA *req = &workRequest.u.FtpPutFileA; struct WORKREQ_FTPPUTFILEW *req = &workRequest.u.FtpPutFileW;
FTP_FtpPutFileA(workRequest.handle, req->lpszLocalFile, FTP_FtpPutFileW(workRequest.handle, req->lpszLocalFile,
req->lpszNewRemoteFile, req->dwFlags, req->dwContext); req->lpszNewRemoteFile, req->dwFlags, req->dwContext);
HeapFree(GetProcessHeap(), 0, req->lpszLocalFile); HeapFree(GetProcessHeap(), 0, req->lpszLocalFile);
@ -2468,62 +2529,62 @@ VOID INTERNET_ExecuteWork()
} }
break; break;
case FTPSETCURRENTDIRECTORYA: case FTPSETCURRENTDIRECTORYW:
{ {
struct WORKREQ_FTPSETCURRENTDIRECTORYA *req; struct WORKREQ_FTPSETCURRENTDIRECTORYW *req;
req = &workRequest.u.FtpSetCurrentDirectoryA; req = &workRequest.u.FtpSetCurrentDirectoryW;
FTP_FtpSetCurrentDirectoryA(workRequest.handle, req->lpszDirectory); FTP_FtpSetCurrentDirectoryW(workRequest.handle, req->lpszDirectory);
HeapFree(GetProcessHeap(), 0, req->lpszDirectory); HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
} }
break; break;
case FTPCREATEDIRECTORYA: case FTPCREATEDIRECTORYW:
{ {
struct WORKREQ_FTPCREATEDIRECTORYA *req; struct WORKREQ_FTPCREATEDIRECTORYW *req;
req = &workRequest.u.FtpCreateDirectoryA; req = &workRequest.u.FtpCreateDirectoryW;
FTP_FtpCreateDirectoryA(workRequest.handle, req->lpszDirectory); FTP_FtpCreateDirectoryW(workRequest.handle, req->lpszDirectory);
HeapFree(GetProcessHeap(), 0, req->lpszDirectory); HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
} }
break; break;
case FTPFINDFIRSTFILEA: case FTPFINDFIRSTFILEW:
{ {
struct WORKREQ_FTPFINDFIRSTFILEA *req; struct WORKREQ_FTPFINDFIRSTFILEW *req;
req = &workRequest.u.FtpFindFirstFileA; req = &workRequest.u.FtpFindFirstFileW;
FTP_FtpFindFirstFileA(workRequest.handle, req->lpszSearchFile, FTP_FtpFindFirstFileW(workRequest.handle, req->lpszSearchFile,
req->lpFindFileData, req->dwFlags, req->dwContext); req->lpFindFileData, req->dwFlags, req->dwContext);
HeapFree(GetProcessHeap(), 0, req->lpszSearchFile); HeapFree(GetProcessHeap(), 0, req->lpszSearchFile);
} }
break; break;
case FTPGETCURRENTDIRECTORYA: case FTPGETCURRENTDIRECTORYW:
{ {
struct WORKREQ_FTPGETCURRENTDIRECTORYA *req; struct WORKREQ_FTPGETCURRENTDIRECTORYW *req;
req = &workRequest.u.FtpGetCurrentDirectoryA; req = &workRequest.u.FtpGetCurrentDirectoryW;
FTP_FtpGetCurrentDirectoryA(workRequest.handle, FTP_FtpGetCurrentDirectoryW(workRequest.handle,
req->lpszDirectory, req->lpdwDirectory); req->lpszDirectory, req->lpdwDirectory);
} }
break; break;
case FTPOPENFILEA: case FTPOPENFILEW:
{ {
struct WORKREQ_FTPOPENFILEA *req = &workRequest.u.FtpOpenFileA; struct WORKREQ_FTPOPENFILEW *req = &workRequest.u.FtpOpenFileW;
FTP_FtpOpenFileA(workRequest.handle, req->lpszFilename, FTP_FtpOpenFileW(workRequest.handle, req->lpszFilename,
req->dwAccess, req->dwFlags, req->dwContext); req->dwAccess, req->dwFlags, req->dwContext);
HeapFree(GetProcessHeap(), 0, req->lpszFilename); HeapFree(GetProcessHeap(), 0, req->lpszFilename);
} }
break; break;
case FTPGETFILEA: case FTPGETFILEW:
{ {
struct WORKREQ_FTPGETFILEA *req = &workRequest.u.FtpGetFileA; struct WORKREQ_FTPGETFILEW *req = &workRequest.u.FtpGetFileW;
FTP_FtpGetFileA(workRequest.handle, req->lpszRemoteFile, FTP_FtpGetFileW(workRequest.handle, req->lpszRemoteFile,
req->lpszNewFile, req->fFailIfExists, req->lpszNewFile, req->fFailIfExists,
req->dwLocalFlagsAttribute, req->dwFlags, req->dwContext); req->dwLocalFlagsAttribute, req->dwFlags, req->dwContext);
HeapFree(GetProcessHeap(), 0, req->lpszRemoteFile); HeapFree(GetProcessHeap(), 0, req->lpszRemoteFile);
@ -2531,41 +2592,41 @@ VOID INTERNET_ExecuteWork()
} }
break; break;
case FTPDELETEFILEA: case FTPDELETEFILEW:
{ {
struct WORKREQ_FTPDELETEFILEA *req = &workRequest.u.FtpDeleteFileA; struct WORKREQ_FTPDELETEFILEW *req = &workRequest.u.FtpDeleteFileW;
FTP_FtpDeleteFileA(workRequest.handle, req->lpszFilename); FTP_FtpDeleteFileW(workRequest.handle, req->lpszFilename);
HeapFree(GetProcessHeap(), 0, req->lpszFilename); HeapFree(GetProcessHeap(), 0, req->lpszFilename);
} }
break; break;
case FTPREMOVEDIRECTORYA: case FTPREMOVEDIRECTORYW:
{ {
struct WORKREQ_FTPREMOVEDIRECTORYA *req; struct WORKREQ_FTPREMOVEDIRECTORYW *req;
req = &workRequest.u.FtpRemoveDirectoryA; req = &workRequest.u.FtpRemoveDirectoryW;
FTP_FtpRemoveDirectoryA(workRequest.handle, req->lpszDirectory); FTP_FtpRemoveDirectoryW(workRequest.handle, req->lpszDirectory);
HeapFree(GetProcessHeap(), 0, req->lpszDirectory); HeapFree(GetProcessHeap(), 0, req->lpszDirectory);
} }
break; break;
case FTPRENAMEFILEA: case FTPRENAMEFILEW:
{ {
struct WORKREQ_FTPRENAMEFILEA *req = &workRequest.u.FtpRenameFileA; struct WORKREQ_FTPRENAMEFILEW *req = &workRequest.u.FtpRenameFileW;
FTP_FtpRenameFileA(workRequest.handle, req->lpszSrcFile, req->lpszDestFile); FTP_FtpRenameFileW(workRequest.handle, req->lpszSrcFile, req->lpszDestFile);
HeapFree(GetProcessHeap(), 0, req->lpszSrcFile); HeapFree(GetProcessHeap(), 0, req->lpszSrcFile);
HeapFree(GetProcessHeap(), 0, req->lpszDestFile); HeapFree(GetProcessHeap(), 0, req->lpszDestFile);
} }
break; break;
case INTERNETFINDNEXTA: case INTERNETFINDNEXTW:
{ {
struct WORKREQ_INTERNETFINDNEXTA *req; struct WORKREQ_INTERNETFINDNEXTW *req;
req = &workRequest.u.InternetFindNextA; req = &workRequest.u.InternetFindNextW;
INTERNET_FindNextFileA(workRequest.handle, req->lpFindFileData); INTERNET_FindNextFileW(workRequest.handle, req->lpFindFileData);
} }
break; break;
@ -2643,12 +2704,13 @@ LPSTR INTERNET_GetResponseBuffer()
* *
*/ */
LPSTR INTERNET_GetNextLine(INT nSocket, LPSTR lpszBuffer, LPDWORD dwBuffer) LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen)
{ {
struct timeval tv; struct timeval tv;
fd_set infd; fd_set infd;
BOOL bSuccess = FALSE; BOOL bSuccess = FALSE;
INT nRecv = 0; INT nRecv = 0;
LPSTR lpszBuffer = INTERNET_GetResponseBuffer();
TRACE("\n"); TRACE("\n");
@ -2657,7 +2719,7 @@ LPSTR INTERNET_GetNextLine(INT nSocket, LPSTR lpszBuffer, LPDWORD dwBuffer)
tv.tv_sec=RESPONSE_TIMEOUT; tv.tv_sec=RESPONSE_TIMEOUT;
tv.tv_usec=0; tv.tv_usec=0;
while (nRecv < *dwBuffer) while (nRecv < MAX_REPLY_LEN)
{ {
if (select(nSocket+1,&infd,NULL,NULL,&tv) > 0) if (select(nSocket+1,&infd,NULL,NULL,&tv) > 0)
{ {
@ -2686,7 +2748,7 @@ lend:
if (bSuccess) if (bSuccess)
{ {
lpszBuffer[nRecv] = '\0'; lpszBuffer[nRecv] = '\0';
*dwBuffer = nRecv - 1; *dwLen = nRecv - 1;
TRACE(":%d %s\n", nRecv, lpszBuffer); TRACE(":%d %s\n", nRecv, lpszBuffer);
return lpszBuffer; return lpszBuffer;
} }

179
dlls/wininet/internet.h
View File

@ -70,6 +70,42 @@ inline static LPWSTR WININET_strdupW( LPCWSTR str )
return ret; return ret;
} }
inline static LPWSTR WININET_strdup_AtoW( LPCSTR str )
{
int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0);
LPWSTR ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
if (ret)
MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len);
return ret;
}
inline static LPSTR WININET_strdup_WtoA( LPCWSTR str )
{
int len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
LPSTR ret = HeapAlloc( GetProcessHeap(), 0, len );
if (ret)
WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL);
return ret;
}
inline static void WININET_find_data_WtoA(LPWIN32_FIND_DATAW dataW, LPWIN32_FIND_DATAA dataA)
{
dataA->dwFileAttributes = dataW->dwFileAttributes;
dataA->ftCreationTime = dataW->ftCreationTime;
dataA->ftLastAccessTime = dataW->ftLastAccessTime;
dataA->ftLastWriteTime = dataW->ftLastWriteTime;
dataA->nFileSizeHigh = dataW->nFileSizeHigh;
dataA->nFileSizeLow = dataW->nFileSizeLow;
dataA->dwReserved0 = dataW->dwReserved0;
dataA->dwReserved1 = dataW->dwReserved1;
WideCharToMultiByte(CP_ACP, 0, dataW->cFileName, -1,
dataA->cFileName, sizeof(dataA->cFileName),
NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, dataW->cAlternateFileName, -1,
dataA->cAlternateFileName, sizeof(dataA->cAlternateFileName),
NULL, NULL);
}
typedef enum typedef enum
{ {
WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET, WH_HINIT = INTERNET_HANDLE_TYPE_INTERNET,
@ -82,6 +118,7 @@ typedef enum
} WH_TYPE; } WH_TYPE;
#define INET_OPENURL 0x0001 #define INET_OPENURL 0x0001
#define INET_CALLBACKW 0x0002
typedef struct _WININETHANDLEHEADER typedef struct _WININETHANDLEHEADER
{ {
@ -161,19 +198,19 @@ typedef struct
struct sockaddr_in socketAddress; struct sockaddr_in socketAddress;
struct sockaddr_in lstnSocketAddress; struct sockaddr_in lstnSocketAddress;
struct hostent *phostent; struct hostent *phostent;
LPSTR lpszPassword; LPWSTR lpszPassword;
LPSTR lpszUserName; LPWSTR lpszUserName;
} WININETFTPSESSIONA, *LPWININETFTPSESSIONA; } WININETFTPSESSIONW, *LPWININETFTPSESSIONW;
typedef struct typedef struct
{ {
BOOL bIsDirectory; BOOL bIsDirectory;
LPSTR lpszName; LPWSTR lpszName;
DWORD nSize; DWORD nSize;
struct tm tmLastModified; struct tm tmLastModified;
unsigned short permissions; unsigned short permissions;
} FILEPROPERTIESA, *LPFILEPROPERTIESA; } FILEPROPERTIESW, *LPFILEPROPERTIESW;
typedef struct typedef struct
@ -181,97 +218,97 @@ typedef struct
WININETHANDLEHEADER hdr; WININETHANDLEHEADER hdr;
int index; int index;
DWORD size; DWORD size;
LPFILEPROPERTIESA lpafp; LPFILEPROPERTIESW lpafp;
} WININETFINDNEXTA, *LPWININETFINDNEXTA; } WININETFINDNEXTW, *LPWININETFINDNEXTW;
typedef enum typedef enum
{ {
FTPPUTFILEA, FTPPUTFILEW,
FTPSETCURRENTDIRECTORYA, FTPSETCURRENTDIRECTORYW,
FTPCREATEDIRECTORYA, FTPCREATEDIRECTORYW,
FTPFINDFIRSTFILEA, FTPFINDFIRSTFILEW,
FTPGETCURRENTDIRECTORYA, FTPGETCURRENTDIRECTORYW,
FTPOPENFILEA, FTPOPENFILEW,
FTPGETFILEA, FTPGETFILEW,
FTPDELETEFILEA, FTPDELETEFILEW,
FTPREMOVEDIRECTORYA, FTPREMOVEDIRECTORYW,
FTPRENAMEFILEA, FTPRENAMEFILEW,
INTERNETFINDNEXTA, INTERNETFINDNEXTW,
HTTPSENDREQUESTW, HTTPSENDREQUESTW,
HTTPOPENREQUESTW, HTTPOPENREQUESTW,
SENDCALLBACK, SENDCALLBACK,
INTERNETOPENURLW, INTERNETOPENURLW,
} ASYNC_FUNC; } ASYNC_FUNC;
struct WORKREQ_FTPPUTFILEA struct WORKREQ_FTPPUTFILEW
{ {
LPSTR lpszLocalFile; LPWSTR lpszLocalFile;
LPSTR lpszNewRemoteFile; LPWSTR lpszNewRemoteFile;
DWORD dwFlags; DWORD dwFlags;
DWORD dwContext; DWORD dwContext;
}; };
struct WORKREQ_FTPSETCURRENTDIRECTORYA struct WORKREQ_FTPSETCURRENTDIRECTORYW
{ {
LPSTR lpszDirectory; LPWSTR lpszDirectory;
}; };
struct WORKREQ_FTPCREATEDIRECTORYA struct WORKREQ_FTPCREATEDIRECTORYW
{ {
LPSTR lpszDirectory; LPWSTR lpszDirectory;
}; };
struct WORKREQ_FTPFINDFIRSTFILEA struct WORKREQ_FTPFINDFIRSTFILEW
{ {
LPSTR lpszSearchFile; LPWSTR lpszSearchFile;
LPWIN32_FIND_DATAA lpFindFileData; LPWIN32_FIND_DATAW lpFindFileData;
DWORD dwFlags; DWORD dwFlags;
DWORD dwContext; DWORD dwContext;
}; };
struct WORKREQ_FTPGETCURRENTDIRECTORYA struct WORKREQ_FTPGETCURRENTDIRECTORYW
{ {
LPSTR lpszDirectory; LPWSTR lpszDirectory;
DWORD *lpdwDirectory; DWORD *lpdwDirectory;
}; };
struct WORKREQ_FTPOPENFILEA struct WORKREQ_FTPOPENFILEW
{ {
LPSTR lpszFilename; LPWSTR lpszFilename;
DWORD dwAccess; DWORD dwAccess;
DWORD dwFlags; DWORD dwFlags;
DWORD dwContext; DWORD dwContext;
}; };
struct WORKREQ_FTPGETFILEA struct WORKREQ_FTPGETFILEW
{ {
LPSTR lpszRemoteFile; LPWSTR lpszRemoteFile;
LPSTR lpszNewFile; LPWSTR lpszNewFile;
BOOL fFailIfExists; BOOL fFailIfExists;
DWORD dwLocalFlagsAttribute; DWORD dwLocalFlagsAttribute;
DWORD dwFlags; DWORD dwFlags;
DWORD dwContext; DWORD dwContext;
}; };
struct WORKREQ_FTPDELETEFILEA struct WORKREQ_FTPDELETEFILEW
{ {
LPSTR lpszFilename; LPWSTR lpszFilename;
}; };
struct WORKREQ_FTPREMOVEDIRECTORYA struct WORKREQ_FTPREMOVEDIRECTORYW
{ {
LPSTR lpszDirectory; LPWSTR lpszDirectory;
}; };
struct WORKREQ_FTPRENAMEFILEA struct WORKREQ_FTPRENAMEFILEW
{ {
LPSTR lpszSrcFile; LPWSTR lpszSrcFile;
LPSTR lpszDestFile; LPWSTR lpszDestFile;
}; };
struct WORKREQ_INTERNETFINDNEXTA struct WORKREQ_INTERNETFINDNEXTW
{ {
LPWIN32_FIND_DATAA lpFindFileData; LPWIN32_FIND_DATAW lpFindFileData;
}; };
struct WORKREQ_HTTPOPENREQUESTW struct WORKREQ_HTTPOPENREQUESTW
@ -318,17 +355,17 @@ typedef struct WORKREQ
HINTERNET handle; HINTERNET handle;
union { union {
struct WORKREQ_FTPPUTFILEA FtpPutFileA; struct WORKREQ_FTPPUTFILEW FtpPutFileW;
struct WORKREQ_FTPSETCURRENTDIRECTORYA FtpSetCurrentDirectoryA; struct WORKREQ_FTPSETCURRENTDIRECTORYW FtpSetCurrentDirectoryW;
struct WORKREQ_FTPCREATEDIRECTORYA FtpCreateDirectoryA; struct WORKREQ_FTPCREATEDIRECTORYW FtpCreateDirectoryW;
struct WORKREQ_FTPFINDFIRSTFILEA FtpFindFirstFileA; struct WORKREQ_FTPFINDFIRSTFILEW FtpFindFirstFileW;
struct WORKREQ_FTPGETCURRENTDIRECTORYA FtpGetCurrentDirectoryA; struct WORKREQ_FTPGETCURRENTDIRECTORYW FtpGetCurrentDirectoryW;
struct WORKREQ_FTPOPENFILEA FtpOpenFileA; struct WORKREQ_FTPOPENFILEW FtpOpenFileW;
struct WORKREQ_FTPGETFILEA FtpGetFileA; struct WORKREQ_FTPGETFILEW FtpGetFileW;
struct WORKREQ_FTPDELETEFILEA FtpDeleteFileA; struct WORKREQ_FTPDELETEFILEW FtpDeleteFileW;
struct WORKREQ_FTPREMOVEDIRECTORYA FtpRemoveDirectoryA; struct WORKREQ_FTPREMOVEDIRECTORYW FtpRemoveDirectoryW;
struct WORKREQ_FTPRENAMEFILEA FtpRenameFileA; struct WORKREQ_FTPRENAMEFILEW FtpRenameFileW;
struct WORKREQ_INTERNETFINDNEXTA InternetFindNextA; struct WORKREQ_INTERNETFINDNEXTW InternetFindNextW;
struct WORKREQ_HTTPOPENREQUESTW HttpOpenRequestW; struct WORKREQ_HTTPOPENREQUESTW HttpOpenRequestW;
struct WORKREQ_HTTPSENDREQUESTW HttpSendRequestW; struct WORKREQ_HTTPSENDREQUESTW HttpSendRequestW;
struct WORKREQ_SENDCALLBACK SendCallback; struct WORKREQ_SENDCALLBACK SendCallback;
@ -364,26 +401,26 @@ void INTERNET_SetLastError(DWORD dwError);
DWORD INTERNET_GetLastError(); DWORD INTERNET_GetLastError();
BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest); BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest);
LPSTR INTERNET_GetResponseBuffer(); LPSTR INTERNET_GetResponseBuffer();
LPSTR INTERNET_GetNextLine(INT nSocket, LPSTR lpszBuffer, LPDWORD dwBuffer); LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen);
BOOL FTP_CloseSessionHandle(LPWININETFTPSESSIONA lpwfs); BOOL FTP_CloseSessionHandle(LPWININETFTPSESSIONW lpwfs);
BOOL FTP_CloseFindNextHandle(LPWININETFINDNEXTA lpwfn); BOOL FTP_CloseFindNextHandle(LPWININETFINDNEXTW lpwfn);
BOOL FTP_CloseFileTransferHandle(LPWININETFILE lpwfn); BOOL FTP_CloseFileTransferHandle(LPWININETFILE lpwfn);
BOOLAPI FTP_FtpPutFileA(HINTERNET hConnect, LPCSTR lpszLocalFile, BOOLAPI FTP_FtpPutFileW(HINTERNET hConnect, LPCWSTR lpszLocalFile,
LPCSTR lpszNewRemoteFile, DWORD dwFlags, DWORD dwContext); LPCWSTR lpszNewRemoteFile, DWORD dwFlags, DWORD dwContext);
BOOLAPI FTP_FtpSetCurrentDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory); BOOLAPI FTP_FtpSetCurrentDirectoryW(HINTERNET hConnect, LPCWSTR lpszDirectory);
BOOLAPI FTP_FtpCreateDirectoryA(HINTERNET hConnect, LPCSTR lpszDirectory); BOOLAPI FTP_FtpCreateDirectoryW(HINTERNET hConnect, LPCWSTR lpszDirectory);
INTERNETAPI HINTERNET WINAPI FTP_FtpFindFirstFileA(HINTERNET hConnect, INTERNETAPI HINTERNET WINAPI FTP_FtpFindFirstFileW(HINTERNET hConnect,
LPCSTR lpszSearchFile, LPWIN32_FIND_DATAA lpFindFileData, DWORD dwFlags, DWORD dwContext); LPCWSTR lpszSearchFile, LPWIN32_FIND_DATAW lpFindFileData, DWORD dwFlags, DWORD dwContext);
BOOLAPI FTP_FtpGetCurrentDirectoryA(HINTERNET hFtpSession, LPSTR lpszCurrentDirectory, BOOLAPI FTP_FtpGetCurrentDirectoryW(HINTERNET hFtpSession, LPWSTR lpszCurrentDirectory,
LPDWORD lpdwCurrentDirectory); LPDWORD lpdwCurrentDirectory);
BOOL FTP_ConvertFileProp(LPFILEPROPERTIESA lpafp, LPWIN32_FIND_DATAA lpFindFileData); BOOL FTP_ConvertFileProp(LPFILEPROPERTIESW lpafp, LPWIN32_FIND_DATAW lpFindFileData);
BOOL FTP_FtpRenameFileA(HINTERNET hFtpSession, LPCSTR lpszSrc, LPCSTR lpszDest); BOOL FTP_FtpRenameFileW(HINTERNET hFtpSession, LPCWSTR lpszSrc, LPCWSTR lpszDest);
BOOL FTP_FtpRemoveDirectoryA(HINTERNET hFtpSession, LPCSTR lpszDirectory); BOOL FTP_FtpRemoveDirectoryW(HINTERNET hFtpSession, LPCWSTR lpszDirectory);
BOOL FTP_FtpDeleteFileA(HINTERNET hFtpSession, LPCSTR lpszFileName); BOOL FTP_FtpDeleteFileW(HINTERNET hFtpSession, LPCWSTR lpszFileName);
HINTERNET FTP_FtpOpenFileA(HINTERNET hFtpSession, LPCSTR lpszFileName, HINTERNET FTP_FtpOpenFileW(HINTERNET hFtpSession, LPCWSTR lpszFileName,
DWORD fdwAccess, DWORD dwFlags, DWORD dwContext); DWORD fdwAccess, DWORD dwFlags, DWORD dwContext);
BOOLAPI FTP_FtpGetFileA(HINTERNET hInternet, LPCSTR lpszRemoteFile, LPCSTR lpszNewFile, BOOLAPI FTP_FtpGetFileW(HINTERNET hInternet, LPCWSTR lpszRemoteFile, LPCWSTR lpszNewFile,
BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags, BOOL fFailIfExists, DWORD dwLocalFlagsAttribute, DWORD dwInternetFlags,
DWORD dwContext); DWORD dwContext);

9
dlls/wininet/utility.c
View File

@ -219,6 +219,7 @@ VOID SendAsyncCallbackInt(LPWININETAPPINFOW hIC, HINTERNET hHttpSession,
DWORD dwContext, DWORD dwInternetStatus, LPVOID DWORD dwContext, DWORD dwInternetStatus, LPVOID
lpvStatusInfo, DWORD dwStatusInfoLength) lpvStatusInfo, DWORD dwStatusInfoLength)
{ {
LPVOID lpvNewInfo = NULL;
if (! (hIC->lpfnStatusCB)) if (! (hIC->lpfnStatusCB))
return; return;
@ -229,8 +230,14 @@ VOID SendAsyncCallbackInt(LPWININETAPPINFOW hIC, HINTERNET hHttpSession,
TRACE("--> Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus)); TRACE("--> Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus));
if(!(hIC->hdr.dwInternalFlags & INET_CALLBACKW)) {
if(dwInternetStatus == INTERNET_STATUS_RESOLVING_NAME)
lpvNewInfo = WININET_strdup_WtoA(lpvStatusInfo);
}
hIC->lpfnStatusCB(hHttpSession, dwContext, dwInternetStatus, hIC->lpfnStatusCB(hHttpSession, dwContext, dwInternetStatus,
lpvStatusInfo, dwStatusInfoLength); lpvNewInfo?lpvNewInfo:lpvStatusInfo, dwStatusInfoLength);
if(lpvNewInfo)
HeapFree(GetProcessHeap(), 0, lpvNewInfo);
TRACE("<-- Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus)); TRACE("<-- Callback %ld (%s)\n",dwInternetStatus, get_callback_name(dwInternetStatus));
} }

12
dlls/wininet/wininet.spec
View File

@ -54,7 +54,7 @@
@ stdcall FtpCreateDirectoryA(ptr str) @ stdcall FtpCreateDirectoryA(ptr str)
@ stdcall FtpCreateDirectoryW(ptr wstr) @ stdcall FtpCreateDirectoryW(ptr wstr)
@ stdcall FtpDeleteFileA(ptr str) @ stdcall FtpDeleteFileA(ptr str)
@ stub FtpDeleteFileW @ stdcall FtpDeleteFileW(ptr wstr)
@ stdcall FtpFindFirstFileA(ptr str ptr long long) @ stdcall FtpFindFirstFileA(ptr str ptr long long)
@ stdcall FtpFindFirstFileW(ptr wstr ptr long long) @ stdcall FtpFindFirstFileW(ptr wstr ptr long long)
@ stdcall FtpGetCurrentDirectoryA(ptr str ptr) @ stdcall FtpGetCurrentDirectoryA(ptr str ptr)
@ -64,11 +64,11 @@
@ stdcall FtpOpenFileA(ptr str long long long) @ stdcall FtpOpenFileA(ptr str long long long)
@ stdcall FtpOpenFileW(ptr wstr long long long) @ stdcall FtpOpenFileW(ptr wstr long long long)
@ stdcall FtpPutFileA(ptr str str long long) @ stdcall FtpPutFileA(ptr str str long long)
@ stub FtpPutFileW @ stdcall FtpPutFileW(ptr wstr wstr long long)
@ stdcall FtpRemoveDirectoryA(ptr str) @ stdcall FtpRemoveDirectoryA(ptr str)
@ stub FtpRemoveDirectoryW @ stdcall FtpRemoveDirectoryW(ptr wstr)
@ stdcall FtpRenameFileA(ptr str str) @ stdcall FtpRenameFileA(ptr str str)
@ stub FtpRenameFileW @ stdcall FtpRenameFileW(ptr wstr wstr)
@ stdcall FtpSetCurrentDirectoryA(ptr str) @ stdcall FtpSetCurrentDirectoryA(ptr str)
@ stdcall FtpSetCurrentDirectoryW(ptr wstr) @ stdcall FtpSetCurrentDirectoryW(ptr wstr)
@ stdcall GetUrlCacheConfigInfoA(ptr ptr long) @ stdcall GetUrlCacheConfigInfoA(ptr ptr long)
@ -123,7 +123,7 @@
@ stub InternetDial @ stub InternetDial
@ stdcall InternetErrorDlg(long long long long ptr) @ stdcall InternetErrorDlg(long long long long ptr)
@ stdcall InternetFindNextFileA(ptr ptr) @ stdcall InternetFindNextFileA(ptr ptr)
@ stub InternetFindNextFileW @ stdcall InternetFindNextFileW(ptr ptr)
@ stub InternetGetCertByURL @ stub InternetGetCertByURL
@ stdcall InternetGetConnectedState(ptr long) @ stdcall InternetGetConnectedState(ptr long)
@ stdcall InternetGetConnectedStateExW(ptr ptr long long) @ stdcall InternetGetConnectedStateExW(ptr ptr long long)
@ -156,7 +156,7 @@
@ stdcall InternetSetOptionExW(ptr long ptr long long) @ stdcall InternetSetOptionExW(ptr long ptr long long)
@ stdcall InternetSetStatusCallback(ptr ptr) InternetSetStatusCallbackA @ stdcall InternetSetStatusCallback(ptr ptr) InternetSetStatusCallbackA
@ stdcall InternetSetStatusCallbackA(ptr ptr) @ stdcall InternetSetStatusCallbackA(ptr ptr)
@ stub InternetSetStatusCallbackW @ stdcall InternetSetStatusCallbackW(ptr ptr)
@ stub InternetShowSecurityInfoByURL @ stub InternetShowSecurityInfoByURL
@ stub InternetTimeFromSystemTime @ stub InternetTimeFromSystemTime
@ stub InternetTimeToSystemTime @ stub InternetTimeToSystemTime