#define MAXHOSTNAME 100 /* from http.c */
+#if defined(__MINGW32__) || defined (_MSC_VER)
+#include <ws2tcpip.h>
+#endif
+
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
+#ifdef HAVE_POLL_H
+#include <poll.h>
+#endif
+#ifdef HAVE_SYS_POLL_H
+# include <sys/poll.h>
+#endif
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
#endif
#include "winerror.h"
#define NO_SHLWAPI_STREAM
#include "shlwapi.h"
-#include "wincrypt.h"
#include "wine/exception.h"
#include "resource.h"
#include "wine/unicode.h"
-#define CP_UNIXCP CP_THREAD_ACP
WINE_DEFAULT_DEBUG_CHANNEL(wininet);
CHAR response[MAX_REPLY_LEN];
} WITHREADERROR, *LPWITHREADERROR;
-static VOID INTERNET_CloseHandle(LPWININETHANDLEHEADER hdr);
-HINTERNET WINAPI INTERNET_InternetOpenUrlW(LPWININETAPPINFOW hIC, LPCWSTR lpszUrl,
- LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext);
-
static DWORD g_dwTlsErrIndex = TLS_OUT_OF_INDEXES;
static HMODULE WININET_hModule;
};
static CRITICAL_SECTION WININET_cs = { &WININET_cs_debug, -1, 0, 0, 0, 0 };
-static LPWININETHANDLEHEADER *WININET_Handles;
+static object_header_t **WININET_Handles;
static UINT WININET_dwNextHandle;
static UINT WININET_dwMaxHandles;
-HINTERNET WININET_AllocHandle( LPWININETHANDLEHEADER info )
+typedef struct
{
- LPWININETHANDLEHEADER *p;
+ DWORD dwProxyEnabled;
+ LPWSTR lpszProxyServer;
+ LPWSTR lpszProxyBypass;
+} proxyinfo_t;
+
+static const WCHAR szInternetSettings[] =
+ { 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
+ 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
+ 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0 };
+static const WCHAR szProxyServer[] = { 'P','r','o','x','y','S','e','r','v','e','r', 0 };
+static const WCHAR szProxyEnable[] = { 'P','r','o','x','y','E','n','a','b','l','e', 0 };
+
+HINTERNET WININET_AllocHandle( object_header_t *info )
+{
+ object_header_t **p;
UINT handle = 0, num;
list_init( &info->children );
{
num = HANDLE_CHUNK_SIZE;
p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof (UINT)* num);
+ sizeof (*WININET_Handles)* num);
if( !p )
goto end;
WININET_Handles = p;
{
num = WININET_dwMaxHandles + HANDLE_CHUNK_SIZE;
p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
- WININET_Handles, sizeof (UINT)* num);
+ WININET_Handles, sizeof (*WININET_Handles)* num);
if( !p )
goto end;
WININET_Handles = p;
return info->hInternet = (HINTERNET) (handle+1);
}
-LPWININETHANDLEHEADER WININET_AddRef( LPWININETHANDLEHEADER info )
+object_header_t *WININET_AddRef( object_header_t *info )
{
- info->dwRefCount++;
- TRACE("%p -> refcount = %d\n", info, info->dwRefCount );
+ ULONG refs = InterlockedIncrement(&info->refs);
+ TRACE("%p -> refcount = %d\n", info, refs );
return info;
}
-LPWININETHANDLEHEADER WININET_GetObject( HINTERNET hinternet )
+object_header_t *WININET_GetObject( HINTERNET hinternet )
{
- LPWININETHANDLEHEADER info = NULL;
+ object_header_t *info = NULL;
UINT handle = (UINT) hinternet;
EnterCriticalSection( &WININET_cs );
return info;
}
-BOOL WININET_Release( LPWININETHANDLEHEADER info )
+BOOL WININET_Release( object_header_t *info )
{
- info->dwRefCount--;
- TRACE( "object %p refcount = %d\n", info, info->dwRefCount );
- if( !info->dwRefCount )
+ ULONG refs = InterlockedDecrement(&info->refs);
+ TRACE( "object %p refcount = %d\n", info, refs );
+ if( !refs )
{
- if ( info->close_connection )
+ if ( info->vtbl->CloseConnection )
{
TRACE( "closing connection %p\n", info);
- info->close_connection( info );
+ info->vtbl->CloseConnection( info );
+ }
+ /* Don't send a callback if this is a session handle created with InternetOpenUrl */
+ if ((info->htype != WH_HHTTPSESSION && info->htype != WH_HFTPSESSION)
+ || !(info->dwInternalFlags & INET_OPENURL))
+ {
+ INTERNET_SendCallback(info, info->dwContext,
+ INTERNET_STATUS_HANDLE_CLOSING, &info->hInternet,
+ sizeof(HINTERNET));
}
- INTERNET_SendCallback(info, info->dwContext,
- INTERNET_STATUS_HANDLE_CLOSING, &info->hInternet,
- sizeof(HINTERNET));
TRACE( "destroying object %p\n", info);
if ( info->htype != WH_HINIT )
list_remove( &info->entry );
- info->destroy( info );
+ info->vtbl->Destroy( info );
}
return TRUE;
}
{
BOOL ret = FALSE;
UINT handle = (UINT) hinternet;
- LPWININETHANDLEHEADER info = NULL, child, next;
+ object_header_t *info = NULL, *child, *next;
EnterCriticalSection( &WININET_cs );
if( info )
{
/* Free all children as native does */
- LIST_FOR_EACH_ENTRY_SAFE( child, next, &info->children, WININETHANDLEHEADER, entry )
+ LIST_FOR_EACH_ENTRY_SAFE( child, next, &info->children, object_header_t, entry )
{
TRACE( "freeing child handle %d for parent handle %d\n",
(UINT)child->hInternet, handle+1);
URLCacheContainers_CreateDefaults();
- WININET_hModule = (HMODULE)hinstDLL;
+ WININET_hModule = hinstDLL;
case DLL_THREAD_ATTACH:
break;
case DLL_PROCESS_DETACH:
+ NETCON_unload();
+
URLCacheContainers_DeleteAll();
if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
return TRUE;
}
+/***********************************************************************
+ * INTERNET_SaveProxySettings
+ *
+ * Stores the proxy settings given by lpwai into the registry
+ *
+ * RETURNS
+ * ERROR_SUCCESS if no error, or error code on fail
+ */
+static LONG INTERNET_SaveProxySettings( proxyinfo_t *lpwpi )
+{
+ HKEY key;
+ LONG ret;
+
+ if ((ret = RegOpenKeyW( HKEY_CURRENT_USER, szInternetSettings, &key )))
+ return ret;
+
+ if ((ret = RegSetValueExW( key, szProxyEnable, 0, REG_DWORD, (BYTE*)&lpwpi->dwProxyEnabled, sizeof(DWORD))))
+ {
+ RegCloseKey( key );
+ return ret;
+ }
+
+ if (lpwpi->lpszProxyServer)
+ {
+ if ((ret = RegSetValueExW( key, szProxyServer, 0, REG_SZ, (BYTE*)lpwpi->lpszProxyServer, sizeof(WCHAR) * (lstrlenW(lpwpi->lpszProxyServer) + 1))))
+ {
+ RegCloseKey( key );
+ return ret;
+ }
+ }
+ else
+ {
+ if ((ret = RegDeleteValueW( key, szProxyServer )))
+ {
+ RegCloseKey( key );
+ return ret;
+ }
+ }
+
+ RegCloseKey(key);
+ return ERROR_SUCCESS;
+}
+
+/***********************************************************************
+ * INTERNET_FindProxyForProtocol
+ *
+ * Searches the proxy string for a proxy of the given protocol.
+ * Returns the found proxy, or the default proxy if none of the given
+ * protocol is found.
+ *
+ * PARAMETERS
+ * szProxy [In] proxy string to search
+ * proto [In] protocol to search for, e.g. "http"
+ * foundProxy [Out] found proxy
+ * foundProxyLen [In/Out] length of foundProxy buffer, in WCHARs
+ *
+ * RETURNS
+ * TRUE if a proxy is found, FALSE if not. If foundProxy is too short,
+ * *foundProxyLen is set to the required size in WCHARs, including the
+ * NULL terminator, and the last error is set to ERROR_INSUFFICIENT_BUFFER.
+ */
+BOOL INTERNET_FindProxyForProtocol(LPCWSTR szProxy, LPCWSTR proto, WCHAR *foundProxy, DWORD *foundProxyLen)
+{
+ LPCWSTR ptr;
+ BOOL ret = FALSE;
+
+ TRACE("(%s, %s)\n", debugstr_w(szProxy), debugstr_w(proto));
+
+ /* First, look for the specified protocol (proto=scheme://host:port) */
+ for (ptr = szProxy; !ret && ptr && *ptr; )
+ {
+ LPCWSTR end, equal;
+
+ if (!(end = strchrW(ptr, ' ')))
+ end = ptr + strlenW(ptr);
+ if ((equal = strchrW(ptr, '=')) && equal < end &&
+ equal - ptr == strlenW(proto) &&
+ !strncmpiW(proto, ptr, strlenW(proto)))
+ {
+ if (end - equal > *foundProxyLen)
+ {
+ WARN("buffer too short for %s\n",
+ debugstr_wn(equal + 1, end - equal - 1));
+ *foundProxyLen = end - equal;
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ }
+ else
+ {
+ memcpy(foundProxy, equal + 1, (end - equal) * sizeof(WCHAR));
+ foundProxy[end - equal] = 0;
+ ret = TRUE;
+ }
+ }
+ if (*end == ' ')
+ ptr = end + 1;
+ else
+ ptr = end;
+ }
+ if (!ret)
+ {
+ /* It wasn't found: look for no protocol */
+ for (ptr = szProxy; !ret && ptr && *ptr; )
+ {
+ LPCWSTR end, equal;
+
+ if (!(end = strchrW(ptr, ' ')))
+ end = ptr + strlenW(ptr);
+ if (!(equal = strchrW(ptr, '=')))
+ {
+ if (end - ptr + 1 > *foundProxyLen)
+ {
+ WARN("buffer too short for %s\n",
+ debugstr_wn(ptr, end - ptr));
+ *foundProxyLen = end - ptr + 1;
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ }
+ else
+ {
+ memcpy(foundProxy, ptr, (end - ptr) * sizeof(WCHAR));
+ foundProxy[end - ptr] = 0;
+ ret = TRUE;
+ }
+ }
+ if (*end == ' ')
+ ptr = end + 1;
+ else
+ ptr = end;
+ }
+ }
+ if (ret)
+ TRACE("found proxy for %s: %s\n", debugstr_w(proto),
+ debugstr_w(foundProxy));
+ return ret;
+}
/***********************************************************************
* InternetInitializeAutoProxyDll (WININET.@)
BOOL WINAPI InternetInitializeAutoProxyDll(DWORD dwReserved)
{
FIXME("STUB\n");
- INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
DWORD dwAutoProxyUrlLength, DWORD dwDetectFlags)
{
FIXME("STUB\n");
- INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
+static void FreeProxyInfo( proxyinfo_t *lpwpi )
+{
+ HeapFree(GetProcessHeap(), 0, lpwpi->lpszProxyServer);
+ HeapFree(GetProcessHeap(), 0, lpwpi->lpszProxyBypass);
+}
/***********************************************************************
- * INTERNET_ConfigureProxyFromReg
+ * INTERNET_LoadProxySettings
+ *
+ * Loads proxy information from the registry or environment into lpwpi.
+ *
+ * The caller should call FreeProxyInfo when done with lpwpi.
*
* FIXME:
* The proxy may be specified in the form 'http=proxy.my.org'
* Presumably that means there can be ftp=ftpproxy.my.org too.
*/
-static BOOL INTERNET_ConfigureProxyFromReg( LPWININETAPPINFOW lpwai )
+static LONG INTERNET_LoadProxySettings( proxyinfo_t *lpwpi )
{
HKEY key;
- DWORD r, keytype, len, enabled;
- LPCSTR lpszInternetSettings =
- "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
- static const WCHAR szProxyServer[] = { 'P','r','o','x','y','S','e','r','v','e','r', 0 };
+ DWORD type, len;
+ LPCSTR envproxy;
+ LONG ret;
- r = RegOpenKeyA(HKEY_CURRENT_USER, lpszInternetSettings, &key);
- if ( r != ERROR_SUCCESS )
- return FALSE;
+ if ((ret = RegOpenKeyW( HKEY_CURRENT_USER, szInternetSettings, &key )))
+ return ret;
- len = sizeof enabled;
- r = RegQueryValueExA( key, "ProxyEnable", NULL, &keytype,
- (BYTE*)&enabled, &len);
- if( (r == ERROR_SUCCESS) && enabled )
+ len = sizeof(DWORD);
+ if (RegQueryValueExW( key, szProxyEnable, NULL, &type, (BYTE *)&lpwpi->dwProxyEnabled, &len ) || type != REG_DWORD)
+ {
+ lpwpi->dwProxyEnabled = 0;
+ if((ret = RegSetValueExW( key, szProxyEnable, 0, REG_DWORD, (BYTE *)&lpwpi->dwProxyEnabled, sizeof(DWORD) )))
+ {
+ RegCloseKey( key );
+ return ret;
+ }
+ }
+
+ if (!(envproxy = getenv( "http_proxy" )) || lpwpi->dwProxyEnabled)
{
TRACE("Proxy is enabled.\n");
/* figure out how much memory the proxy setting takes */
- r = RegQueryValueExW( key, szProxyServer, NULL, &keytype,
- NULL, &len);
- if( (r == ERROR_SUCCESS) && len && (keytype == REG_SZ) )
+ if (!RegQueryValueExW( key, szProxyServer, NULL, &type, NULL, &len ) && len && (type == REG_SZ))
{
LPWSTR szProxy, p;
static const WCHAR szHttp[] = {'h','t','t','p','=',0};
- szProxy=HeapAlloc( GetProcessHeap(), 0, len );
- RegQueryValueExW( key, szProxyServer, NULL, &keytype,
- (BYTE*)szProxy, &len);
+ if (!(szProxy = HeapAlloc( GetProcessHeap(), 0, len )))
+ {
+ RegCloseKey( key );
+ return ERROR_OUTOFMEMORY;
+ }
+ RegQueryValueExW( key, szProxyServer, NULL, &type, (BYTE*)szProxy, &len );
/* find the http proxy, and strip away everything else */
p = strstrW( szProxy, szHttp );
- if( p )
+ if (p)
{
- p += lstrlenW(szHttp);
- lstrcpyW( szProxy, p );
+ p += lstrlenW( szHttp );
+ lstrcpyW( szProxy, p );
}
p = strchrW( szProxy, ' ' );
- if( p )
- *p = 0;
+ if (p) *p = 0;
- lpwai->dwAccessType = INTERNET_OPEN_TYPE_PROXY;
- lpwai->lpszProxy = szProxy;
+ lpwpi->lpszProxyServer = szProxy;
- TRACE("http proxy = %s\n", debugstr_w(lpwai->lpszProxy));
+ TRACE("http proxy = %s\n", debugstr_w(lpwpi->lpszProxyServer));
}
else
- ERR("Couldn't read proxy server settings.\n");
+ {
+ TRACE("No proxy server settings in registry.\n");
+ lpwpi->lpszProxyServer = NULL;
+ }
+ }
+ else if (envproxy)
+ {
+ WCHAR *envproxyW;
+
+ len = MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, NULL, 0 );
+ if (!(envproxyW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR))))
+ return ERROR_OUTOFMEMORY;
+ MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, envproxyW, len );
+
+ lpwpi->dwProxyEnabled = 1;
+ lpwpi->lpszProxyServer = envproxyW;
+
+ TRACE("http proxy (from environment) = %s\n", debugstr_w(lpwpi->lpszProxyServer));
+ }
+ RegCloseKey( key );
+
+ lpwpi->lpszProxyBypass = NULL;
+
+ return ERROR_SUCCESS;
+}
+
+/***********************************************************************
+ * INTERNET_ConfigureProxy
+ */
+static BOOL INTERNET_ConfigureProxy( appinfo_t *lpwai )
+{
+ proxyinfo_t wpi;
+
+ if (INTERNET_LoadProxySettings( &wpi ))
+ return FALSE;
+
+ if (wpi.dwProxyEnabled)
+ {
+ lpwai->dwAccessType = INTERNET_OPEN_TYPE_PROXY;
+ lpwai->lpszProxy = wpi.lpszProxyServer;
+ return TRUE;
}
- else
- TRACE("Proxy is not enabled.\n");
- RegCloseKey(key);
- return enabled;
+ lpwai->dwAccessType = INTERNET_OPEN_TYPE_DIRECT;
+ return FALSE;
}
/***********************************************************************
FE(INTERNET_FLAG_TRANSFER_BINARY)
};
#undef FE
- int i;
-
+ unsigned int i;
+
for (i = 0; i < (sizeof(flag) / sizeof(flag[0])); i++) {
if (flag[i].val & dwFlags) {
TRACE(" %s", flag[i].name);
TRACE("\n");
}
+/***********************************************************************
+ * INTERNET_CloseHandle (internal)
+ *
+ * Close internet handle
+ *
+ */
+static VOID APPINFO_Destroy(object_header_t *hdr)
+{
+ appinfo_t *lpwai = (appinfo_t*)hdr;
+
+ TRACE("%p\n",lpwai);
+
+ HeapFree(GetProcessHeap(), 0, lpwai->lpszAgent);
+ HeapFree(GetProcessHeap(), 0, lpwai->lpszProxy);
+ HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyBypass);
+ HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyUsername);
+ HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyPassword);
+ HeapFree(GetProcessHeap(), 0, lpwai);
+}
+
+static DWORD APPINFO_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
+{
+ appinfo_t *ai = (appinfo_t*)hdr;
+
+ switch(option) {
+ case INTERNET_OPTION_HANDLE_TYPE:
+ TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
+
+ if (*size < sizeof(ULONG))
+ return ERROR_INSUFFICIENT_BUFFER;
+
+ *size = sizeof(DWORD);
+ *(DWORD*)buffer = INTERNET_HANDLE_TYPE_INTERNET;
+ return ERROR_SUCCESS;
+
+ case INTERNET_OPTION_USER_AGENT: {
+ DWORD bufsize;
+
+ TRACE("INTERNET_OPTION_USER_AGENT\n");
+
+ bufsize = *size;
+
+ if (unicode) {
+ DWORD len = ai->lpszAgent ? strlenW(ai->lpszAgent) : 0;
+
+ *size = (len + 1) * sizeof(WCHAR);
+ if(!buffer || bufsize < *size)
+ return ERROR_INSUFFICIENT_BUFFER;
+
+ if (ai->lpszAgent)
+ strcpyW(buffer, ai->lpszAgent);
+ else
+ *(WCHAR *)buffer = 0;
+ /* If the buffer is copied, the returned length doesn't include
+ * the NULL terminator.
+ */
+ *size = len * sizeof(WCHAR);
+ }else {
+ if (ai->lpszAgent)
+ *size = WideCharToMultiByte(CP_ACP, 0, ai->lpszAgent, -1, NULL, 0, NULL, NULL);
+ else
+ *size = 1;
+ if(!buffer || bufsize < *size)
+ return ERROR_INSUFFICIENT_BUFFER;
+
+ if (ai->lpszAgent)
+ WideCharToMultiByte(CP_ACP, 0, ai->lpszAgent, -1, buffer, *size, NULL, NULL);
+ else
+ *(char *)buffer = 0;
+ /* If the buffer is copied, the returned length doesn't include
+ * the NULL terminator.
+ */
+ *size -= 1;
+ }
+
+ return ERROR_SUCCESS;
+ }
+
+ case INTERNET_OPTION_PROXY:
+ if (unicode) {
+ INTERNET_PROXY_INFOW *pi = (INTERNET_PROXY_INFOW *)buffer;
+ DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
+ LPWSTR proxy, proxy_bypass;
+
+ if (ai->lpszProxy)
+ proxyBytesRequired = (lstrlenW(ai->lpszProxy) + 1) * sizeof(WCHAR);
+ if (ai->lpszProxyBypass)
+ proxyBypassBytesRequired = (lstrlenW(ai->lpszProxyBypass) + 1) * sizeof(WCHAR);
+ if (*size < sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired)
+ {
+ *size = sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired;
+ return ERROR_INSUFFICIENT_BUFFER;
+ }
+ proxy = (LPWSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOW));
+ proxy_bypass = (LPWSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired);
+
+ pi->dwAccessType = ai->dwAccessType;
+ pi->lpszProxy = NULL;
+ pi->lpszProxyBypass = NULL;
+ if (ai->lpszProxy) {
+ lstrcpyW(proxy, ai->lpszProxy);
+ pi->lpszProxy = proxy;
+ }
+
+ if (ai->lpszProxyBypass) {
+ lstrcpyW(proxy_bypass, ai->lpszProxyBypass);
+ pi->lpszProxyBypass = proxy_bypass;
+ }
+
+ *size = sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired;
+ return ERROR_SUCCESS;
+ }else {
+ INTERNET_PROXY_INFOA *pi = (INTERNET_PROXY_INFOA *)buffer;
+ DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
+ LPSTR proxy, proxy_bypass;
+
+ if (ai->lpszProxy)
+ proxyBytesRequired = WideCharToMultiByte(CP_ACP, 0, ai->lpszProxy, -1, NULL, 0, NULL, NULL);
+ if (ai->lpszProxyBypass)
+ proxyBypassBytesRequired = WideCharToMultiByte(CP_ACP, 0, ai->lpszProxyBypass, -1,
+ NULL, 0, NULL, NULL);
+ if (*size < sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired)
+ {
+ *size = sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired;
+ return ERROR_INSUFFICIENT_BUFFER;
+ }
+ proxy = (LPSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOA));
+ proxy_bypass = (LPSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired);
+
+ pi->dwAccessType = ai->dwAccessType;
+ pi->lpszProxy = NULL;
+ pi->lpszProxyBypass = NULL;
+ if (ai->lpszProxy) {
+ WideCharToMultiByte(CP_ACP, 0, ai->lpszProxy, -1, proxy, proxyBytesRequired, NULL, NULL);
+ pi->lpszProxy = proxy;
+ }
+
+ if (ai->lpszProxyBypass) {
+ WideCharToMultiByte(CP_ACP, 0, ai->lpszProxyBypass, -1, proxy_bypass,
+ proxyBypassBytesRequired, NULL, NULL);
+ pi->lpszProxyBypass = proxy_bypass;
+ }
+
+ *size = sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired;
+ return ERROR_SUCCESS;
+ }
+ }
+
+ return INET_QueryOption(option, buffer, size, unicode);
+}
+
+static const object_vtbl_t APPINFOVtbl = {
+ APPINFO_Destroy,
+ NULL,
+ APPINFO_QueryOption,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+};
+
+
/***********************************************************************
* InternetOpenW (WININET.@)
*
HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType,
LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags)
{
- LPWININETAPPINFOW lpwai = NULL;
+ appinfo_t *lpwai = NULL;
HINTERNET handle = NULL;
if (TRACE_ON(wininet)) {
/* Clear any error information */
INTERNET_SetLastError(0);
- lpwai = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WININETAPPINFOW));
+ lpwai = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(appinfo_t));
if (NULL == lpwai)
{
INTERNET_SetLastError(ERROR_OUTOFMEMORY);
}
lpwai->hdr.htype = WH_HINIT;
+ lpwai->hdr.vtbl = &APPINFOVtbl;
lpwai->hdr.dwFlags = dwFlags;
- lpwai->hdr.dwRefCount = 1;
- lpwai->hdr.close_connection = NULL;
- lpwai->hdr.destroy = INTERNET_CloseHandle;
+ lpwai->hdr.refs = 1;
lpwai->dwAccessType = dwAccessType;
lpwai->lpszProxyUsername = NULL;
lpwai->lpszProxyPassword = NULL;
goto lend;
}
- if (NULL != lpszAgent)
- {
- lpwai->lpszAgent = HeapAlloc( GetProcessHeap(),0,
- (strlenW(lpszAgent)+1)*sizeof(WCHAR));
- if (lpwai->lpszAgent)
- lstrcpyW( lpwai->lpszAgent, lpszAgent );
- }
+ lpwai->lpszAgent = heap_strdupW(lpszAgent);
if(dwAccessType == INTERNET_OPEN_TYPE_PRECONFIG)
- INTERNET_ConfigureProxyFromReg( lpwai );
- else if (NULL != lpszProxy)
- {
- lpwai->lpszProxy = HeapAlloc( GetProcessHeap(), 0,
- (strlenW(lpszProxy)+1)*sizeof(WCHAR));
- if (lpwai->lpszProxy)
- lstrcpyW( lpwai->lpszProxy, lpszProxy );
- }
-
- if (NULL != lpszProxyBypass)
- {
- lpwai->lpszProxyBypass = HeapAlloc( GetProcessHeap(), 0,
- (strlenW(lpszProxyBypass)+1)*sizeof(WCHAR));
- if (lpwai->lpszProxyBypass)
- lstrcpyW( lpwai->lpszProxyBypass, lpszProxyBypass );
- }
+ INTERNET_ConfigureProxy( lpwai );
+ else
+ lpwai->lpszProxy = heap_strdupW(lpszProxy);
+ lpwai->lpszProxyBypass = heap_strdupW(lpszProxyBypass);
lend:
if( lpwai )
HINTERNET WINAPI InternetOpenA(LPCSTR lpszAgent, DWORD dwAccessType,
LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags)
{
- HINTERNET rc = (HINTERNET)NULL;
- INT len;
- WCHAR *szAgent = NULL, *szProxy = NULL, *szBypass = NULL;
+ WCHAR *szAgent, *szProxy, *szBypass;
+ HINTERNET rc;
TRACE("(%s, 0x%08x, %s, %s, 0x%08x)\n", debugstr_a(lpszAgent),
dwAccessType, debugstr_a(lpszProxy), debugstr_a(lpszProxyBypass), dwFlags);
- if( lpszAgent )
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpszAgent, -1, NULL, 0);
- szAgent = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpszAgent, -1, szAgent, len);
- }
-
- if( lpszProxy )
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpszProxy, -1, NULL, 0);
- szProxy = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpszProxy, -1, szProxy, len);
- }
-
- if( lpszProxyBypass )
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpszProxyBypass, -1, NULL, 0);
- szBypass = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpszProxyBypass, -1, szBypass, len);
- }
+ szAgent = heap_strdupAtoW(lpszAgent);
+ szProxy = heap_strdupAtoW(lpszProxy);
+ szBypass = heap_strdupAtoW(lpszProxyBypass);
rc = InternetOpenW(szAgent, dwAccessType, szProxy, szBypass, dwFlags);
BOOL WINAPI InternetGetLastResponseInfoA(LPDWORD lpdwError,
LPSTR lpszBuffer, LPDWORD lpdwBufferLength)
{
- LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
+ LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
TRACE("\n");
BOOL WINAPI InternetGetLastResponseInfoW(LPDWORD lpdwError,
LPWSTR lpszBuffer, LPDWORD lpdwBufferLength)
{
- LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
+ LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
TRACE("\n");
TRACE("(%p, 0x%08x)\n", lpdwStatus, dwReserved);
if (lpdwStatus) {
- FIXME("always returning LAN connection.\n");
+ WARN("always returning LAN connection.\n");
*lpdwStatus = INTERNET_CONNECTION_LAN;
}
return TRUE;
return FALSE;
if (lpdwStatus) {
- FIXME("always returning LAN connection.\n");
+ WARN("always returning LAN connection.\n");
*lpdwStatus = INTERNET_CONNECTION_LAN;
}
return LoadStringW(WININET_hModule, IDS_LANCONNECTION, lpszConnectionName, dwNameLen);
LPCWSTR lpszUserName, LPCWSTR lpszPassword,
DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
{
- LPWININETAPPINFOW hIC;
+ appinfo_t *hIC;
HINTERNET rc = NULL;
+ DWORD res = ERROR_SUCCESS;
TRACE("(%p, %s, %i, %s, %s, %i, %i, %lx)\n", hInternet, debugstr_w(lpszServerName),
nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword),
if (!lpszServerName)
{
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
+ SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
- /* Clear any error information */
- INTERNET_SetLastError(0);
- hIC = (LPWININETAPPINFOW) WININET_GetObject( hInternet );
+ hIC = (appinfo_t*)WININET_GetObject( hInternet );
if ( (hIC == NULL) || (hIC->hdr.htype != WH_HINIT) )
{
- INTERNET_SetLastError(ERROR_INVALID_HANDLE);
+ res = ERROR_INVALID_HANDLE;
goto lend;
}
case INTERNET_SERVICE_FTP:
rc = FTP_Connect(hIC, lpszServerName, nServerPort,
lpszUserName, lpszPassword, dwFlags, dwContext, 0);
+ if(!rc)
+ res = INTERNET_GetLastError();
break;
case INTERNET_SERVICE_HTTP:
- rc = HTTP_Connect(hIC, lpszServerName, nServerPort,
- lpszUserName, lpszPassword, dwFlags, dwContext, 0);
+ res = HTTP_Connect(hIC, lpszServerName, nServerPort,
+ lpszUserName, lpszPassword, dwFlags, dwContext, 0, &rc);
break;
case INTERNET_SERVICE_GOPHER:
WININET_Release( &hIC->hdr );
TRACE("returning %p\n", rc);
+ SetLastError(res);
return rc;
}
LPCSTR lpszUserName, LPCSTR lpszPassword,
DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
{
- HINTERNET rc = (HINTERNET)NULL;
- INT len = 0;
- LPWSTR szServerName = NULL;
- LPWSTR szUserName = NULL;
- LPWSTR szPassword = NULL;
-
- if (lpszServerName)
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpszServerName, -1, NULL, 0);
- szServerName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpszServerName, -1, szServerName, len);
- }
- if (lpszUserName)
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, NULL, 0);
- szUserName = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpszUserName, -1, szUserName, len);
- }
- if (lpszPassword)
- {
- len = MultiByteToWideChar(CP_ACP, 0, lpszPassword, -1, NULL, 0);
- szPassword = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
- MultiByteToWideChar(CP_ACP, 0, lpszPassword, -1, szPassword, len);
- }
+ HINTERNET rc = NULL;
+ LPWSTR szServerName;
+ LPWSTR szUserName;
+ LPWSTR szPassword;
+ szServerName = heap_strdupAtoW(lpszServerName);
+ szUserName = heap_strdupAtoW(lpszUserName);
+ szPassword = heap_strdupAtoW(lpszPassword);
rc = InternetConnectW(hInternet, szServerName, nServerPort,
szUserName, szPassword, dwService, dwFlags, dwContext);
* FALSE on failure
*
*/
-static void AsyncFtpFindNextFileProc(WORKREQUEST *workRequest)
-{
- struct WORKREQ_FTPFINDNEXTW *req = &workRequest->u.FtpFindNextW;
- LPWININETFTPFINDNEXTW lpwh = (LPWININETFTPFINDNEXTW) workRequest->hdr;
-
- TRACE("%p\n", lpwh);
-
- FTP_FindNextFileW(lpwh, req->lpFindFileData);
-}
-
BOOL WINAPI InternetFindNextFileW(HINTERNET hFind, LPVOID lpvFindData)
{
- LPWININETAPPINFOW hIC = NULL;
- LPWININETFTPFINDNEXTW lpwh;
- BOOL bSuccess = FALSE;
+ object_header_t *hdr;
+ DWORD res;
TRACE("\n");
- lpwh = (LPWININETFTPFINDNEXTW) WININET_GetObject( hFind );
- if (NULL == lpwh || lpwh->hdr.htype != WH_HFTPFINDNEXT)
- {
- FIXME("Only FTP supported\n");
- INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
- goto lend;
+ hdr = WININET_GetObject(hFind);
+ if(!hdr) {
+ WARN("Invalid handle\n");
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
}
- hIC = lpwh->lpFtpSession->lpAppInfo;
- if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC)
- {
- WORKREQUEST workRequest;
- struct WORKREQ_FTPFINDNEXTW *req;
-
- workRequest.asyncproc = AsyncFtpFindNextFileProc;
- workRequest.hdr = WININET_AddRef( &lpwh->hdr );
- req = &workRequest.u.FtpFindNextW;
- req->lpFindFileData = lpvFindData;
-
- bSuccess = INTERNET_AsyncCall(&workRequest);
- }
- else
- {
- bSuccess = FTP_FindNextFileW(lpwh, lpvFindData);
+ if(hdr->vtbl->FindNextFileW) {
+ res = hdr->vtbl->FindNextFileW(hdr, lpvFindData);
+ }else {
+ WARN("Handle doesn't support NextFile\n");
+ res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
}
-lend:
- if( lpwh )
- WININET_Release( &lpwh->hdr );
- return bSuccess;
-}
-/***********************************************************************
- * INTERNET_CloseHandle (internal)
- *
- * Close internet handle
- *
- * RETURNS
- * Void
- *
- */
-static VOID INTERNET_CloseHandle(LPWININETHANDLEHEADER hdr)
-{
- LPWININETAPPINFOW lpwai = (LPWININETAPPINFOW) hdr;
-
- TRACE("%p\n",lpwai);
+ WININET_Release(hdr);
- HeapFree(GetProcessHeap(), 0, lpwai->lpszAgent);
- HeapFree(GetProcessHeap(), 0, lpwai->lpszProxy);
- HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyBypass);
- HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyUsername);
- HeapFree(GetProcessHeap(), 0, lpwai->lpszProxyPassword);
- HeapFree(GetProcessHeap(), 0, lpwai);
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
}
-
/***********************************************************************
* InternetCloseHandle (WININET.@)
*
*/
BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
{
- LPWININETHANDLEHEADER lpwh;
+ object_header_t *lpwh;
TRACE("%p\n",hInternet);
/***********************************************************************
* ConvertUrlComponentValue (Internal)
*
- * Helper function for InternetCrackUrlW
+ * Helper function for InternetCrackUrlA
*
*/
static void ConvertUrlComponentValue(LPSTR* lppszComponent, LPDWORD dwComponentLen,
LPWSTR lpwszComponent, DWORD dwwComponentLen,
LPCSTR lpszStart, LPCWSTR lpwszStart)
{
- TRACE("%p %d %p %d %p %p\n", lppszComponent, *dwComponentLen, lpwszComponent, dwwComponentLen, lpszStart, lpwszStart);
+ TRACE("%p %d %p %d %p %p\n", *lppszComponent, *dwComponentLen, lpwszComponent, dwwComponentLen, lpszStart, lpwszStart);
if (*dwComponentLen != 0)
{
DWORD nASCIILength=WideCharToMultiByte(CP_ACP,0,lpwszComponent,dwwComponentLen,NULL,0,NULL,NULL);
if (*lppszComponent == NULL)
{
- int nASCIIOffset=WideCharToMultiByte(CP_ACP,0,lpwszStart,lpwszComponent-lpwszStart,NULL,0,NULL,NULL);
if (lpwszComponent)
- *lppszComponent = (LPSTR)lpszStart+nASCIIOffset;
+ {
+ int offset = WideCharToMultiByte(CP_ACP, 0, lpwszStart, lpwszComponent-lpwszStart, NULL, 0, NULL, NULL);
+ *lppszComponent = (LPSTR)lpszStart + offset;
+ }
else
*lppszComponent = NULL;
+
*dwComponentLen = nASCIILength;
}
else
{
DWORD nLength;
URL_COMPONENTSW UCW;
- WCHAR* lpwszUrl;
+ BOOL ret = FALSE;
+ WCHAR *lpwszUrl, *hostname = NULL, *username = NULL, *password = NULL, *path = NULL,
+ *scheme = NULL, *extra = NULL;
- TRACE("(%s %u %x %p)\n", debugstr_a(lpszUrl), dwUrlLength, dwFlags, lpUrlComponents);
+ TRACE("(%s %u %x %p)\n",
+ lpszUrl ? debugstr_an(lpszUrl, dwUrlLength ? dwUrlLength : strlen(lpszUrl)) : "(null)",
+ dwUrlLength, dwFlags, lpUrlComponents);
- if (!lpszUrl || !*lpszUrl)
+ if (!lpszUrl || !*lpszUrl || !lpUrlComponents ||
+ lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSA))
{
INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
InternetCrackUrlW should not include it */
if (dwUrlLength == -1) nLength--;
- lpwszUrl=HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR)*nLength);
+ lpwszUrl = HeapAlloc(GetProcessHeap(), 0, nLength * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP,0,lpszUrl,dwUrlLength,lpwszUrl,nLength);
memset(&UCW,0,sizeof(UCW));
- if(lpUrlComponents->dwHostNameLength!=0)
- UCW.dwHostNameLength= lpUrlComponents->dwHostNameLength;
- if(lpUrlComponents->dwUserNameLength!=0)
- UCW.dwUserNameLength=lpUrlComponents->dwUserNameLength;
- if(lpUrlComponents->dwPasswordLength!=0)
- UCW.dwPasswordLength=lpUrlComponents->dwPasswordLength;
- if(lpUrlComponents->dwUrlPathLength!=0)
- UCW.dwUrlPathLength=lpUrlComponents->dwUrlPathLength;
- if(lpUrlComponents->dwSchemeLength!=0)
- UCW.dwSchemeLength=lpUrlComponents->dwSchemeLength;
- if(lpUrlComponents->dwExtraInfoLength!=0)
- UCW.dwExtraInfoLength=lpUrlComponents->dwExtraInfoLength;
- if(!InternetCrackUrlW(lpwszUrl,nLength,dwFlags,&UCW))
+ UCW.dwStructSize = sizeof(URL_COMPONENTSW);
+ if (lpUrlComponents->dwHostNameLength)
{
- HeapFree(GetProcessHeap(), 0, lpwszUrl);
- return FALSE;
+ UCW.dwHostNameLength = lpUrlComponents->dwHostNameLength;
+ if (lpUrlComponents->lpszHostName)
+ {
+ hostname = HeapAlloc(GetProcessHeap(), 0, UCW.dwHostNameLength * sizeof(WCHAR));
+ UCW.lpszHostName = hostname;
+ }
+ }
+ if (lpUrlComponents->dwUserNameLength)
+ {
+ UCW.dwUserNameLength = lpUrlComponents->dwUserNameLength;
+ if (lpUrlComponents->lpszUserName)
+ {
+ username = HeapAlloc(GetProcessHeap(), 0, UCW.dwUserNameLength * sizeof(WCHAR));
+ UCW.lpszUserName = username;
+ }
+ }
+ if (lpUrlComponents->dwPasswordLength)
+ {
+ UCW.dwPasswordLength = lpUrlComponents->dwPasswordLength;
+ if (lpUrlComponents->lpszPassword)
+ {
+ password = HeapAlloc(GetProcessHeap(), 0, UCW.dwPasswordLength * sizeof(WCHAR));
+ UCW.lpszPassword = password;
+ }
+ }
+ if (lpUrlComponents->dwUrlPathLength)
+ {
+ UCW.dwUrlPathLength = lpUrlComponents->dwUrlPathLength;
+ if (lpUrlComponents->lpszUrlPath)
+ {
+ path = HeapAlloc(GetProcessHeap(), 0, UCW.dwUrlPathLength * sizeof(WCHAR));
+ UCW.lpszUrlPath = path;
+ }
+ }
+ if (lpUrlComponents->dwSchemeLength)
+ {
+ UCW.dwSchemeLength = lpUrlComponents->dwSchemeLength;
+ if (lpUrlComponents->lpszScheme)
+ {
+ scheme = HeapAlloc(GetProcessHeap(), 0, UCW.dwSchemeLength * sizeof(WCHAR));
+ UCW.lpszScheme = scheme;
+ }
+ }
+ if (lpUrlComponents->dwExtraInfoLength)
+ {
+ UCW.dwExtraInfoLength = lpUrlComponents->dwExtraInfoLength;
+ if (lpUrlComponents->lpszExtraInfo)
+ {
+ extra = HeapAlloc(GetProcessHeap(), 0, UCW.dwExtraInfoLength * sizeof(WCHAR));
+ UCW.lpszExtraInfo = extra;
+ }
+ }
+ if ((ret = InternetCrackUrlW(lpwszUrl, nLength, dwFlags, &UCW)))
+ {
+ ConvertUrlComponentValue(&lpUrlComponents->lpszHostName, &lpUrlComponents->dwHostNameLength,
+ UCW.lpszHostName, UCW.dwHostNameLength, lpszUrl, lpwszUrl);
+ ConvertUrlComponentValue(&lpUrlComponents->lpszUserName, &lpUrlComponents->dwUserNameLength,
+ UCW.lpszUserName, UCW.dwUserNameLength, lpszUrl, lpwszUrl);
+ ConvertUrlComponentValue(&lpUrlComponents->lpszPassword, &lpUrlComponents->dwPasswordLength,
+ UCW.lpszPassword, UCW.dwPasswordLength, lpszUrl, lpwszUrl);
+ ConvertUrlComponentValue(&lpUrlComponents->lpszUrlPath, &lpUrlComponents->dwUrlPathLength,
+ UCW.lpszUrlPath, UCW.dwUrlPathLength, lpszUrl, lpwszUrl);
+ ConvertUrlComponentValue(&lpUrlComponents->lpszScheme, &lpUrlComponents->dwSchemeLength,
+ UCW.lpszScheme, UCW.dwSchemeLength, lpszUrl, lpwszUrl);
+ ConvertUrlComponentValue(&lpUrlComponents->lpszExtraInfo, &lpUrlComponents->dwExtraInfoLength,
+ UCW.lpszExtraInfo, UCW.dwExtraInfoLength, lpszUrl, lpwszUrl);
+
+ lpUrlComponents->nScheme = UCW.nScheme;
+ lpUrlComponents->nPort = UCW.nPort;
+
+ TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", lpszUrl,
+ debugstr_an(lpUrlComponents->lpszScheme, lpUrlComponents->dwSchemeLength),
+ debugstr_an(lpUrlComponents->lpszHostName, lpUrlComponents->dwHostNameLength),
+ debugstr_an(lpUrlComponents->lpszUrlPath, lpUrlComponents->dwUrlPathLength),
+ debugstr_an(lpUrlComponents->lpszExtraInfo, lpUrlComponents->dwExtraInfoLength));
}
-
- ConvertUrlComponentValue(&lpUrlComponents->lpszHostName, &lpUrlComponents->dwHostNameLength,
- UCW.lpszHostName, UCW.dwHostNameLength,
- lpszUrl, lpwszUrl);
- ConvertUrlComponentValue(&lpUrlComponents->lpszUserName, &lpUrlComponents->dwUserNameLength,
- UCW.lpszUserName, UCW.dwUserNameLength,
- lpszUrl, lpwszUrl);
- ConvertUrlComponentValue(&lpUrlComponents->lpszPassword, &lpUrlComponents->dwPasswordLength,
- UCW.lpszPassword, UCW.dwPasswordLength,
- lpszUrl, lpwszUrl);
- ConvertUrlComponentValue(&lpUrlComponents->lpszUrlPath, &lpUrlComponents->dwUrlPathLength,
- UCW.lpszUrlPath, UCW.dwUrlPathLength,
- lpszUrl, lpwszUrl);
- ConvertUrlComponentValue(&lpUrlComponents->lpszScheme, &lpUrlComponents->dwSchemeLength,
- UCW.lpszScheme, UCW.dwSchemeLength,
- lpszUrl, lpwszUrl);
- ConvertUrlComponentValue(&lpUrlComponents->lpszExtraInfo, &lpUrlComponents->dwExtraInfoLength,
- UCW.lpszExtraInfo, UCW.dwExtraInfoLength,
- lpszUrl, lpwszUrl);
- lpUrlComponents->nScheme=UCW.nScheme;
- lpUrlComponents->nPort=UCW.nPort;
HeapFree(GetProcessHeap(), 0, lpwszUrl);
-
- TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", lpszUrl,
- debugstr_an(lpUrlComponents->lpszScheme,lpUrlComponents->dwSchemeLength),
- debugstr_an(lpUrlComponents->lpszHostName,lpUrlComponents->dwHostNameLength),
- debugstr_an(lpUrlComponents->lpszUrlPath,lpUrlComponents->dwUrlPathLength),
- debugstr_an(lpUrlComponents->lpszExtraInfo,lpUrlComponents->dwExtraInfoLength));
-
- return TRUE;
+ HeapFree(GetProcessHeap(), 0, hostname);
+ HeapFree(GetProcessHeap(), 0, username);
+ HeapFree(GetProcessHeap(), 0, password);
+ HeapFree(GetProcessHeap(), 0, path);
+ HeapFree(GetProcessHeap(), 0, scheme);
+ HeapFree(GetProcessHeap(), 0, extra);
+ return ret;
}
static const WCHAR url_schemes[][7] =
LPCWSTR lpszcp = NULL;
LPWSTR lpszUrl_decode = NULL;
DWORD dwUrlLength = dwUrlLength_orig;
- const WCHAR lpszSeparators[3]={';','?',0};
- const WCHAR lpszSlash[2]={'/',0};
- TRACE("(%s %u %x %p)\n", debugstr_w(lpszUrl), dwUrlLength, dwFlags, lpUC);
+ TRACE("(%s %u %x %p)\n",
+ lpszUrl ? debugstr_wn(lpszUrl, dwUrlLength ? dwUrlLength : strlenW(lpszUrl)) : "(null)",
+ dwUrlLength, dwFlags, lpUC);
if (!lpszUrl_orig || !*lpszUrl_orig || !lpUC)
{
if (dwFlags & ICU_DECODE)
{
- lpszUrl_decode=HeapAlloc( GetProcessHeap(), 0, dwUrlLength * sizeof (WCHAR) );
- if( InternetCanonicalizeUrlW(lpszUrl_orig, lpszUrl_decode, &dwUrlLength, dwFlags))
- {
- lpszUrl = lpszUrl_decode;
- }
+ WCHAR *url_tmp;
+ DWORD len = dwUrlLength + 1;
+
+ if (!(url_tmp = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
+ {
+ INTERNET_SetLastError(ERROR_OUTOFMEMORY);
+ return FALSE;
+ }
+ memcpy(url_tmp, lpszUrl_orig, dwUrlLength * sizeof(WCHAR));
+ url_tmp[dwUrlLength] = 0;
+ if (!(lpszUrl_decode = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
+ {
+ HeapFree(GetProcessHeap(), 0, url_tmp);
+ INTERNET_SetLastError(ERROR_OUTOFMEMORY);
+ return FALSE;
+ }
+ if (InternetCanonicalizeUrlW(url_tmp, lpszUrl_decode, &len, ICU_DECODE | ICU_NO_ENCODE))
+ {
+ dwUrlLength = len;
+ lpszUrl = lpszUrl_decode;
+ }
+ HeapFree(GetProcessHeap(), 0, url_tmp);
}
lpszap = lpszUrl;
/* Determine if the URI is absolute. */
- while (*lpszap != '\0')
+ while (lpszap - lpszUrl < dwUrlLength)
{
- if (isalnumW(*lpszap))
+ if (isalnumW(*lpszap) || *lpszap == '+' || *lpszap == '.' || *lpszap == '-')
{
lpszap++;
continue;
lpUC->nPort = INTERNET_INVALID_PORT_NUMBER;
/* Parse <params> */
- lpszParam = strpbrkW(lpszap, lpszSeparators);
+ lpszParam = memchrW(lpszap, ';', dwUrlLength - (lpszap - lpszUrl));
+ if(!lpszParam)
+ lpszParam = memchrW(lpszap, '?', dwUrlLength - (lpszap - lpszUrl));
+ if(!lpszParam)
+ lpszParam = memchrW(lpszap, '#', dwUrlLength - (lpszap - lpszUrl));
+
SetUrlComponentValueW(&lpUC->lpszExtraInfo, &lpUC->dwExtraInfoLength,
lpszParam, lpszParam ? dwUrlLength-(lpszParam-lpszUrl) : 0);
{
lpszcp += 2;
- lpszNetLoc = strpbrkW(lpszcp, lpszSlash);
+ lpszNetLoc = memchrW(lpszcp, '/', dwUrlLength - (lpszcp - lpszUrl));
if (lpszParam)
{
if (lpszNetLoc)
/* [<user>[<:password>]@]<host>[:<port>] */
/* First find the user and password if they exist */
- lpszHost = strchrW(lpszcp, '@');
+ lpszHost = memchrW(lpszcp, '@', dwUrlLength - (lpszcp - lpszUrl));
if (lpszHost == NULL || lpszHost > lpszNetLoc)
{
/* username and password not specified. */
}
/* If the scheme is "file" and the host is just one letter, it's not a host */
- if(lpUC->nScheme==INTERNET_SCHEME_FILE && (lpszPort-lpszHost)==1)
+ if(lpUC->nScheme==INTERNET_SCHEME_FILE && lpszPort <= lpszHost+1)
{
lpszcp=lpszHost;
SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
* <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
*/
- if (lpszcp != 0 && *lpszcp != '\0' && (!lpszParam || lpszcp < lpszParam))
+ if (lpszcp != 0 && lpszcp - lpszUrl < dwUrlLength && (!lpszParam || lpszcp <= lpszParam))
{
INT len;
/* Leave the parameter list in lpszUrlPath. Strip off any trailing
* newlines if necessary.
*/
- LPWSTR lpsznewline = strchrW(lpszcp, '\n');
+ LPWSTR lpsznewline = memchrW(lpszcp, '\n', dwUrlLength - (lpszcp - lpszUrl));
if (lpsznewline != NULL)
len = lpsznewline - lpszcp;
else
}
else
{
+ if (lpUC->lpszUrlPath && (lpUC->dwUrlPathLength > 0))
+ lpUC->lpszUrlPath[0] = 0;
lpUC->dwUrlPathLength = 0;
}
DWORD dwURLFlags = URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE;
TRACE("(%s, %p, %p, 0x%08x) bufferlength: %d\n", debugstr_w(lpszUrl), lpszBuffer,
- lpdwBufferLength, lpdwBufferLength ? *lpdwBufferLength : -1, dwFlags);
+ lpdwBufferLength, dwFlags, lpdwBufferLength ? *lpdwBufferLength : -1);
if(dwFlags & ICU_DECODE)
{
/* #################################################### */
static INTERNET_STATUS_CALLBACK set_status_callback(
- LPWININETHANDLEHEADER lpwh, INTERNET_STATUS_CALLBACK callback, BOOL unicode)
+ object_header_t *lpwh, INTERNET_STATUS_CALLBACK callback, BOOL unicode)
{
INTERNET_STATUS_CALLBACK ret;
HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
{
INTERNET_STATUS_CALLBACK retVal;
- LPWININETHANDLEHEADER lpwh;
+ object_header_t *lpwh;
+
+ TRACE("%p\n", hInternet);
- TRACE("0x%08x\n", (ULONG)hInternet);
-
if (!(lpwh = WININET_GetObject(hInternet)))
return INTERNET_INVALID_STATUS_CALLBACK;
HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
{
INTERNET_STATUS_CALLBACK retVal;
- LPWININETHANDLEHEADER lpwh;
+ object_header_t *lpwh;
- TRACE("0x%08x\n", (ULONG)hInternet);
+ TRACE("%p\n", hInternet);
if (!(lpwh = WININET_GetObject(hInternet)))
return INTERNET_INVALID_STATUS_CALLBACK;
* FALSE on failure
*
*/
-BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer ,
+BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer,
DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
{
- BOOL retval = FALSE;
- int nSocket = -1;
- LPWININETHANDLEHEADER lpwh;
+ object_header_t *lpwh;
+ BOOL res;
- TRACE("\n");
- lpwh = (LPWININETHANDLEHEADER) WININET_GetObject( hFile );
- if (NULL == lpwh)
- return FALSE;
-
- switch (lpwh->htype)
- {
- case WH_HHTTPREQ:
- {
- LPWININETHTTPREQW lpwhr;
- lpwhr = (LPWININETHTTPREQW)lpwh;
-
- TRACE("HTTPREQ %i\n",dwNumOfBytesToWrite);
- retval = NETCON_send(&lpwhr->netConnection, lpBuffer,
- dwNumOfBytesToWrite, 0, (LPINT)lpdwNumOfBytesWritten);
-
- WININET_Release( lpwh );
- return retval;
- }
- break;
+ TRACE("(%p %p %d %p)\n", hFile, lpBuffer, dwNumOfBytesToWrite, lpdwNumOfBytesWritten);
- case WH_HFILE:
- nSocket = ((LPWININETFTPFILE)lpwh)->nDataSocket;
- break;
-
- default:
- break;
+ lpwh = WININET_GetObject( hFile );
+ if (!lpwh) {
+ WARN("Invalid handle\n");
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
}
- if (nSocket != -1)
- {
- int res = send(nSocket, lpBuffer, dwNumOfBytesToWrite, 0);
- retval = (res >= 0);
- *lpdwNumOfBytesWritten = retval ? res : 0;
+ if(lpwh->vtbl->WriteFile) {
+ res = lpwh->vtbl->WriteFile(lpwh, lpBuffer, dwNumOfBytesToWrite, lpdwNumOfBytesWritten);
+ }else {
+ WARN("No Writefile method.\n");
+ res = ERROR_INVALID_HANDLE;
}
+
WININET_Release( lpwh );
- return retval;
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
}
-BOOL INTERNET_ReadFile(LPWININETHANDLEHEADER lpwh, LPVOID lpBuffer,
- DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead,
- BOOL bWait, BOOL bSendCompletionStatus)
-{
- BOOL retval = FALSE;
- int nSocket = -1;
- int bytes_read;
- LPWININETHTTPREQW lpwhr;
-
- /* FIXME: this should use NETCON functions! */
- switch (lpwh->htype)
- {
- case WH_HHTTPREQ:
- lpwhr = (LPWININETHTTPREQW)lpwh;
-
- if (!NETCON_recv(&lpwhr->netConnection, lpBuffer,
- min(dwNumOfBytesToRead, lpwhr->dwContentLength - lpwhr->dwContentRead),
- bWait ? MSG_WAITALL : 0, &bytes_read))
- {
-
- if (((lpwhr->dwContentLength != -1) &&
- (lpwhr->dwContentRead != lpwhr->dwContentLength)))
- ERR("not all data received %d/%d\n", lpwhr->dwContentRead,
- lpwhr->dwContentLength);
-
- /* always returns TRUE, even if the network layer returns an
- * error */
- *pdwNumOfBytesRead = 0;
- HTTP_FinishedReading(lpwhr);
- retval = TRUE;
- }
- else
- {
- lpwhr->dwContentRead += bytes_read;
- *pdwNumOfBytesRead = bytes_read;
- if (!bytes_read && (lpwhr->dwContentRead == lpwhr->dwContentLength))
- retval = HTTP_FinishedReading(lpwhr);
- else
- retval = TRUE;
- }
- break;
-
- case WH_HFILE:
- /* FIXME: FTP should use NETCON_ stuff */
- nSocket = ((LPWININETFTPFILE)lpwh)->nDataSocket;
- if (nSocket != -1)
- {
- int res = recv(nSocket, lpBuffer, dwNumOfBytesToRead, bWait ? MSG_WAITALL : 0);
- retval = (res >= 0);
- *pdwNumOfBytesRead = retval ? res : 0;
- }
- break;
-
- default:
- break;
- }
-
- if (bSendCompletionStatus)
- {
- INTERNET_ASYNC_RESULT iar;
-
- iar.dwResult = retval;
- iar.dwError = iar.dwError = retval ? ERROR_SUCCESS :
- INTERNET_GetLastError();
-
- INTERNET_SendCallback(lpwh, lpwh->dwContext,
- INTERNET_STATUS_REQUEST_COMPLETE, &iar,
- sizeof(INTERNET_ASYNC_RESULT));
- }
- return retval;
-}
-
/***********************************************************************
* InternetReadFile (WININET.@)
*
*
*/
BOOL WINAPI InternetReadFile(HINTERNET hFile, LPVOID lpBuffer,
- DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead)
+ DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead)
{
- LPWININETHANDLEHEADER lpwh;
- BOOL retval;
+ object_header_t *hdr;
+ DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
TRACE("%p %p %d %p\n", hFile, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead);
- lpwh = WININET_GetObject( hFile );
- if (!lpwh)
- {
+ hdr = WININET_GetObject(hFile);
+ if (!hdr) {
INTERNET_SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
- retval = INTERNET_ReadFile(lpwh, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead, TRUE, FALSE);
- WININET_Release( lpwh );
+ if(hdr->vtbl->ReadFile)
+ res = hdr->vtbl->ReadFile(hdr, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead);
- TRACE("-- %s (bytes read: %d)\n", retval ? "TRUE": "FALSE", pdwNumOfBytesRead ? *pdwNumOfBytesRead : -1);
- return retval;
+ WININET_Release(hdr);
+
+ TRACE("-- %s (%u) (bytes read: %d)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE", res,
+ pdwNumOfBytesRead ? *pdwNumOfBytesRead : -1);
+
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
}
/***********************************************************************
* SEE
* InternetOpenUrlA(), HttpOpenRequestA()
*/
-void AsyncInternetReadFileExProc(WORKREQUEST *workRequest)
-{
- struct WORKREQ_INTERNETREADFILEEXA const *req = &workRequest->u.InternetReadFileExA;
-
- TRACE("INTERNETREADFILEEXA %p\n", workRequest->hdr);
-
- INTERNET_ReadFile(workRequest->hdr, req->lpBuffersOut->lpvBuffer,
- req->lpBuffersOut->dwBufferLength,
- &req->lpBuffersOut->dwBufferLength, TRUE, TRUE);
-}
-
BOOL WINAPI InternetReadFileExA(HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffersOut,
DWORD dwFlags, DWORD_PTR dwContext)
{
- BOOL retval = FALSE;
- LPWININETHANDLEHEADER lpwh;
+ object_header_t *hdr;
+ DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
TRACE("(%p %p 0x%x 0x%lx)\n", hFile, lpBuffersOut, dwFlags, dwContext);
- if (dwFlags & ~(IRF_ASYNC|IRF_NO_WAIT))
- FIXME("these dwFlags aren't implemented: 0x%x\n", dwFlags & ~(IRF_ASYNC|IRF_NO_WAIT));
-
- if (lpBuffersOut->dwStructSize != sizeof(*lpBuffersOut))
- {
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
+ hdr = WININET_GetObject(hFile);
+ if (!hdr) {
+ INTERNET_SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
- lpwh = (LPWININETHANDLEHEADER) WININET_GetObject( hFile );
- if (!lpwh)
- {
+ if(hdr->vtbl->ReadFileExA)
+ res = hdr->vtbl->ReadFileExA(hdr, lpBuffersOut, dwFlags, dwContext);
+
+ WININET_Release(hdr);
+
+ TRACE("-- %s (%u, bytes read: %d)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE",
+ res, lpBuffersOut->dwBufferLength);
+
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
+}
+
+/***********************************************************************
+ * InternetReadFileExW (WININET.@)
+ * SEE
+ * InternetReadFileExA()
+ */
+BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer,
+ DWORD dwFlags, DWORD_PTR dwContext)
+{
+ object_header_t *hdr;
+ DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
+
+ TRACE("(%p %p 0x%x 0x%lx)\n", hFile, lpBuffer, dwFlags, dwContext);
+
+ hdr = WININET_GetObject(hFile);
+ if (!hdr) {
INTERNET_SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
- INTERNET_SendCallback(lpwh, lpwh->dwContext,
- INTERNET_STATUS_RECEIVING_RESPONSE, NULL, 0);
+ if(hdr->vtbl->ReadFileExW)
+ res = hdr->vtbl->ReadFileExW(hdr, lpBuffer, dwFlags, dwContext);
- /* FIXME: IRF_ASYNC may not be the right thing to test here;
- * hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC is probably better */
- if (dwFlags & IRF_ASYNC)
- {
- DWORD dwDataAvailable = 0;
+ WININET_Release(hdr);
- if (lpwh->htype == WH_HHTTPREQ)
- NETCON_query_data_available(&((LPWININETHTTPREQW)lpwh)->netConnection,
- &dwDataAvailable);
+ TRACE("-- %s (%u, bytes read: %d)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE",
+ res, lpBuffer->dwBufferLength);
- if (!dwDataAvailable)
- {
- WORKREQUEST workRequest;
- struct WORKREQ_INTERNETREADFILEEXA *req;
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
+}
- workRequest.asyncproc = AsyncInternetReadFileExProc;
- workRequest.hdr = WININET_AddRef( lpwh );
- req = &workRequest.u.InternetReadFileExA;
- req->lpBuffersOut = lpBuffersOut;
+DWORD INET_QueryOption(DWORD option, void *buffer, DWORD *size, BOOL unicode)
+{
+ static BOOL warn = TRUE;
- if (!INTERNET_AsyncCall(&workRequest))
- WININET_Release( lpwh );
- else
- INTERNET_SetLastError(ERROR_IO_PENDING);
- goto end;
+ switch(option) {
+ case INTERNET_OPTION_REQUEST_FLAGS:
+ TRACE("INTERNET_OPTION_REQUEST_FLAGS\n");
+
+ if (*size < sizeof(ULONG))
+ return ERROR_INSUFFICIENT_BUFFER;
+
+ *(ULONG*)buffer = 4;
+ *size = sizeof(ULONG);
+
+ return ERROR_SUCCESS;
+
+ case INTERNET_OPTION_HTTP_VERSION:
+ if (*size < sizeof(HTTP_VERSION_INFO))
+ return ERROR_INSUFFICIENT_BUFFER;
+
+ /*
+ * Presently hardcoded to 1.1
+ */
+ ((HTTP_VERSION_INFO*)buffer)->dwMajorVersion = 1;
+ ((HTTP_VERSION_INFO*)buffer)->dwMinorVersion = 1;
+ *size = sizeof(HTTP_VERSION_INFO);
+
+ return ERROR_SUCCESS;
+
+ case INTERNET_OPTION_CONNECTED_STATE:
+ if (warn) {
+ FIXME("INTERNET_OPTION_CONNECTED_STATE: semi-stub\n");
+ warn = FALSE;
}
- }
+ if (*size < sizeof(ULONG))
+ return ERROR_INSUFFICIENT_BUFFER;
- retval = INTERNET_ReadFile(lpwh, lpBuffersOut->lpvBuffer,
- lpBuffersOut->dwBufferLength, &lpBuffersOut->dwBufferLength,
- !(dwFlags & IRF_NO_WAIT), FALSE);
+ *(ULONG*)buffer = INTERNET_STATE_CONNECTED;
+ *size = sizeof(ULONG);
- if (retval)
- {
- DWORD dwBytesReceived = lpBuffersOut->dwBufferLength;
- INTERNET_SendCallback(lpwh, lpwh->dwContext,
- INTERNET_STATUS_RESPONSE_RECEIVED, &dwBytesReceived,
- sizeof(dwBytesReceived));
+ return ERROR_SUCCESS;
+
+ case INTERNET_OPTION_PROXY: {
+ appinfo_t ai;
+ BOOL ret;
+
+ TRACE("Getting global proxy info\n");
+ memset(&ai, 0, sizeof(appinfo_t));
+ INTERNET_ConfigureProxy(&ai);
+
+ ret = APPINFO_QueryOption(&ai.hdr, INTERNET_OPTION_PROXY, buffer, size, unicode); /* FIXME */
+ APPINFO_Destroy(&ai.hdr);
+ return ret;
}
-end:
- WININET_Release( lpwh );
+ case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
+ TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER\n");
- TRACE("-- %s (bytes read: %d)\n", retval ? "TRUE": "FALSE", lpBuffersOut->dwBufferLength);
- return retval;
-}
+ if (*size < sizeof(ULONG))
+ return ERROR_INSUFFICIENT_BUFFER;
-/***********************************************************************
- * InternetReadFileExW (WININET.@)
- *
- * Read data from an open internet file.
- *
- * PARAMS
- * hFile [I] Handle returned by InternetOpenUrl() or HttpOpenRequest().
- * lpBuffersOut [I/O] Buffer.
- * dwFlags [I] Flags.
- * dwContext [I] Context for callbacks.
- *
- * RETURNS
- * FALSE, last error is set to ERROR_CALL_NOT_IMPLEMENTED
- *
- * NOTES
- * Not implemented in Wine or native either (as of IE6 SP2).
- *
- */
-BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer,
- DWORD dwFlags, DWORD_PTR dwContext)
-{
- ERR("(%p, %p, 0x%x, 0x%lx): not implemented in native\n", hFile, lpBuffer, dwFlags, dwContext);
+ *(ULONG*)buffer = 2;
+ *size = sizeof(ULONG);
- INTERNET_SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return FALSE;
-}
+ return ERROR_SUCCESS;
-/***********************************************************************
- * INET_QueryOptionHelper (internal)
- */
-static BOOL INET_QueryOptionHelper(BOOL bIsUnicode, HINTERNET hInternet, DWORD dwOption,
- LPVOID lpBuffer, LPDWORD lpdwBufferLength)
-{
- LPWININETHANDLEHEADER lpwhh;
- BOOL bSuccess = FALSE;
+ case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
+ TRACE("INTERNET_OPTION_MAX_CONNS_1_0_SERVER\n");
- TRACE("(%p, 0x%08x, %p, %p)\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
+ if (*size < sizeof(ULONG))
+ return ERROR_INSUFFICIENT_BUFFER;
- lpwhh = (LPWININETHANDLEHEADER) WININET_GetObject( hInternet );
+ *(ULONG*)size = 4;
+ *size = sizeof(ULONG);
- switch (dwOption)
- {
- case INTERNET_OPTION_HANDLE_TYPE:
- {
- ULONG type;
+ return ERROR_SUCCESS;
- if (!lpwhh)
- {
- WARN("Invalid hInternet handle\n");
- INTERNET_SetLastError(ERROR_INVALID_HANDLE);
- return FALSE;
- }
+ case INTERNET_OPTION_SECURITY_FLAGS:
+ FIXME("INTERNET_OPTION_SECURITY_FLAGS: Stub\n");
+ return ERROR_SUCCESS;
- type = lpwhh->htype;
+ case INTERNET_OPTION_VERSION: {
+ static const INTERNET_VERSION_INFO info = { 1, 2 };
- TRACE("INTERNET_OPTION_HANDLE_TYPE: %d\n", type);
+ TRACE("INTERNET_OPTION_VERSION\n");
- if (*lpdwBufferLength < sizeof(ULONG))
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- memcpy(lpBuffer, &type, sizeof(ULONG));
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(ULONG);
- break;
- }
+ if (*size < sizeof(INTERNET_VERSION_INFO))
+ return ERROR_INSUFFICIENT_BUFFER;
- case INTERNET_OPTION_REQUEST_FLAGS:
- {
- ULONG flags = 4;
- TRACE("INTERNET_OPTION_REQUEST_FLAGS: %d\n", flags);
- if (*lpdwBufferLength < sizeof(ULONG))
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- memcpy(lpBuffer, &flags, sizeof(ULONG));
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(ULONG);
- break;
- }
+ memcpy(buffer, &info, sizeof(info));
+ *size = sizeof(info);
- case INTERNET_OPTION_URL:
- case INTERNET_OPTION_DATAFILE_NAME:
- {
- if (!lpwhh)
- {
- WARN("Invalid hInternet handle\n");
- INTERNET_SetLastError(ERROR_INVALID_HANDLE);
- return FALSE;
- }
- if (lpwhh->htype == WH_HHTTPREQ)
- {
- LPWININETHTTPREQW lpreq = (LPWININETHTTPREQW) lpwhh;
- WCHAR url[1023];
- static const WCHAR szFmt[] = {'h','t','t','p',':','/','/','%','s','%','s',0};
- static const WCHAR szHost[] = {'H','o','s','t',0};
- DWORD sizeRequired;
- LPHTTPHEADERW Host;
-
- Host = HTTP_GetHeader(lpreq,szHost);
- sprintfW(url,szFmt,Host->lpszValue,lpreq->lpszPath);
- TRACE("INTERNET_OPTION_URL: %s\n",debugstr_w(url));
- if(!bIsUnicode)
- {
- sizeRequired = WideCharToMultiByte(CP_ACP,0,url,-1,
- lpBuffer,*lpdwBufferLength,NULL,NULL);
- if (sizeRequired > *lpdwBufferLength)
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- bSuccess = TRUE;
- *lpdwBufferLength = sizeRequired;
- }
- else
- {
- sizeRequired = (lstrlenW(url)+1) * sizeof(WCHAR);
- if (*lpdwBufferLength < sizeRequired)
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- strcpyW(lpBuffer, url);
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeRequired;
- }
- }
- break;
- }
- case INTERNET_OPTION_HTTP_VERSION:
- {
- if (*lpdwBufferLength < sizeof(HTTP_VERSION_INFO))
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- /*
- * Presently hardcoded to 1.1
- */
- ((HTTP_VERSION_INFO*)lpBuffer)->dwMajorVersion = 1;
- ((HTTP_VERSION_INFO*)lpBuffer)->dwMinorVersion = 1;
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(HTTP_VERSION_INFO);
- break;
- }
- case INTERNET_OPTION_CONNECTED_STATE:
- {
- DWORD *pdwConnectedState = (DWORD *)lpBuffer;
- FIXME("INTERNET_OPTION_CONNECTED_STATE: semi-stub\n");
+ return ERROR_SUCCESS;
+ }
+
+ case INTERNET_OPTION_PER_CONNECTION_OPTION: {
+ INTERNET_PER_CONN_OPTION_LISTW *con = buffer;
+ INTERNET_PER_CONN_OPTION_LISTA *conA = buffer;
+ DWORD res = ERROR_SUCCESS, i;
+ proxyinfo_t pi;
+ LONG ret;
- if (*lpdwBufferLength < sizeof(*pdwConnectedState))
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- *pdwConnectedState = INTERNET_STATE_CONNECTED;
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(*pdwConnectedState);
- break;
+ TRACE("Getting global proxy info\n");
+ if((ret = INTERNET_LoadProxySettings(&pi)))
+ return ret;
+
+ FIXME("INTERNET_OPTION_PER_CONNECTION_OPTION stub\n");
+
+ if (*size < sizeof(INTERNET_PER_CONN_OPTION_LISTW)) {
+ FreeProxyInfo(&pi);
+ return ERROR_INSUFFICIENT_BUFFER;
}
- case INTERNET_OPTION_PROXY:
- {
- LPWININETAPPINFOW lpwai = (LPWININETAPPINFOW)lpwhh;
- WININETAPPINFOW wai;
- if (lpwai == NULL)
- {
- TRACE("Getting global proxy info\n");
- memset(&wai, 0, sizeof(WININETAPPINFOW));
- INTERNET_ConfigureProxyFromReg( &wai );
- lpwai = &wai;
- }
+ for (i = 0; i < con->dwOptionCount; i++) {
+ INTERNET_PER_CONN_OPTIONW *option = con->pOptions + i;
+ INTERNET_PER_CONN_OPTIONA *optionA = conA->pOptions + i;
- if (bIsUnicode)
- {
- INTERNET_PROXY_INFOW *pPI = (INTERNET_PROXY_INFOW *)lpBuffer;
- DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
-
- if (lpwai->lpszProxy)
- proxyBytesRequired = (lstrlenW(lpwai->lpszProxy) + 1) *
- sizeof(WCHAR);
- if (lpwai->lpszProxyBypass)
- proxyBypassBytesRequired =
- (lstrlenW(lpwai->lpszProxyBypass) + 1) * sizeof(WCHAR);
- if (*lpdwBufferLength < sizeof(INTERNET_PROXY_INFOW) +
- proxyBytesRequired + proxyBypassBytesRequired)
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ switch (option->dwOption) {
+ case INTERNET_PER_CONN_FLAGS:
+ if(pi.dwProxyEnabled)
+ option->Value.dwValue = PROXY_TYPE_PROXY;
else
- {
- LPWSTR proxy = (LPWSTR)((LPBYTE)lpBuffer +
- sizeof(INTERNET_PROXY_INFOW));
- LPWSTR proxy_bypass = (LPWSTR)((LPBYTE)lpBuffer +
- sizeof(INTERNET_PROXY_INFOW) +
- proxyBytesRequired);
-
- pPI->dwAccessType = lpwai->dwAccessType;
- pPI->lpszProxy = NULL;
- pPI->lpszProxyBypass = NULL;
- if (lpwai->lpszProxy)
- {
- lstrcpyW(proxy, lpwai->lpszProxy);
- pPI->lpszProxy = proxy;
- }
+ option->Value.dwValue = PROXY_TYPE_DIRECT;
+ break;
- if (lpwai->lpszProxyBypass)
- {
- lstrcpyW(proxy_bypass, lpwai->lpszProxyBypass);
- pPI->lpszProxyBypass = proxy_bypass;
- }
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(INTERNET_PROXY_INFOW) +
- proxyBytesRequired + proxyBypassBytesRequired;
- }
- else
- {
- INTERNET_PROXY_INFOA *pPI = (INTERNET_PROXY_INFOA *)lpBuffer;
- DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
-
- if (lpwai->lpszProxy)
- proxyBytesRequired = WideCharToMultiByte(CP_ACP, 0,
- lpwai->lpszProxy, -1, NULL, 0, NULL, NULL);
- if (lpwai->lpszProxyBypass)
- proxyBypassBytesRequired = WideCharToMultiByte(CP_ACP, 0,
- lpwai->lpszProxyBypass, -1, NULL, 0, NULL, NULL);
- if (*lpdwBufferLength < sizeof(INTERNET_PROXY_INFOA) +
- proxyBytesRequired + proxyBypassBytesRequired)
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ case INTERNET_PER_CONN_PROXY_SERVER:
+ if (unicode)
+ option->Value.pszValue = heap_strdupW(pi.lpszProxyServer);
else
- {
- LPSTR proxy = (LPSTR)((LPBYTE)lpBuffer +
- sizeof(INTERNET_PROXY_INFOA));
- LPSTR proxy_bypass = (LPSTR)((LPBYTE)lpBuffer +
- sizeof(INTERNET_PROXY_INFOA) +
- proxyBytesRequired);
-
- pPI->dwAccessType = lpwai->dwAccessType;
- pPI->lpszProxy = NULL;
- pPI->lpszProxyBypass = NULL;
- if (lpwai->lpszProxy)
- {
- WideCharToMultiByte(CP_ACP, 0, lpwai->lpszProxy, -1,
- proxy, proxyBytesRequired, NULL, NULL);
- pPI->lpszProxy = proxy;
- }
-
- if (lpwai->lpszProxyBypass)
- {
- WideCharToMultiByte(CP_ACP, 0, lpwai->lpszProxyBypass,
- -1, proxy_bypass, proxyBypassBytesRequired,
- NULL, NULL);
- pPI->lpszProxyBypass = proxy_bypass;
- }
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(INTERNET_PROXY_INFOA) +
- proxyBytesRequired + proxyBypassBytesRequired;
- }
- break;
- }
- case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
- {
- ULONG conn = 2;
- TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER: %d\n", conn);
- if (*lpdwBufferLength < sizeof(ULONG))
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- memcpy(lpBuffer, &conn, sizeof(ULONG));
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(ULONG);
- break;
- }
- case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
- {
- ULONG conn = 4;
- TRACE("INTERNET_OPTION_MAX_CONNS_1_0_SERVER: %d\n", conn);
- if (*lpdwBufferLength < sizeof(ULONG))
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- else
- {
- memcpy(lpBuffer, &conn, sizeof(ULONG));
- bSuccess = TRUE;
- }
- *lpdwBufferLength = sizeof(ULONG);
- break;
- }
- case INTERNET_OPTION_SECURITY_FLAGS:
- FIXME("INTERNET_OPTION_SECURITY_FLAGS: Stub\n");
- bSuccess = TRUE;
- break;
+ optionA->Value.pszValue = heap_strdupWtoA(pi.lpszProxyServer);
+ break;
- case INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT:
- if (!lpwhh)
- {
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
- if (*lpdwBufferLength < sizeof(INTERNET_CERTIFICATE_INFOW))
- {
- *lpdwBufferLength = sizeof(INTERNET_CERTIFICATE_INFOW);
- INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
- }
- else if (lpwhh->htype == WH_HHTTPREQ)
- {
- LPWININETHTTPREQW lpwhr;
- PCCERT_CONTEXT context;
+ case INTERNET_PER_CONN_PROXY_BYPASS:
+ if (unicode)
+ option->Value.pszValue = heap_strdupW(pi.lpszProxyBypass);
+ else
+ optionA->Value.pszValue = heap_strdupWtoA(pi.lpszProxyBypass);
+ break;
- lpwhr = (LPWININETHTTPREQW)lpwhh;
- context = (PCCERT_CONTEXT)NETCON_GetCert(&(lpwhr->netConnection));
- if (context)
- {
- LPINTERNET_CERTIFICATE_INFOW info = (LPINTERNET_CERTIFICATE_INFOW)lpBuffer;
- DWORD strLen;
+ case INTERNET_PER_CONN_AUTOCONFIG_URL:
+ case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
+ case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
+ case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
+ FIXME("Unhandled dwOption %d\n", option->dwOption);
+ memset(&option->Value, 0, sizeof(option->Value));
+ break;
- memset(info,0,sizeof(INTERNET_CERTIFICATE_INFOW));
- info->ftExpiry = context->pCertInfo->NotAfter;
- info->ftStart = context->pCertInfo->NotBefore;
- if (bIsUnicode)
- {
- strLen = CertNameToStrW(context->dwCertEncodingType,
- &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
- NULL, 0);
- info->lpszSubjectInfo = LocalAlloc(0,
- strLen * sizeof(WCHAR));
- if (info->lpszSubjectInfo)
- CertNameToStrW(context->dwCertEncodingType,
- &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
- info->lpszSubjectInfo, strLen);
- strLen = CertNameToStrW(context->dwCertEncodingType,
- &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
- NULL, 0);
- info->lpszIssuerInfo = LocalAlloc(0,
- strLen * sizeof(WCHAR));
- if (info->lpszIssuerInfo)
- CertNameToStrW(context->dwCertEncodingType,
- &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
- info->lpszIssuerInfo, strLen);
- }
- else
- {
- LPINTERNET_CERTIFICATE_INFOA infoA =
- (LPINTERNET_CERTIFICATE_INFOA)info;
-
- strLen = CertNameToStrA(context->dwCertEncodingType,
- &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
- NULL, 0);
- infoA->lpszSubjectInfo = LocalAlloc(0, strLen);
- if (infoA->lpszSubjectInfo)
- CertNameToStrA(context->dwCertEncodingType,
- &context->pCertInfo->Subject, CERT_SIMPLE_NAME_STR,
- infoA->lpszSubjectInfo, strLen);
- strLen = CertNameToStrA(context->dwCertEncodingType,
- &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
- NULL, 0);
- infoA->lpszIssuerInfo = LocalAlloc(0, strLen);
- if (infoA->lpszIssuerInfo)
- CertNameToStrA(context->dwCertEncodingType,
- &context->pCertInfo->Issuer, CERT_SIMPLE_NAME_STR,
- infoA->lpszIssuerInfo, strLen);
- }
- /*
- * Contrary to MSDN, these do not appear to be set.
- * lpszProtocolName
- * lpszSignatureAlgName
- * lpszEncryptionAlgName
- * dwKeySize
- */
- CertFreeCertificateContext(context);
- bSuccess = TRUE;
- }
+ default:
+ FIXME("Unknown dwOption %d\n", option->dwOption);
+ res = ERROR_INVALID_PARAMETER;
+ break;
}
- break;
- default:
- FIXME("Stub! %d\n", dwOption);
- break;
+ }
+ FreeProxyInfo(&pi);
+
+ return res;
+ }
+ case INTERNET_OPTION_USER_AGENT:
+ return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
+ case INTERNET_OPTION_POLICY:
+ return ERROR_INVALID_PARAMETER;
}
- if (lpwhh)
- WININET_Release( lpwhh );
- return bSuccess;
+ FIXME("Stub for %d\n", option);
+ return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
}
/***********************************************************************
BOOL WINAPI InternetQueryOptionW(HINTERNET hInternet, DWORD dwOption,
LPVOID lpBuffer, LPDWORD lpdwBufferLength)
{
- return INET_QueryOptionHelper(TRUE, hInternet, dwOption, lpBuffer, lpdwBufferLength);
+ object_header_t *hdr;
+ DWORD res = ERROR_INVALID_HANDLE;
+
+ TRACE("%p %d %p %p\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
+
+ if(hInternet) {
+ hdr = WININET_GetObject(hInternet);
+ if (hdr) {
+ res = hdr->vtbl->QueryOption(hdr, dwOption, lpBuffer, lpdwBufferLength, TRUE);
+ WININET_Release(hdr);
+ }
+ }else {
+ res = INET_QueryOption(dwOption, lpBuffer, lpdwBufferLength, TRUE);
+ }
+
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
}
/***********************************************************************
BOOL WINAPI InternetQueryOptionA(HINTERNET hInternet, DWORD dwOption,
LPVOID lpBuffer, LPDWORD lpdwBufferLength)
{
- return INET_QueryOptionHelper(FALSE, hInternet, dwOption, lpBuffer, lpdwBufferLength);
+ object_header_t *hdr;
+ DWORD res = ERROR_INVALID_HANDLE;
+
+ TRACE("%p %d %p %p\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
+
+ if(hInternet) {
+ hdr = WININET_GetObject(hInternet);
+ if (hdr) {
+ res = hdr->vtbl->QueryOption(hdr, dwOption, lpBuffer, lpdwBufferLength, FALSE);
+ WININET_Release(hdr);
+ }
+ }else {
+ res = INET_QueryOption(dwOption, lpBuffer, lpdwBufferLength, FALSE);
+ }
+
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
}
BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
LPVOID lpBuffer, DWORD dwBufferLength)
{
- LPWININETHANDLEHEADER lpwhh;
+ object_header_t *lpwhh;
BOOL ret = TRUE;
- TRACE("0x%08x\n", dwOption);
+ TRACE("(%p %d %p %d)\n", hInternet, dwOption, lpBuffer, dwBufferLength);
- lpwhh = (LPWININETHANDLEHEADER) WININET_GetObject( hInternet );
- if( !lpwhh )
- return FALSE;
+ lpwhh = (object_header_t*) WININET_GetObject( hInternet );
+ if(lpwhh && lpwhh->vtbl->SetOption) {
+ DWORD res;
+
+ res = lpwhh->vtbl->SetOption(lpwhh, dwOption, lpBuffer, dwBufferLength);
+ if(res != ERROR_INTERNET_INVALID_OPTION) {
+ WININET_Release( lpwhh );
+
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+
+ return res == ERROR_SUCCESS;
+ }
+ }
switch (dwOption)
{
case INTERNET_OPTION_CALLBACK:
{
- INTERNET_STATUS_CALLBACK callback = *(INTERNET_STATUS_CALLBACK *)lpBuffer;
- ret = (set_status_callback(lpwhh, callback, TRUE) != INTERNET_INVALID_STATUS_CALLBACK);
- break;
+ if (!lpwhh)
+ {
+ SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+ return FALSE;
+ }
+ WININET_Release(lpwhh);
+ SetLastError(ERROR_INTERNET_OPTION_NOT_SETTABLE);
+ return FALSE;
}
case INTERNET_OPTION_HTTP_VERSION:
{
break;
case INTERNET_OPTION_ERROR_MASK:
{
- unsigned long flags=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_ERROR_MASK(%ld): STUB\n",flags);
+ ULONG flags = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_ERROR_MASK(%d): STUB\n", flags);
}
break;
case INTERNET_OPTION_CODEPAGE:
{
- unsigned long codepage=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_CODEPAGE (%ld): STUB\n",codepage);
+ ULONG codepage = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_CODEPAGE (%d): STUB\n", codepage);
}
break;
case INTERNET_OPTION_REQUEST_PRIORITY:
{
- unsigned long priority=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_REQUEST_PRIORITY (%ld): STUB\n",priority);
+ ULONG priority = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_REQUEST_PRIORITY (%d): STUB\n", priority);
}
break;
case INTERNET_OPTION_CONNECT_TIMEOUT:
{
- unsigned long connecttimeout=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_CONNECT_TIMEOUT (%ld): STUB\n",connecttimeout);
+ ULONG connecttimeout = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_CONNECT_TIMEOUT (%d): STUB\n", connecttimeout);
}
break;
case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
{
- unsigned long receivetimeout=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_DATA_RECEIVE_TIMEOUT (%ld): STUB\n",receivetimeout);
+ ULONG receivetimeout = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_DATA_RECEIVE_TIMEOUT (%d): STUB\n", receivetimeout);
}
break;
case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
{
- unsigned long conns=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_SERVER (%ld): STUB\n",conns);
+ ULONG conns = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_SERVER (%d): STUB\n", conns);
}
break;
case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
{
- unsigned long conns=*(unsigned long*)lpBuffer;
- FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER (%ld): STUB\n",conns);
+ ULONG conns = *(ULONG *)lpBuffer;
+ FIXME("Option INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER (%d): STUB\n", conns);
}
break;
case INTERNET_OPTION_RESET_URLCACHE_SESSION:
break;
case INTERNET_OPTION_SEND_TIMEOUT:
case INTERNET_OPTION_RECEIVE_TIMEOUT:
- TRACE("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT\n");
- if (dwBufferLength == sizeof(DWORD))
- {
- if (lpwhh->htype == WH_HHTTPREQ)
- ret = NETCON_set_timeout(
- &((LPWININETHTTPREQW)lpwhh)->netConnection,
- dwOption == INTERNET_OPTION_SEND_TIMEOUT,
- *(DWORD *)lpBuffer);
- else
- {
- FIXME("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT not supported on protocol %d\n",
- lpwhh->htype);
- }
- }
- else
- {
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
- ret = FALSE;
- }
+ {
+ ULONG timeout = *(ULONG *)lpBuffer;
+ FIXME("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT %d\n", timeout);
break;
+ }
case INTERNET_OPTION_CONNECT_RETRIES:
- FIXME("Option INTERNET_OPTION_CONNECT_RETRIES: STUB\n");
+ {
+ ULONG retries = *(ULONG *)lpBuffer;
+ FIXME("INTERNET_OPTION_CONNECT_RETRIES %d\n", retries);
break;
+ }
case INTERNET_OPTION_CONTEXT_VALUE:
FIXME("Option INTERNET_OPTION_CONTEXT_VALUE; STUB\n");
break;
case INTERNET_OPTION_SECURITY_FLAGS:
FIXME("Option INTERNET_OPTION_SECURITY_FLAGS; STUB\n");
break;
+ case INTERNET_OPTION_DISABLE_AUTODIAL:
+ FIXME("Option INTERNET_OPTION_DISABLE_AUTODIAL; STUB\n");
+ break;
+ case INTERNET_OPTION_HTTP_DECODING:
+ FIXME("INTERNET_OPTION_HTTP_DECODING; STUB\n");
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_COOKIES_3RD_PARTY:
+ FIXME("INTERNET_OPTION_COOKIES_3RD_PARTY; STUB\n");
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY:
+ FIXME("INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY; STUB\n");
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_CODEPAGE_PATH:
+ FIXME("INTERNET_OPTION_CODEPAGE_PATH; STUB\n");
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_CODEPAGE_EXTRA:
+ FIXME("INTERNET_OPTION_CODEPAGE_EXTRA; STUB\n");
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_IDN:
+ FIXME("INTERNET_OPTION_IDN; STUB\n");
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_POLICY:
+ SetLastError(ERROR_INVALID_PARAMETER);
+ ret = FALSE;
+ break;
+ case INTERNET_OPTION_PER_CONNECTION_OPTION: {
+ INTERNET_PER_CONN_OPTION_LISTW *con = lpBuffer;
+ LONG res;
+ int i;
+ proxyinfo_t pi;
+
+ INTERNET_LoadProxySettings(&pi);
+
+ for (i = 0; i < con->dwOptionCount; i++) {
+ INTERNET_PER_CONN_OPTIONW *option = con->pOptions + i;
+
+ switch (option->dwOption) {
+ case INTERNET_PER_CONN_PROXY_SERVER:
+ HeapFree(GetProcessHeap(), 0, pi.lpszProxyServer);
+ pi.lpszProxyServer = heap_strdupW(option->Value.pszValue);
+ break;
+
+ case INTERNET_PER_CONN_FLAGS:
+ if(option->Value.dwValue & PROXY_TYPE_PROXY)
+ pi.dwProxyEnabled = 1;
+ else
+ {
+ if(option->Value.dwValue != PROXY_TYPE_DIRECT)
+ FIXME("Unhandled flags: 0x%x\n", option->Value.dwValue);
+ pi.dwProxyEnabled = 0;
+ }
+ break;
+
+ case INTERNET_PER_CONN_AUTOCONFIG_URL:
+ case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
+ case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
+ case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
+ case INTERNET_PER_CONN_PROXY_BYPASS:
+ FIXME("Unhandled dwOption %d\n", option->dwOption);
+ break;
+
+ default:
+ FIXME("Unknown dwOption %d\n", option->dwOption);
+ SetLastError(ERROR_INVALID_PARAMETER);
+ break;
+ }
+ }
+
+ if ((res = INTERNET_SaveProxySettings(&pi)))
+ SetLastError(res);
+
+ FreeProxyInfo(&pi);
+
+ ret = (res == ERROR_SUCCESS);
+ break;
+ }
default:
FIXME("Option %d STUB\n",dwOption);
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
+ SetLastError(ERROR_INTERNET_INVALID_OPTION);
ret = FALSE;
break;
}
- WININET_Release( lpwhh );
+
+ if(lpwhh)
+ WININET_Release( lpwhh );
return ret;
}
{
case INTERNET_OPTION_CALLBACK:
{
- LPWININETHANDLEHEADER lpwh;
- INTERNET_STATUS_CALLBACK callback = *(INTERNET_STATUS_CALLBACK *)lpBuffer;
+ object_header_t *lpwh;
- if (!(lpwh = (LPWININETHANDLEHEADER)WININET_GetObject(hInternet))) return FALSE;
- r = (set_status_callback(lpwh, callback, FALSE) != INTERNET_INVALID_STATUS_CALLBACK);
+ if (!(lpwh = WININET_GetObject(hInternet)))
+ {
+ INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+ return FALSE;
+ }
WININET_Release(lpwh);
- return r;
+ INTERNET_SetLastError(ERROR_INTERNET_OPTION_NOT_SETTABLE);
+ return FALSE;
}
case INTERNET_OPTION_PROXY:
{
MultiByteToWideChar( CP_ACP, 0, lpBuffer, dwBufferLength,
wbuffer, wlen );
break;
+ case INTERNET_OPTION_PER_CONNECTION_OPTION: {
+ int i;
+ INTERNET_PER_CONN_OPTION_LISTW *listW;
+ INTERNET_PER_CONN_OPTION_LISTA *listA = lpBuffer;
+ wlen = sizeof(INTERNET_PER_CONN_OPTION_LISTW);
+ wbuffer = HeapAlloc( GetProcessHeap(), 0, wlen );
+ listW = wbuffer;
+
+ listW->dwSize = sizeof(INTERNET_PER_CONN_OPTION_LISTW);
+ if (listA->pszConnection)
+ {
+ wlen = MultiByteToWideChar( CP_ACP, 0, listA->pszConnection, -1, NULL, 0 );
+ listW->pszConnection = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, listA->pszConnection, -1, listW->pszConnection, wlen );
+ }
+ else
+ listW->pszConnection = NULL;
+ listW->dwOptionCount = listA->dwOptionCount;
+ listW->dwOptionError = listA->dwOptionError;
+ listW->pOptions = HeapAlloc( GetProcessHeap(), 0, sizeof(INTERNET_PER_CONN_OPTIONW) * listA->dwOptionCount );
+
+ for (i = 0; i < listA->dwOptionCount; ++i) {
+ INTERNET_PER_CONN_OPTIONA *optA = listA->pOptions + i;
+ INTERNET_PER_CONN_OPTIONW *optW = listW->pOptions + i;
+
+ optW->dwOption = optA->dwOption;
+
+ switch (optA->dwOption) {
+ case INTERNET_PER_CONN_AUTOCONFIG_URL:
+ case INTERNET_PER_CONN_PROXY_BYPASS:
+ case INTERNET_PER_CONN_PROXY_SERVER:
+ case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
+ if (optA->Value.pszValue)
+ {
+ wlen = MultiByteToWideChar( CP_ACP, 0, optA->Value.pszValue, -1, NULL, 0 );
+ optW->Value.pszValue = HeapAlloc( GetProcessHeap(), 0, wlen*sizeof(WCHAR) );
+ MultiByteToWideChar( CP_ACP, 0, optA->Value.pszValue, -1, optW->Value.pszValue, wlen );
+ }
+ else
+ optW->Value.pszValue = NULL;
+ break;
+ case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
+ case INTERNET_PER_CONN_FLAGS:
+ case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
+ optW->Value.dwValue = optA->Value.dwValue;
+ break;
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
+ optW->Value.ftValue = optA->Value.ftValue;
+ default:
+ WARN("Unknown PER_CONN dwOption: %d, guessing at conversion to Wide\n", optA->dwOption);
+ optW->Value.dwValue = optA->Value.dwValue;
+ break;
+ }
+ }
+ }
+ break;
default:
wbuffer = lpBuffer;
wlen = dwBufferLength;
r = InternetSetOptionW(hInternet,dwOption, wbuffer, wlen);
if( lpBuffer != wbuffer )
+ {
+ if (dwOption == INTERNET_OPTION_PER_CONNECTION_OPTION)
+ {
+ INTERNET_PER_CONN_OPTION_LISTW *list = wbuffer;
+ int i;
+ for (i = 0; i < list->dwOptionCount; ++i) {
+ INTERNET_PER_CONN_OPTIONW *opt = list->pOptions + i;
+ switch (opt->dwOption) {
+ case INTERNET_PER_CONN_AUTOCONFIG_URL:
+ case INTERNET_PER_CONN_PROXY_BYPASS:
+ case INTERNET_PER_CONN_PROXY_SERVER:
+ case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
+ case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
+ HeapFree( GetProcessHeap(), 0, opt->Value.pszValue );
+ break;
+ default:
+ break;
+ }
+ }
+ HeapFree( GetProcessHeap(), 0, list->pOptions );
+ }
HeapFree( GetProcessHeap(), 0, wbuffer );
+ }
return r;
}
FIXME("Flags %08x ignored\n", dwFlags);
if( dwFlags & ~ISO_VALID_FLAGS )
{
- INTERNET_SetLastError( ERROR_INVALID_PARAMETER );
+ SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
return InternetSetOptionW( hInternet, dwOption, lpBuffer, dwBufferLength );
TRACE( "%p 0x%08x %p 0x%08x\n", time, format, string, size );
+ if (!time || !string || format != INTERNET_RFC1123_FORMAT)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ if (size < INTERNET_RFC1123_BUFSIZE * sizeof(*string))
+ {
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
+ return FALSE;
+ }
+
ret = InternetTimeFromSystemTimeW( time, format, stringW, sizeof(stringW) );
if (ret) WideCharToMultiByte( CP_ACP, 0, stringW, -1, string, size, NULL, NULL );
TRACE( "%p 0x%08x %p 0x%08x\n", time, format, string, size );
- if (!time || !string) return FALSE;
+ if (!time || !string || format != INTERNET_RFC1123_FORMAT)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
- if (format != INTERNET_RFC1123_FORMAT || size < INTERNET_RFC1123_BUFSIZE * sizeof(WCHAR))
+ if (size < INTERNET_RFC1123_BUFSIZE * sizeof(*string))
+ {
+ SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE;
+ }
sprintfW( string, date,
WININET_wkday[time->wDayOfWeek],
{
BOOL ret = FALSE;
WCHAR *stringW;
- int len;
TRACE( "%s %p 0x%08x\n", debugstr_a(string), time, reserved );
- len = MultiByteToWideChar( CP_ACP, 0, string, -1, NULL, 0 );
- stringW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
-
+ stringW = heap_strdupAtoW(string);
if (stringW)
{
- MultiByteToWideChar( CP_ACP, 0, string, -1, stringW, len );
ret = InternetTimeToSystemTimeW( stringW, time, reserved );
HeapFree( GetProcessHeap(), 0, stringW );
}
if (lpszUrl == NULL)
{
/*
- * According to the doc we are supost to use the ip for the next
+ * According to the doc we are supposed to use the ip for the next
* server in the WnInet internal server database. I have
* no idea what that is or how to get it.
*
URL_COMPONENTSW components;
ZeroMemory(&components,sizeof(URL_COMPONENTSW));
- components.lpszHostName = (LPWSTR)&hostW;
+ components.lpszHostName = (LPWSTR)hostW;
components.dwHostNameLength = 1024;
if (!InternetCrackUrlW(lpszUrl,0,0,&components))
if (dwFlags & FLAG_ICC_FORCE_CONNECTION)
{
- struct sockaddr_in sin;
+ struct sockaddr_storage saddr;
+ socklen_t sa_len = sizeof(saddr);
int fd;
- if (!GetAddress(hostW, port, &sin))
+ if (!GetAddress(hostW, port, (struct sockaddr *)&saddr, &sa_len))
goto End;
- fd = socket(sin.sin_family, SOCK_STREAM, 0);
+ fd = socket(saddr.ss_family, SOCK_STREAM, 0);
if (fd != -1)
{
- if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) == 0)
+ if (connect(fd, (struct sockaddr *)&saddr, sa_len) == 0)
rc = TRUE;
close(fd);
}
*/
BOOL WINAPI InternetCheckConnectionA(LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
{
- WCHAR *szUrl;
- INT len;
+ WCHAR *url = NULL;
BOOL rc;
- len = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0);
- if (!(szUrl = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR))))
- return FALSE;
- MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, szUrl, len);
- rc = InternetCheckConnectionW(szUrl, dwFlags, dwReserved);
- HeapFree(GetProcessHeap(), 0, szUrl);
-
+ if(lpszUrl) {
+ url = heap_strdupAtoW(lpszUrl);
+ if(!url)
+ return FALSE;
+ }
+
+ rc = InternetCheckConnectionW(url, dwFlags, dwReserved);
+
+ HeapFree(GetProcessHeap(), 0, url);
return rc;
}
* RETURNS
* handle of connection or NULL on failure
*/
-HINTERNET WINAPI INTERNET_InternetOpenUrlW(LPWININETAPPINFOW hIC, LPCWSTR lpszUrl,
+static HINTERNET INTERNET_InternetOpenUrlW(appinfo_t *hIC, LPCWSTR lpszUrl,
LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
{
URL_COMPONENTSW urlComponents;
WCHAR protocol[32], hostName[MAXHOSTNAME], userName[1024];
WCHAR password[1024], path[2048], extra[1024];
HINTERNET client = NULL, client1 = NULL;
+ DWORD res;
TRACE("(%p, %s, %s, %08x, %08x, %08lx)\n", hIC, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
dwHeadersLength, dwFlags, dwContext);
else
urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
}
+ if (urlComponents.nScheme == INTERNET_SCHEME_HTTPS) dwFlags |= INTERNET_FLAG_SECURE;
+
/* FIXME: should use pointers, not handles, as handles are not thread-safe */
- client = HTTP_Connect(hIC, hostName, urlComponents.nPort,
- userName, password, dwFlags, dwContext, INET_OPENURL);
- if(client == NULL)
+ res = HTTP_Connect(hIC, hostName, urlComponents.nPort,
+ userName, password, dwFlags, dwContext, INET_OPENURL, &client);
+ if(res != ERROR_SUCCESS) {
+ INTERNET_SetLastError(res);
break;
+ }
if (urlComponents.dwExtraInfoLength) {
WCHAR *path_extra;
/* gopher doesn't seem to be implemented in wine, but it's supposed
* to be supported by InternetOpenUrlA. */
default:
- INTERNET_SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
+ SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
break;
}
static void AsyncInternetOpenUrlProc(WORKREQUEST *workRequest)
{
struct WORKREQ_INTERNETOPENURLW const *req = &workRequest->u.InternetOpenUrlW;
- LPWININETAPPINFOW hIC = (LPWININETAPPINFOW) workRequest->hdr;
+ appinfo_t *hIC = (appinfo_t*) workRequest->hdr;
TRACE("%p\n", hIC);
LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
{
HINTERNET ret = NULL;
- LPWININETAPPINFOW hIC = NULL;
+ appinfo_t *hIC = NULL;
if (TRACE_ON(wininet)) {
TRACE("(%p, %s, %s, %08x, %08x, %08lx)\n", hInternet, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
if (!lpszUrl)
{
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
+ SetLastError(ERROR_INVALID_PARAMETER);
goto lend;
}
- hIC = (LPWININETAPPINFOW) WININET_GetObject( hInternet );
+ hIC = (appinfo_t*)WININET_GetObject( hInternet );
if (NULL == hIC || hIC->hdr.htype != WH_HINIT) {
- INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+ SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
goto lend;
}
workRequest.asyncproc = AsyncInternetOpenUrlProc;
workRequest.hdr = WININET_AddRef( &hIC->hdr );
- req = &workRequest.u.InternetOpenUrlW;
- req->lpszUrl = WININET_strdupW(lpszUrl);
- if (lpszHeaders)
- req->lpszHeaders = WININET_strdupW(lpszHeaders);
- else
- req->lpszHeaders = 0;
+ req = &workRequest.u.InternetOpenUrlW;
+ req->lpszUrl = heap_strdupW(lpszUrl);
+ req->lpszHeaders = heap_strdupW(lpszHeaders);
req->dwHeadersLength = dwHeadersLength;
req->dwFlags = dwFlags;
req->dwContext = dwContext;
/*
* This is from windows.
*/
- INTERNET_SetLastError(ERROR_IO_PENDING);
+ SetLastError(ERROR_IO_PENDING);
} else {
ret = INTERNET_InternetOpenUrlW(hIC, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext);
}
HINTERNET WINAPI InternetOpenUrlA(HINTERNET hInternet, LPCSTR lpszUrl,
LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
{
- HINTERNET rc = (HINTERNET)NULL;
-
- INT lenUrl;
- INT lenHeaders = 0;
+ HINTERNET rc = NULL;
+ DWORD lenHeaders = 0;
LPWSTR szUrl = NULL;
LPWSTR szHeaders = NULL;
TRACE("\n");
if(lpszUrl) {
- lenUrl = MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, NULL, 0 );
- szUrl = HeapAlloc(GetProcessHeap(), 0, lenUrl*sizeof(WCHAR));
+ szUrl = heap_strdupAtoW(lpszUrl);
if(!szUrl)
- return (HINTERNET)NULL;
- MultiByteToWideChar(CP_ACP, 0, lpszUrl, -1, szUrl, lenUrl);
+ return NULL;
}
-
+
if(lpszHeaders) {
lenHeaders = MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, NULL, 0 );
szHeaders = HeapAlloc(GetProcessHeap(), 0, lenHeaders*sizeof(WCHAR));
if(!szHeaders) {
HeapFree(GetProcessHeap(), 0, szUrl);
- return (HINTERNET)NULL;
+ return NULL;
}
MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, szHeaders, lenHeaders);
}
*/
void INTERNET_SetLastError(DWORD dwError)
{
- LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
+ LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
if (!lpwite)
lpwite = INTERNET_AllocThreadError();
*/
DWORD INTERNET_GetLastError(void)
{
- LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
+ LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
if (!lpwite) return 0;
/* TlsGetValue clears last error, so set it again here */
SetLastError(lpwite->dwError);
TRACE("\n");
- memcpy(&workRequest, lpRequest, sizeof(WORKREQUEST));
+ workRequest = *lpRequest;
HeapFree(GetProcessHeap(), 0, lpRequest);
workRequest.asyncproc(&workRequest);
-
WININET_Release( workRequest.hdr );
+
+ if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
+ {
+ HeapFree(GetProcessHeap(), 0, TlsGetValue(g_dwTlsErrIndex));
+ TlsSetValue(g_dwTlsErrIndex, NULL);
+ }
return TRUE;
}
* RETURNS
*
*/
-BOOL INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest)
+DWORD INTERNET_AsyncCall(LPWORKREQUEST lpWorkRequest)
{
BOOL bSuccess;
LPWORKREQUEST lpNewRequest;
lpNewRequest = HeapAlloc(GetProcessHeap(), 0, sizeof(WORKREQUEST));
if (!lpNewRequest)
- return FALSE;
+ return ERROR_OUTOFMEMORY;
- memcpy(lpNewRequest, lpWorkRequest, sizeof(WORKREQUEST));
+ *lpNewRequest = *lpWorkRequest;
bSuccess = QueueUserWorkItem(INTERNET_WorkerThreadFunc, lpNewRequest, WT_EXECUTELONGFUNCTION);
if (!bSuccess)
{
HeapFree(GetProcessHeap(), 0, lpNewRequest);
- INTERNET_SetLastError(ERROR_INTERNET_ASYNC_THREAD_FAILED);
+ return ERROR_INTERNET_ASYNC_THREAD_FAILED;
}
- return bSuccess;
+ return ERROR_SUCCESS;
}
*/
LPSTR INTERNET_GetResponseBuffer(void)
{
- LPWITHREADERROR lpwite = (LPWITHREADERROR)TlsGetValue(g_dwTlsErrIndex);
+ LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
if (!lpwite)
lpwite = INTERNET_AllocThreadError();
TRACE("\n");
* INTERNET_STATUS_REQUEST_COMPLETE will be sent when more
* data is available.
*/
-void AsyncInternetQueryDataAvailableProc(WORKREQUEST *workRequest)
-{
- LPWININETHTTPREQW lpwhr;
- INTERNET_ASYNC_RESULT iar;
- char buffer[4048];
-
- TRACE("INTERNETQUERYDATAAVAILABLE %p\n", workRequest->hdr);
-
- switch (workRequest->hdr->htype)
- {
- case WH_HHTTPREQ:
- lpwhr = (LPWININETHTTPREQW)workRequest->hdr;
- iar.dwResult = NETCON_recv(&lpwhr->netConnection, buffer,
- min(sizeof(buffer),
- lpwhr->dwContentLength - lpwhr->dwContentRead),
- MSG_PEEK, (int *)&iar.dwError);
- INTERNET_SendCallback(workRequest->hdr, workRequest->hdr->dwContext,
- INTERNET_STATUS_REQUEST_COMPLETE, &iar,
- sizeof(INTERNET_ASYNC_RESULT));
- break;
-
- default:
- FIXME("unsupported file type\n");
- break;
- }
-}
-
BOOL WINAPI InternetQueryDataAvailable( HINTERNET hFile,
LPDWORD lpdwNumberOfBytesAvailble,
DWORD dwFlags, DWORD_PTR dwContext)
{
- LPWININETHTTPREQW lpwhr;
- BOOL retval = FALSE;
- char buffer[4048];
+ object_header_t *hdr;
+ DWORD res;
- lpwhr = (LPWININETHTTPREQW) WININET_GetObject( hFile );
- if (NULL == lpwhr)
- {
- INTERNET_SetLastError(ERROR_NO_MORE_FILES);
+ TRACE("(%p %p %x %lx)\n", hFile, lpdwNumberOfBytesAvailble, dwFlags, dwContext);
+
+ hdr = WININET_GetObject( hFile );
+ if (!hdr) {
+ SetLastError(ERROR_INVALID_HANDLE);
return FALSE;
}
- TRACE("--> %p %i\n",lpwhr,lpwhr->hdr.htype);
-
- switch (lpwhr->hdr.htype)
- {
- case WH_HHTTPREQ:
- retval = TRUE;
- if (NETCON_query_data_available(&lpwhr->netConnection,
- lpdwNumberOfBytesAvailble) &&
- !*lpdwNumberOfBytesAvailble)
- {
- /* Even if we are in async mode, we need to determine whether
- * there is actually more data available. We do this by trying
- * to peek only a single byte in async mode. */
- BOOL async = (lpwhr->lpHttpSession->lpAppInfo->hdr.dwFlags & INTERNET_FLAG_ASYNC);
- if (NETCON_recv(&lpwhr->netConnection, buffer,
- min(async ? 1 : sizeof(buffer),
- lpwhr->dwContentLength - lpwhr->dwContentRead),
- MSG_PEEK, (int *)lpdwNumberOfBytesAvailble) &&
- async && *lpdwNumberOfBytesAvailble)
- {
- WORKREQUEST workRequest;
-
- *lpdwNumberOfBytesAvailble = 0;
- workRequest.asyncproc = AsyncInternetQueryDataAvailableProc;
- workRequest.hdr = WININET_AddRef( &lpwhr->hdr );
-
- retval = INTERNET_AsyncCall(&workRequest);
- if (!retval)
- {
- WININET_Release( &lpwhr->hdr );
- }
- else
- {
- INTERNET_SetLastError(ERROR_IO_PENDING);
- retval = FALSE;
- }
- }
- }
- break;
-
- default:
- FIXME("unsupported file type\n");
- break;
+ if(hdr->vtbl->QueryDataAvailable) {
+ res = hdr->vtbl->QueryDataAvailable(hdr, lpdwNumberOfBytesAvailble, dwFlags, dwContext);
+ }else {
+ WARN("wrong handle\n");
+ res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
}
- WININET_Release( &lpwhr->hdr );
- TRACE("<-- %i\n",retval);
- return retval;
+ WININET_Release(hdr);
+
+ if(res != ERROR_SUCCESS)
+ SetLastError(res);
+ return res == ERROR_SUCCESS;
}
index = scheme - INTERNET_SCHEME_FIRST;
if (index >= sizeof(url_schemes)/sizeof(url_schemes[0]))
return NULL;
- return (LPCWSTR)&url_schemes[index];
+ return (LPCWSTR)url_schemes[index];
}
/* we can calculate using ansi strings because we're just
if (lpUrlComponents->lpszUrlPath)
*lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
+ if (lpUrlComponents->lpszExtraInfo)
+ *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, ExtraInfo);
+
return TRUE;
}
if (!lpUrlComponents || lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
{
- INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
+ SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
}
-
if (lpUrlComponents->lpszUrlPath)
{
dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
lpszUrl += dwLen;
}
+ if (lpUrlComponents->lpszExtraInfo)
+ {
+ dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, ExtraInfo);
+ memcpy(lpszUrl, lpUrlComponents->lpszExtraInfo, dwLen * sizeof(WCHAR));
+ lpszUrl += dwLen;
+ }
+
*lpszUrl = '\0';
return TRUE;
return ERROR_SUCCESS;
}
+static DWORD zone_preference = 3;
+
+/***********************************************************************
+ * PrivacySetZonePreferenceW (WININET.@)
+ */
+DWORD WINAPI PrivacySetZonePreferenceW( DWORD zone, DWORD type, DWORD template, LPCWSTR preference )
+{
+ FIXME( "%x %x %x %s: stub\n", zone, type, template, debugstr_w(preference) );
+
+ zone_preference = template;
+ return 0;
+}
+
+/***********************************************************************
+ * PrivacyGetZonePreferenceW (WININET.@)
+ */
+DWORD WINAPI PrivacyGetZonePreferenceW( DWORD zone, DWORD type, LPDWORD template,
+ LPWSTR preference, LPDWORD length )
+{
+ FIXME( "%x %x %p %p %p: stub\n", zone, type, template, preference, length );
+
+ if (template) *template = zone_preference;
+ return 0;
+}
+
DWORD WINAPI InternetDialA( HWND hwndParent, LPSTR lpszConnectoid, DWORD dwFlags,
DWORD_PTR* lpdwConnection, DWORD dwReserved )
{
projects / reactos.git / blobdiff