[ros-diffs] [cwittich] 41333: sync urlmon and winhttp with wine 1.1.23

Author: cwittich
Date: Sun Jun  7 16:32:05 2009
New Revision: 41333

URL: http://svn.reactos.org/svn/reactos?rev=41333&view=rev
Log:
sync urlmon and winhttp with wine 1.1.23

Added:
    trunk/reactos/dll/win32/winhttp/cookie.c   (with props)
    trunk/reactos/dll/win32/winhttp/url.c   (with props)
Modified:
    trunk/reactos/dll/win32/urlmon/bindprot.c
    trunk/reactos/dll/win32/urlmon/http.c
    trunk/reactos/dll/win32/urlmon/urlmon_main.c
    trunk/reactos/dll/win32/winhttp/main.c
    trunk/reactos/dll/win32/winhttp/net.c
    trunk/reactos/dll/win32/winhttp/request.c
    trunk/reactos/dll/win32/winhttp/session.c
    trunk/reactos/dll/win32/winhttp/winhttp.rbuild
    trunk/reactos/dll/win32/winhttp/winhttp_private.h
    trunk/reactos/include/psdk/winhttp.h

Modified: trunk/reactos/dll/win32/urlmon/bindprot.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/urlmon/bindprot.…
==============================================================================
--- trunk/reactos/dll/win32/urlmon/bindprot.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/urlmon/bindprot.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -608,10 +608,14 @@
 static HRESULT WINAPI ProtocolHandler_Continue(IInternetProtocol *iface, PROTOCOLDATA
*pProtocolData)
 {
     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
+    HRESULT hres;
 
     TRACE("(%p)->(%p)\n", This, pProtocolData);
 
-    return IInternetProtocol_Continue(This->protocol, pProtocolData);
+    hres = IInternetProtocol_Continue(This->protocol, pProtocolData);
+
+    heap_free(pProtocolData);
+    return hres;
 }
 
 static HRESULT WINAPI ProtocolHandler_Abort(IInternetProtocol *iface, HRESULT hrReason,
@@ -874,14 +878,14 @@
 
 typedef struct {
     task_header_t header;
-    PROTOCOLDATA data;
+    PROTOCOLDATA *data;
 } switch_task_t;
 
 static void switch_proc(BindProtocol *bind, task_header_t *t)
 {
     switch_task_t *task = (switch_task_t*)t;
 
-    IInternetProtocol_Continue(bind->protocol_handler, &task->data);
+    IInternetProtocol_Continue(bind->protocol_handler, task->data);
 
     heap_free(task);
 }
@@ -890,11 +894,17 @@
         PROTOCOLDATA *pProtocolData)
 {
     BindProtocol *This = PROTSINK_THIS(iface);
+    PROTOCOLDATA *data;
 
     TRACE("(%p)->(%p)\n", This, pProtocolData);
 
     TRACE("flags %x state %x data %p cb %u\n", pProtocolData->grfFlags,
pProtocolData->dwState,
           pProtocolData->pData, pProtocolData->cbData);
+
+    data = heap_alloc(sizeof(PROTOCOLDATA));
+    if(!data)
+        return E_OUTOFMEMORY;
+    memcpy(data, pProtocolData, sizeof(PROTOCOLDATA));
 
     if(!do_direct_notif(This)) {
         switch_task_t *task;
@@ -903,18 +913,18 @@
         if(!task)
             return E_OUTOFMEMORY;
 
-        task->data = *pProtocolData;
+        task->data = data;
 
         push_task(This, &task->header, switch_proc);
         return S_OK;
     }
 
     if(!This->protocol_sink) {
-        IInternetProtocol_Continue(This->protocol_handler, pProtocolData);
+        IInternetProtocol_Continue(This->protocol_handler, data);
         return S_OK;
     }
 
-    return IInternetProtocolSink_Switch(This->protocol_sink, pProtocolData);
+    return IInternetProtocolSink_Switch(This->protocol_sink, data);
 }
 
 static void report_progress(BindProtocol *This, ULONG status_code, LPCWSTR status_text)

Modified: trunk/reactos/dll/win32/urlmon/http.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/urlmon/http.c?re…
==============================================================================
--- trunk/reactos/dll/win32/urlmon/http.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/urlmon/http.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -85,7 +85,7 @@
     BYTE security_id[512];
     DWORD len = 0;
     ULONG num = 0;
-    BOOL res;
+    BOOL res, b;
     HRESULT hres;
 
     static const WCHAR wszBindVerb[BINDVERB_CUSTOM][5] =
@@ -208,6 +208,11 @@
         else
             optional = (LPWSTR)This->base.bind_info.stgmedData.u.hGlobal;
     }
+
+    b = TRUE;
+    res = InternetSetOptionW(This->base.request, INTERNET_OPTION_HTTP_DECODING,
&b, sizeof(b));
+    if(!res)
+        WARN("InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %08x\n",
GetLastError());
 
     res = HttpSendRequestW(This->base.request, This->full_header,
lstrlenW(This->full_header),
             optional, optional ? This->base.bind_info.cbstgmedData : 0);

Modified: trunk/reactos/dll/win32/urlmon/urlmon_main.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/urlmon/urlmon_ma…
==============================================================================
--- trunk/reactos/dll/win32/urlmon/urlmon_main.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/urlmon/urlmon_main.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -36,7 +36,7 @@
 
 HINSTANCE URLMON_hInstance = 0;
 static HMODULE hCabinet = NULL;
-static DWORD urlmon_tls;
+static DWORD urlmon_tls = TLS_OUT_OF_INDEXES;
 
 static void init_session(BOOL);
 
@@ -56,9 +56,12 @@
 {
     tls_data_t *data;
 
-    if(!urlmon_tls) {
+    if(urlmon_tls == TLS_OUT_OF_INDEXES) {
         DWORD tls = TlsAlloc();
-        tls = InterlockedCompareExchange((LONG*)&urlmon_tls, tls, 0);
+        if(tls == TLS_OUT_OF_INDEXES)
+            return NULL;
+
+        tls = InterlockedCompareExchange((LONG*)&urlmon_tls, tls,
TLS_OUT_OF_INDEXES);
         if(tls != urlmon_tls)
             TlsFree(tls);
     }
@@ -83,7 +86,7 @@
 {
     tls_data_t *data;
 
-    if(!urlmon_tls)
+    if(urlmon_tls == TLS_OUT_OF_INDEXES)
         return;
 
     while(!list_empty(&tls_list)) {
@@ -99,7 +102,7 @@
 {
     tls_data_t *data;
 
-    if(!urlmon_tls)
+    if(urlmon_tls == TLS_OUT_OF_INDEXES)
         return;
 
     data = TlsGetValue(urlmon_tls);

Added: trunk/reactos/dll/win32/winhttp/cookie.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/cookie.c…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/cookie.c (added)
+++ trunk/reactos/dll/win32/winhttp/cookie.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -1,0 +1,281 @@
+/*
+ * Copyright 2008 Hans Leidekker for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+#include <stdarg.h>
+
+#include "wine/debug.h"
+#include "wine/list.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "winhttp.h"
+
+#include "winhttp_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
+
+static domain_t *add_domain( session_t *session, WCHAR *name )
+{
+    domain_t *domain;
+
+    if (!(domain = heap_alloc_zero( sizeof(domain_t) ))) return NULL;
+
+    list_init( &domain->entry );
+    list_init( &domain->cookies );
+
+    domain->name = name;
+    list_add_tail( &session->cookie_cache, &domain->entry );
+
+    TRACE("%s\n", debugstr_w(domain->name));
+    return domain;
+}
+
+static cookie_t *find_cookie( domain_t *domain, const WCHAR *path, const WCHAR *name )
+{
+    struct list *item;
+    cookie_t *cookie;
+
+    LIST_FOR_EACH( item, &domain->cookies )
+    {
+        cookie = LIST_ENTRY( item, cookie_t, entry );
+        if (!strcmpW( cookie->path, path ) && !strcmpiW( cookie->name, name
))
+        {
+            TRACE("found %s=%s\n", debugstr_w(cookie->name),
debugstr_w(cookie->value));
+            return cookie;
+         }
+    }
+    return NULL;
+}
+
+static BOOL domain_match( const WCHAR *name, domain_t *domain, BOOL partial )
+{
+    TRACE("comparing %s with %s\n", debugstr_w(name),
debugstr_w(domain->name));
+
+    if (partial && !strstrW( name, domain->name )) return FALSE;
+    else if (!partial && strcmpW( name, domain->name )) return FALSE;
+    return TRUE;
+}
+
+static void free_cookie( cookie_t *cookie )
+{
+    heap_free( cookie->name );
+    heap_free( cookie->value );
+    heap_free( cookie->path );
+    heap_free( cookie );
+}
+
+static void delete_cookie( cookie_t *cookie )
+{
+    list_remove( &cookie->entry );
+    free_cookie( cookie );
+}
+
+void delete_domain( domain_t *domain )
+{
+    cookie_t *cookie;
+    struct list *item, *next;
+
+    LIST_FOR_EACH_SAFE( item, next, &domain->cookies )
+    {
+        cookie = LIST_ENTRY( item, cookie_t, entry );
+        delete_cookie( cookie );
+    }
+
+    list_remove( &domain->entry );
+    heap_free( domain->name );
+    heap_free( domain );
+}
+
+static BOOL add_cookie( session_t *session, cookie_t *cookie, WCHAR *domain_name, WCHAR
*path )
+{
+    domain_t *domain = NULL;
+    cookie_t *old_cookie;
+    struct list *item;
+
+    LIST_FOR_EACH( item, &session->cookie_cache )
+    {
+        domain = LIST_ENTRY( item, domain_t, entry );
+        if (domain_match( domain_name, domain, FALSE )) break;
+        domain = NULL;
+    }
+    if (!domain)
+    {
+        if (!(domain = add_domain( session, domain_name ))) return FALSE;
+    }
+    else if ((old_cookie = find_cookie( domain, path, cookie->name ))) delete_cookie(
old_cookie );
+
+    cookie->path = path;
+    list_add_tail( &domain->cookies, &cookie->entry );
+
+    TRACE("domain %s path %s <- %s=%s\n", debugstr_w(domain_name),
debugstr_w(cookie->path),
+          debugstr_w(cookie->name), debugstr_w(cookie->value));
+    return TRUE;
+}
+
+static cookie_t *parse_cookie( const WCHAR *string )
+{
+    cookie_t *cookie;
+    const WCHAR *p;
+    int len;
+
+    if (!(cookie = heap_alloc_zero( sizeof(cookie_t) ))) return NULL;
+
+    list_init( &cookie->entry );
+
+    if (!(p = strchrW( string, '=' )))
+    {
+        WARN("no '=' in %s\n", debugstr_w(string));
+        return NULL;
+    }
+    if (p == string)
+    {
+        WARN("empty cookie name in %s\n", debugstr_w(string));
+        return NULL;
+    }
+    len = p - string;
+    if (!(cookie->name = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+    {
+        heap_free( cookie );
+        return NULL;
+    }
+    memcpy( cookie->name, string, len * sizeof(WCHAR) );
+    cookie->name[len] = 0;
+
+    p++; /* skip '=' */
+    while (*p == ' ') p++;
+
+    len = strlenW( p );
+    if (!(cookie->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
+    {
+        free_cookie( cookie );
+        return NULL;
+    }
+    memcpy( cookie->value, p, len * sizeof(WCHAR) );
+    cookie->value[len] = 0;
+
+    return cookie;
+}
+
+BOOL set_cookies( request_t *request, const WCHAR *cookies )
+{
+    static const WCHAR pathW[] = {'p','a','t','h',0};
+    static const WCHAR domainW[] =
{'d','o','m','a','i','n',0};
+
+    BOOL ret = FALSE;
+    WCHAR *buffer, *p, *q, *r;
+    WCHAR *cookie_domain = NULL, *cookie_path = NULL;
+    session_t *session = request->connect->session;
+    cookie_t *cookie;
+    int len;
+
+    len = strlenW( cookies );
+    if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
+    strcpyW( buffer, cookies );
+
+    p = buffer;
+    while (*p && *p != ';') p++;
+    if (*p == ';') *p++ = 0;
+    if (!(cookie = parse_cookie( buffer )))
+    {
+        heap_free( buffer );
+        return FALSE;
+    }
+    if ((q = strstrW( p, domainW ))) /* FIXME: do real attribute parsing */
+    {
+        while (*q && *q != '=') q++;
+        if (!*q) goto end;
+
+        r = ++q;
+        while (*r && *r != ';') r++;
+        len = r - q;
+
+        if (!(cookie_domain = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+        memcpy( cookie_domain, q, len * sizeof(WCHAR) );
+        cookie_domain[len] = 0;
+
+    }
+    if ((q = strstrW( p, pathW )))
+    {
+        while (*q && *q != '=') q++;
+        if (!*q) goto end;
+
+        r = ++q;
+        while (*r && *r != ';') r++;
+        len = r - q;
+
+        if (!(cookie_path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+        memcpy( cookie_path, q, len * sizeof(WCHAR) );
+        cookie_path[len] = 0;
+    }
+    if (!cookie_domain && !(cookie_domain = strdupW(
request->connect->servername ))) goto end;
+    if (!cookie_path && !(cookie_path = strdupW( request->path ))) goto end;
+
+    if ((p = strrchrW( cookie_path, '/' )) && p != cookie_path) *p = 0;
+    ret = add_cookie( session, cookie, cookie_domain, cookie_path );
+
+end:
+    if (!ret)
+    {
+        free_cookie( cookie );
+        heap_free( cookie_domain );
+        heap_free( cookie_path );
+    }
+    heap_free( buffer );
+    return ret;
+}
+
+BOOL add_cookie_headers( request_t *request )
+{
+    struct list *domain_cursor;
+    session_t *session = request->connect->session;
+
+    LIST_FOR_EACH( domain_cursor, &session->cookie_cache )
+    {
+        domain_t *domain = LIST_ENTRY( domain_cursor, domain_t, entry );
+        if (domain_match( request->connect->servername, domain, TRUE ))
+        {
+            struct list *cookie_cursor;
+            TRACE("found domain %s\n", debugstr_w(domain->name));
+
+            LIST_FOR_EACH( cookie_cursor, &domain->cookies )
+            {
+                cookie_t *cookie = LIST_ENTRY( cookie_cursor, cookie_t, entry );
+
+                TRACE("comparing path %s with %s\n",
debugstr_w(request->path), debugstr_w(cookie->path));
+
+                if (strstrW( request->path, cookie->path ) == request->path)
+                {
+                    const WCHAR format[] =
{'C','o','o','k','i','e',':','
','%','s','=','%','s',0};
+                    int len;
+                    WCHAR *header;
+
+                    len = strlenW( cookie->name ) + strlenW( format ) + strlenW(
cookie->value );
+                    if (!(header = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return
FALSE;
+
+                    sprintfW( header, format, cookie->name, cookie->value );
+
+                    TRACE("%s\n", debugstr_w(header));
+                    add_request_headers( request, header, len, WINHTTP_ADDREQ_FLAG_ADD
);
+                    heap_free( header );
+                }
+            }
+        }
+    }
+    return TRUE;
+}

Propchange: trunk/reactos/dll/win32/winhttp/cookie.c
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: trunk/reactos/dll/win32/winhttp/main.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/main.c?r…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/main.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winhttp/main.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -38,8 +38,6 @@
 {
     switch(fdwReason)
     {
-    case DLL_WINE_PREATTACH:
-        return FALSE;  /* prefer native version */
     case DLL_PROCESS_ATTACH:
         DisableThreadLibraryCalls(hInstDLL);
         break;
@@ -84,41 +82,3 @@
     FIXME("()\n");
     return S_OK;
 }
-
-#define SCHEME_HTTP  3
-#define SCHEME_HTTPS 4
-
-BOOL WINAPI InternetCrackUrlW( LPCWSTR, DWORD, DWORD, LPURL_COMPONENTSW );
-BOOL WINAPI InternetCreateUrlW( LPURL_COMPONENTS, DWORD, LPWSTR, LPDWORD );
-
-/***********************************************************************
- *          WinHttpCrackUrl (winhttp.@)
- */
-BOOL WINAPI WinHttpCrackUrl( LPCWSTR url, DWORD len, DWORD flags, LPURL_COMPONENTSW
components )
-{
-    BOOL ret;
-
-    TRACE("%s, %d, %x, %p\n", debugstr_w(url), len, flags, components);
-
-    if ((ret = InternetCrackUrlW( url, len, flags, components )))
-    {
-        /* fix up an incompatibility between wininet and winhttp */
-        if (components->nScheme == SCHEME_HTTP) components->nScheme =
INTERNET_SCHEME_HTTP;
-        else if (components->nScheme == SCHEME_HTTPS) components->nScheme =
INTERNET_SCHEME_HTTPS;
-        else
-        {
-            set_last_error( ERROR_WINHTTP_UNRECOGNIZED_SCHEME );
-            return FALSE;
-        }
-    }
-    return ret;
-}
-
-/***********************************************************************
- *          WinHttpCreateUrl (winhttp.@)
- */
-BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS comps, DWORD flags, LPWSTR url, LPDWORD
len )
-{
-    TRACE("%p, 0x%08x, %p, %p\n", comps, flags, url, len);
-    return InternetCreateUrlW( comps, flags, url, len );
-}

Modified: trunk/reactos/dll/win32/winhttp/net.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/net.c?re…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/net.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winhttp/net.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -48,12 +48,13 @@
 #include "windef.h"
 #include "winbase.h"
 #include "winhttp.h"
+#include "wincrypt.h"
+
+#include "winhttp_private.h"
 
 /* to avoid conflicts with the Unix socket headers */
 #define USE_WS_PREFIX
 #include "winsock2.h"
-
-#include "winhttp_private.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
 
@@ -83,6 +84,7 @@
 static void *libcrypto_handle;
 
 static SSL_METHOD *method;
+static SSL_CTX *ctx;
 
 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
 
@@ -90,7 +92,6 @@
 MAKE_FUNCPTR( SSL_load_error_strings );
 MAKE_FUNCPTR( SSLv23_method );
 MAKE_FUNCPTR( SSL_CTX_new );
-MAKE_FUNCPTR( SSL_CTX_free );
 MAKE_FUNCPTR( SSL_new );
 MAKE_FUNCPTR( SSL_free );
 MAKE_FUNCPTR( SSL_set_fd );
@@ -107,14 +108,15 @@
 MAKE_FUNCPTR( BIO_new_fp );
 MAKE_FUNCPTR( ERR_get_error );
 MAKE_FUNCPTR( ERR_error_string );
+MAKE_FUNCPTR( i2d_X509 );
 #undef MAKE_FUNCPTR
 
 #endif
 
-#if 0
 /* translate a unix error code into a winsock error code */
 static int sock_get_error( int err )
 {
+#if !defined(__MINGW32__) && !defined (_MSC_VER)
     switch (err)
     {
         case EINTR:             return WSAEINTR;
@@ -174,11 +176,9 @@
 #endif
     default: errno = err; perror( "sock_set_error" ); return WSAEFAULT;
     }
+#endif
     return err;
 }
-#else
-#define sock_get_error(x) WSAGetLastError()
-#endif
 
 BOOL netconn_init( netconn_t *conn, BOOL secure )
 {
@@ -210,7 +210,6 @@
     LOAD_FUNCPTR( SSL_load_error_strings );
     LOAD_FUNCPTR( SSLv23_method );
     LOAD_FUNCPTR( SSL_CTX_new );
-    LOAD_FUNCPTR( SSL_CTX_free );
     LOAD_FUNCPTR( SSL_new );
     LOAD_FUNCPTR( SSL_free );
     LOAD_FUNCPTR( SSL_set_fd );
@@ -235,6 +234,7 @@
     LOAD_FUNCPTR( BIO_new_fp );
     LOAD_FUNCPTR( ERR_get_error );
     LOAD_FUNCPTR( ERR_error_string );
+    LOAD_FUNCPTR( i2d_X509 );
 #undef LOAD_FUNCPTR
 
     pSSL_library_init();
@@ -242,8 +242,6 @@
     pBIO_new_fp( stderr, BIO_NOCLOSE );
 
     method = pSSLv23_method();
-    conn->ssl_ctx = pSSL_CTX_new( method );
-
 #else
     WARN("SSL support not compiled in.\n");
     set_last_error( ERROR_WINHTTP_SECURE_CHANNEL_ERROR );
@@ -314,13 +312,14 @@
     X509 *cert;
     long res;
 
-    if (!pSSL_CTX_set_default_verify_paths( conn->ssl_ctx ))
+    ctx = pSSL_CTX_new( method );
+    if (!pSSL_CTX_set_default_verify_paths( ctx ))
     {
         ERR("SSL_CTX_set_default_verify_paths failed: %s\n", pERR_error_string(
pERR_get_error(), 0 ));
         set_last_error( ERROR_OUTOFMEMORY );
         return FALSE;
     }
-    if (!(conn->ssl_conn = pSSL_new( conn->ssl_ctx )))
+    if (!(conn->ssl_conn = pSSL_new( ctx )))
     {
         ERR("SSL_new failed: %s\n", pERR_error_string( pERR_get_error(), 0 ));
         set_last_error( ERROR_OUTOFMEMORY );
@@ -468,11 +467,7 @@
         return TRUE;
     }
 #ifdef FIONREAD
-    if (!(ret = ioctlsocket( conn->socket, FIONREAD, &unread )))
-    {
-        TRACE("%d bytes of queued, but unread data\n", unread);
-        *available += unread;
-    }
+    if (!(ret = ioctlsocket( conn->socket, FIONREAD, &unread ))) *available =
unread;
 #endif
     return TRUE;
 }
@@ -491,8 +486,8 @@
 #ifdef SONAME_LIBSSL
         long timeout;
 
-        timeout = pSSL_CTX_get_timeout( conn->ssl_ctx );
-        pSSL_CTX_set_timeout( conn->ssl_ctx, DEFAULT_RECEIVE_TIMEOUT );
+        timeout = pSSL_CTX_get_timeout( ctx );
+        pSSL_CTX_set_timeout( ctx, DEFAULT_RECEIVE_TIMEOUT );
 
         while (recvd < *buflen)
         {
@@ -509,7 +504,7 @@
             }
             if (buffer[recvd] != '\r') recvd++;
         }
-        pSSL_CTX_set_timeout( conn->ssl_ctx, timeout );
+        pSSL_CTX_set_timeout( ctx, timeout );
         if (ret)
         {
             buffer[recvd++] = 0;
@@ -567,7 +562,7 @@
     tv.tv_sec = value / 1000;
     tv.tv_usec = (value % 1000) * 1000;
 
-    if ((res = setsockopt( netconn->socket, SOL_SOCKET, send ? SO_SNDTIMEO :
SO_RCVTIMEO, &tv, sizeof(tv) ) == -1))
+    if ((res = setsockopt( netconn->socket, SOL_SOCKET, send ? SO_SNDTIMEO :
SO_RCVTIMEO, (void*)&tv, sizeof(tv) ) == -1))
     {
         WARN("setsockopt failed (%s)\n", strerror( errno ));
         return sock_get_error( errno );
@@ -595,7 +590,7 @@
     heap_free( hostname );
     if (ret != 0)
     {
-        TRACE("failed to get address of %s (%s)\n", debugstr_a(hostname),
gai_strerror(ret));
+        TRACE("failed to get address of %s (%s)\n", debugstr_w(hostnameW),
gai_strerror(ret));
         return FALSE;
     }
     memset( sa, 0, sizeof(struct sockaddr_in) );
@@ -611,12 +606,12 @@
     heap_free( hostname );
     if (!he)
     {
-        TRACE("failed to get address of %s (%d)\n", debugstr_a(hostname),
h_errno);
+        TRACE("failed to get address of %s (%d)\n", debugstr_w(hostnameW),
h_errno);
         LeaveCriticalSection( &cs_gethostbyname );
         return FALSE;
     }
     memset( sa, 0, sizeof(struct sockaddr_in) );
-    memcpy( (char *)&sa->sin_addr, he->h_addr, he->h_length );
+    memcpy( &sa->sin_addr, he->h_addr, he->h_length );
     sa->sin_family = he->h_addrtype;
     sa->sin_port = htons( port );
 
@@ -624,3 +619,46 @@
 #endif
     return TRUE;
 }
+
+const void *netconn_get_certificate( netconn_t *conn )
+{
+#ifdef SONAME_LIBSSL
+    X509 *cert;
+    unsigned char *buffer, *p;
+    int len;
+    BOOL malloc = FALSE;
+    const CERT_CONTEXT *ret;
+
+    if (!conn->secure) return NULL;
+
+    if (!(cert = pSSL_get_peer_certificate( conn->ssl_conn ))) return NULL;
+    p = NULL;
+    if ((len = pi2d_X509( cert, &p )) < 0) return NULL;
+    /*
+     * SSL 0.9.7 and above malloc the buffer if it is null.
+     * however earlier version do not and so we would need to alloc the buffer.
+     *
+     * see the i2d_X509 man page for more details.
+     */
+    if (!p)
+    {
+        if (!(buffer = heap_alloc( len ))) return NULL;
+        p = buffer;
+        len = pi2d_X509( cert, &p );
+    }
+    else
+    {
+        buffer = p;
+        malloc = TRUE;
+    }
+
+    ret = CertCreateCertificateContext( X509_ASN_ENCODING, buffer, len );
+
+    if (malloc) free( buffer );
+    else heap_free( buffer );
+
+    return ret;
+#else
+    return NULL;
+#endif
+}

Modified: trunk/reactos/dll/win32/winhttp/request.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/request.…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/request.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winhttp/request.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -175,6 +175,22 @@
     NULL                            /* WINHTTP_QUERY_PASSPORT_CONFIG            = 78 */
 };
 
+static DWORD CALLBACK task_thread( LPVOID param )
+{
+    task_header_t *task = param;
+
+    task->proc( task );
+
+    release_object( &task->request->hdr );
+    heap_free( task );
+    return ERROR_SUCCESS;
+}
+
+static BOOL queue_task( task_header_t *task )
+{
+    return QueueUserWorkItem( task_thread, task, WT_EXECUTELONGFUNCTION );
+}
+
 static void free_header( header_t *header )
 {
     heap_free( header->field );
@@ -391,13 +407,13 @@
     return TRUE;
 }
 
-static BOOL add_request_headers( request_t *request, LPCWSTR headers, DWORD len, DWORD
flags )
+BOOL add_request_headers( request_t *request, LPCWSTR headers, DWORD len, DWORD flags )
 {
     BOOL ret = FALSE;
     WCHAR *buffer, *p, *q;
     header_t *header;
 
-    if (len == ~0UL) len = strlenW( headers );
+    if (len == ~0u) len = strlenW( headers );
     if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
     strcpyW( buffer, headers );
 
@@ -467,28 +483,20 @@
     static const WCHAR crlf[]    = {'\r','\n',0};
     static const WCHAR colon[]   = {':',' ',0};
     static const WCHAR twocrlf[] =
{'\r','\n','\r','\n',0};
-    static const WCHAR get[]     = {'G','E','T',0};
-    static const WCHAR slash[]   = {'/',0};
-    static const WCHAR http1_1[] =
{'H','T','T','P','/','1','.','1',0};
 
     WCHAR *ret;
     const WCHAR **headers, **p;
-    const WCHAR *verb = get, *path = slash, *version = http1_1;
     unsigned int len, i = 0, j;
-
-    if (request->verb && request->verb[0]) verb = request->verb;
-    if (request->path && request->path[0]) path = request->path;
-    if (request->version && request->version[0]) version =
request->version;
 
     /* allocate space for an array of all the string pointers to be added */
     len = request->num_headers * 4 + 7;
     if (!(headers = heap_alloc( len * sizeof(LPCWSTR) ))) return NULL;
 
-    headers[i++] = verb;
+    headers[i++] = request->verb;
     headers[i++] = space;
-    headers[i++] = path;
+    headers[i++] = request->path;
     headers[i++] = space;
-    headers[i++] = version;
+    headers[i++] = request->version;
 
     for (j = 0; j < request->num_headers; j++)
     {
@@ -561,7 +569,7 @@
         }
         else if (buffer)
         {
-            for (p = headers, q = (WCHAR *)buffer; *p; p++, q++)
+            for (p = headers, q = buffer; *p; p++, q++)
             {
                 if (*p != '\r') *q = *p;
                 else
@@ -571,7 +579,7 @@
                 }
             }
             *q = 0;
-            TRACE("returning data: %s\n", debugstr_wn((WCHAR *)buffer, len));
+            TRACE("returning data: %s\n", debugstr_wn(buffer, len));
             ret = TRUE;
         }
         *buflen = len * sizeof(WCHAR);
@@ -606,7 +614,7 @@
     }
     default:
     {
-        if (attr > sizeof(attribute_table)/sizeof(attribute_table[0]) ||
!attribute_table[attr])
+        if (attr >= sizeof(attribute_table)/sizeof(attribute_table[0]) ||
!attribute_table[attr])
         {
             FIXME("attribute %u not implemented\n", attr);
             return FALSE;
@@ -710,13 +718,16 @@
     connect_t *connect;
     char address[32];
     WCHAR *addressW;
+    INTERNET_PORT port;
 
     if (netconn_connected( &request->netconn )) return TRUE;
+
     connect = request->connect;
+    port = connect->hostport ? connect->hostport : (request->hdr.flags &
WINHTTP_FLAG_SECURE ? 443 : 80);
 
     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME,
connect->servername, strlenW(connect->servername) + 1 );
 
-    if (!netconn_resolve( connect->servername, connect->serverport,
&connect->sockaddr )) return FALSE;
+    if (!netconn_resolve( connect->servername, port, &connect->sockaddr ))
return FALSE;
     inet_ntop( connect->sockaddr.sin_family, &connect->sockaddr.sin_addr,
address, sizeof(address) );
     addressW = strdupAW( address );
 
@@ -759,32 +770,35 @@
     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, 0, 0
);
 }
 
-static BOOL add_host_header( request_t *request, WCHAR *hostname, INTERNET_PORT port,
DWORD modifier )
+static BOOL add_host_header( request_t *request, DWORD modifier )
 {
     BOOL ret;
     DWORD len;
     WCHAR *host;
     static const WCHAR fmt[] =
{'%','s',':','%','u',0};
+    connect_t *connect = request->connect;
+    INTERNET_PORT port;
+
+    port = connect->hostport ? connect->hostport : (request->hdr.flags &
WINHTTP_FLAG_SECURE ? 443 : 80);
 
     if (port == INTERNET_DEFAULT_HTTP_PORT || port == INTERNET_DEFAULT_HTTPS_PORT)
     {
-        return process_header( request, attr_host, hostname, modifier, TRUE );
-    }
-    len = strlenW( hostname ) + 7; /* sizeof(":65335") */
+        return process_header( request, attr_host, connect->hostname, modifier, TRUE
);
+    }
+    len = strlenW( connect->hostname ) + 7; /* sizeof(":65335") */
     if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
-    sprintfW( host, fmt, hostname, port );
+    sprintfW( host, fmt, connect->hostname, port );
     ret = process_header( request, attr_host, host, modifier, TRUE );
     heap_free( host );
     return ret;
 }
 
 static BOOL send_request( request_t *request, LPCWSTR headers, DWORD headers_len, LPVOID
optional,
-                          DWORD optional_len, DWORD total_len, DWORD_PTR context )
+                          DWORD optional_len, DWORD total_len, DWORD_PTR context, BOOL
async )
 {
     static const WCHAR keep_alive[] =
{'K','e','e','p','-','A','l','i','v','e',0};
     static const WCHAR no_cache[]   =
{'n','o','-','c','a','c','h','e',0};
     static const WCHAR length_fmt[] = {'%','l','d',0};
-    static const WCHAR post[]       =
{'P','O','S','T',0};
 
     BOOL ret = FALSE;
     connect_t *connect = request->connect;
@@ -798,9 +812,9 @@
         process_header( request, attr_user_agent, session->agent,
WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
 
     if (connect->hostname)
-        add_host_header( request, connect->hostname, connect->hostport,
WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
-
-    if (total_len || (request->verb && !strcmpW( request->verb, post )))
+        add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
+
+    if (total_len || (request->verb && !strcmpW( request->verb, postW )))
     {
         WCHAR length[21]; /* decimal long int + null */
         sprintfW( length, length_fmt, total_len );
@@ -820,6 +834,11 @@
         TRACE("failed to add request headers\n");
         return FALSE;
     }
+    if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) &&
!add_cookie_headers( request ))
+    {
+        WARN("failed to add cookie headers\n");
+        return FALSE;
+    }
 
     if (!(ret = open_connection( request ))) goto end;
     if (!(req = build_request_string( request ))) goto end;
@@ -840,8 +859,26 @@
     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_SENT, &len,
sizeof(DWORD) );
 
 end:
+    if (async)
+    {
+        if (ret) send_callback( &request->hdr,
WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NULL, 0 );
+        else
+        {
+            WINHTTP_ASYNC_RESULT result;
+            result.dwResult = API_SEND_REQUEST;
+            result.dwError  = get_last_error();
+            send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR,
&result, sizeof(result) );
+        }
+    }
     heap_free( req );
     return ret;
+}
+
+static void task_send_request( task_header_t *task )
+{
+    send_request_t *s = (send_request_t *)task;
+    send_request( s->hdr.request, s->headers, s->headers_len, s->optional,
s->optional_len, s->total_len, s->context, TRUE );
+    heap_free( s->headers );
 }
 
 /***********************************************************************
@@ -868,7 +905,25 @@
         return FALSE;
     }
 
-    ret = send_request( request, headers, headers_len, optional, optional_len, total_len,
context );
+    if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+    {
+        send_request_t *s;
+
+        if (!(s = heap_alloc( sizeof(send_request_t) ))) return FALSE;
+        s->hdr.request  = request;
+        s->hdr.proc     = task_send_request;
+        s->headers      = strdupW( headers );
+        s->headers_len  = headers_len;
+        s->optional     = optional;
+        s->optional_len = optional_len;
+        s->total_len    = total_len;
+        s->context      = context;
+
+        addref_object( &request->hdr );
+        ret = queue_task( (task_header_t *)s );
+    }
+    else
+        ret = send_request( request, headers, headers_len, optional, optional_len,
total_len, context, FALSE );
 
     release_object( &request->hdr );
     return ret;
@@ -889,9 +944,9 @@
 }
 
 #define MAX_REPLY_LEN   1460
-#define INITIAL_HEADER_BUFFER_SIZE  512
-
-static BOOL receive_response( request_t *request, BOOL clear )
+#define INITIAL_HEADER_BUFFER_LEN  512
+
+static BOOL read_reply( request_t *request )
 {
     static const WCHAR crlf[] = {'\r','\n',0};
 
@@ -902,9 +957,6 @@
     WCHAR status_codeW[4]; /* sizeof("nnn") */
 
     if (!netconn_connected( &request->netconn )) return FALSE;
-
-    /* clear old response headers (eg. from a redirect response) */
-    if (clear) clear_response_headers( request );
 
     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE,
NULL, 0 );
 
@@ -949,7 +1001,7 @@
     heap_free( request->status_text );
     request->status_text = status_textW;
 
-    len = max( buflen + crlf_len, INITIAL_HEADER_BUFFER_SIZE );
+    len = max( buflen + crlf_len, INITIAL_HEADER_BUFFER_LEN );
     if (!(raw_headers = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
     MultiByteToWideChar( CP_ACP, 0, buffer, buflen, raw_headers, buflen );
     memcpy( raw_headers + buflen - 1, crlf, sizeof(crlf) );
@@ -1002,6 +1054,7 @@
     connect_t *connect = request->connect;
     INTERNET_PORT port;
     WCHAR *hostname = NULL, *location = NULL;
+    int index;
 
     size = 0;
     query_headers( request, WINHTTP_QUERY_LOCATION, NULL, NULL, &size, NULL );
@@ -1012,48 +1065,73 @@
 
     memset( &uc, 0, sizeof(uc) );
     uc.dwStructSize = sizeof(uc);
-    uc.dwSchemeLength = uc.dwHostNameLength = uc.dwUrlPathLength = uc.dwExtraInfoLength =
~0UL;
-
-    if (!(ret = WinHttpCrackUrl( location, size / sizeof(WCHAR), 0, &uc ))) goto
end;
-
-    if (uc.nScheme == INTERNET_SCHEME_HTTP && request->hdr.flags &
WINHTTP_FLAG_SECURE)
-    {
-        TRACE("redirect from secure page to non-secure page\n");
-        request->hdr.flags &= ~WINHTTP_FLAG_SECURE;
-    }
-    else if (uc.nScheme == INTERNET_SCHEME_HTTPS && !(request->hdr.flags &
WINHTTP_FLAG_SECURE))
-    {
-        TRACE("redirect from non-secure page to secure page\n");
-        request->hdr.flags |= WINHTTP_FLAG_SECURE;
-    }
-
-    len = uc.dwHostNameLength;
-    if (!(hostname = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
-    memcpy( hostname, uc.lpszHostName, len * sizeof(WCHAR) );
-    hostname[len] = 0;
-
-    port = uc.nPort ? uc.nPort : (uc.nScheme == INTERNET_SCHEME_HTTPS ? 443 : 80);
-    if (strcmpiW( connect->servername, hostname ) || connect->serverport != port)
-    {
-        heap_free( connect->servername );
-        connect->servername = hostname;
-        connect->serverport = connect->hostport = port;
-
-        netconn_close( &request->netconn );
-        if (!(ret = netconn_init( &request->netconn, request->hdr.flags &
WINHTTP_FLAG_SECURE ))) goto end;
-    }
-    if (!(ret = add_host_header( request, hostname, port, WINHTTP_ADDREQ_FLAG_REPLACE )))
goto end;
-    if (!(ret = open_connection( request ))) goto end;
-
-    heap_free( request->path );
-    request->path = NULL;
-    if (uc.lpszUrlPath)
-    {
-        len = uc.dwUrlPathLength + uc.dwExtraInfoLength;
-        if (!(request->path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
-        strcpyW( request->path, uc.lpszUrlPath );
-    }
-
+    uc.dwSchemeLength = uc.dwHostNameLength = uc.dwUrlPathLength = uc.dwExtraInfoLength =
~0u;
+
+    if (!WinHttpCrackUrl( location, size / sizeof(WCHAR), 0, &uc )) /* assume
relative redirect */
+    {
+        WCHAR *path, *p;
+
+        len = strlenW( location ) + 1;
+        if (location[0] != '/') len++;
+        if (!(p = path = heap_alloc( len * sizeof(WCHAR) ))) goto end;
+
+        if (location[0] != '/') *p++ = '/';
+        strcpyW( p, location );
+
+        heap_free( request->path );
+        request->path = path;
+    }
+    else
+    {
+        if (uc.nScheme == INTERNET_SCHEME_HTTP && request->hdr.flags &
WINHTTP_FLAG_SECURE)
+        {
+            TRACE("redirect from secure page to non-secure page\n");
+            request->hdr.flags &= ~WINHTTP_FLAG_SECURE;
+        }
+        else if (uc.nScheme == INTERNET_SCHEME_HTTPS && !(request->hdr.flags
& WINHTTP_FLAG_SECURE))
+        {
+            TRACE("redirect from non-secure page to secure page\n");
+            request->hdr.flags |= WINHTTP_FLAG_SECURE;
+        }
+
+        len = uc.dwHostNameLength;
+        if (!(hostname = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+        memcpy( hostname, uc.lpszHostName, len * sizeof(WCHAR) );
+        hostname[len] = 0;
+
+        port = uc.nPort ? uc.nPort : (uc.nScheme == INTERNET_SCHEME_HTTPS ? 443 : 80);
+        if (strcmpiW( connect->servername, hostname ) || connect->serverport !=
port)
+        {
+            heap_free( connect->hostname );
+            connect->hostname = hostname;
+            heap_free( connect->servername );
+            connect->servername = strdupW( connect->hostname );
+            connect->serverport = connect->hostport = port;
+
+            netconn_close( &request->netconn );
+            if (!(ret = netconn_init( &request->netconn, request->hdr.flags
& WINHTTP_FLAG_SECURE ))) goto end;
+        }
+        if (!(ret = add_host_header( request, WINHTTP_ADDREQ_FLAG_REPLACE ))) goto end;
+        if (!(ret = open_connection( request ))) goto end;
+
+        heap_free( request->path );
+        request->path = NULL;
+        if (uc.dwUrlPathLength)
+        {
+            len = uc.dwUrlPathLength + uc.dwExtraInfoLength;
+            if (!(request->path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
+            strcpyW( request->path, uc.lpszUrlPath );
+        }
+        else request->path = strdupW( slashW );
+    }
+
+    /* remove content-type/length headers */
+    if ((index = get_header_index( request, attr_content_type, 0, TRUE )) >= 0)
delete_header( request, index );
+    if ((index = get_header_index( request, attr_content_length, 0, TRUE )) >= 0 )
delete_header( request, index );
+
+    /* redirects are always GET requests */
+    heap_free( request->verb );
+    request->verb = strdupW( getW );
     ret = TRUE;
 
 end:
@@ -1062,7 +1140,7 @@
     return ret;
 }
 
-static BOOL read_data( request_t *request, void *buffer, DWORD size, DWORD *read, BOOL
async )
+static BOOL receive_data( request_t *request, void *buffer, DWORD size, DWORD *read, BOOL
async )
 {
     DWORD to_read;
     int bytes_read;
@@ -1081,99 +1159,6 @@
     request->content_read += bytes_read;
     *read = bytes_read;
     return TRUE;
-}
-
-/* read any content returned by the server so that the connection can be reused */
-static void drain_content( request_t *request )
-{
-    DWORD bytes_read;
-    char buffer[2048];
-
-    if (request->content_length == ~0UL) return;
-    for (;;)
-    {
-        if (!read_data( request, buffer, sizeof(buffer), &bytes_read, FALSE ) ||
!bytes_read) return;
-    }
-}
-
-/***********************************************************************
- *          WinHttpReceiveResponse (winhttp.@)
- */
-BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
-{
-    BOOL ret = TRUE;
-    request_t *request;
-    DWORD size, query, status;
-
-    TRACE("%p, %p\n", hrequest, reserved);
-
-    if (!(request = (request_t *)grab_object( hrequest )))
-    {
-        set_last_error( ERROR_INVALID_HANDLE );
-        return FALSE;
-    }
-    if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
-    {
-        release_object( &request->hdr );
-        set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
-        return FALSE;
-    }
-
-    for (;;)
-    {
-        if (!(ret = receive_response( request, TRUE ))) break;
-
-        size = sizeof(DWORD);
-        query = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
-        if (!(ret = query_headers( request, query, NULL, &status, &size, NULL )))
break;
-
-        size = sizeof(DWORD);
-        query = WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER;
-        if (!query_headers( request, query, NULL, &request->content_length,
&size, NULL ))
-            request->content_length = ~0UL;
-
-        if (status == 200) break;
-        if (status == 301 || status == 302)
-        {
-            if (request->hdr.disable_flags & WINHTTP_DISABLE_REDIRECTS) break;
-            drain_content( request );
-            if (!(ret = handle_redirect( request ))) break;
-        }
-        ret = send_request( request, NULL, 0, NULL, 0, 0, 0 );
-    }
-
-    release_object( &request->hdr );
-    return ret;
-}
-
-/***********************************************************************
- *          WinHttpQueryDataAvailable (winhttp.@)
- */
-BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
-{
-    BOOL ret;
-    DWORD num_bytes;
-    request_t *request;
-
-    TRACE("%p, %p\n", hrequest, available);
-
-    if (!(request = (request_t *)grab_object( hrequest )))
-    {
-        set_last_error( ERROR_INVALID_HANDLE );
-        return FALSE;
-    }
-    if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
-    {
-        release_object( &request->hdr );
-        set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
-        return FALSE;
-    }
-
-    ret = netconn_query_data_available( &request->netconn, &num_bytes );
-
-    if (ret && available) *available = num_bytes;
-    release_object( &request->hdr );
-    return ret;
 }
 
 static DWORD get_chunk_size( const char *buffer )
@@ -1191,7 +1176,7 @@
     return size;
 }
 
-static BOOL read_data_chunked( request_t *request, void *buffer, DWORD size, DWORD *read,
BOOL async )
+static BOOL receive_data_chunked( request_t *request, void *buffer, DWORD size, DWORD
*read, BOOL async )
 {
     char reply[MAX_REPLY_LEN], *p = buffer;
     DWORD buflen, to_read, to_write = size;
@@ -1202,7 +1187,7 @@
     {
         if (*read == size) break;
 
-        if (request->content_length == ~0UL) /* new chunk */
+        if (request->content_length == ~0u) /* new chunk */
         {
             buflen = sizeof(reply);
             if (!netconn_get_next_line( &request->netconn, reply, &buflen ))
break;
@@ -1210,7 +1195,7 @@
             if (!(request->content_length = get_chunk_size( reply )))
             {
                 /* zero sized chunk marks end of transfer; read any trailing headers and
return */
-                receive_response( request, FALSE );
+                read_reply( request );
                 break;
             }
         }
@@ -1236,7 +1221,7 @@
         if (request->content_read == request->content_length) /* chunk complete */
         {
             request->content_read = 0;
-            request->content_length = ~0UL;
+            request->content_length = ~0u;
 
             buflen = sizeof(reply);
             if (!netconn_get_next_line( &request->netconn, reply, &buflen ))
@@ -1250,17 +1235,285 @@
     return TRUE;
 }
 
+static void finished_reading( request_t *request )
+{
+    static const WCHAR closeW[] =
{'c','l','o','s','e',0};
+
+    BOOL close = FALSE;
+    WCHAR connection[20];
+    DWORD size = sizeof(connection);
+
+    if (request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE) close = TRUE;
+    else if (query_headers( request, WINHTTP_QUERY_CONNECTION, NULL, connection,
&size, NULL ) ||
+             query_headers( request, WINHTTP_QUERY_PROXY_CONNECTION, NULL, connection,
&size, NULL ))
+    {
+        if (!strcmpiW( connection, closeW )) close = TRUE;
+    }
+    else if (!strcmpW( request->version, http1_0 )) close = TRUE;
+
+    if (close) close_connection( request );
+    request->content_length = ~0u;
+    request->content_read = 0;
+}
+
+static BOOL read_data( request_t *request, void *buffer, DWORD to_read, DWORD *read, BOOL
async )
+{
+    static const WCHAR chunked[] =
{'c','h','u','n','k','e','d',0};
+
+    BOOL ret;
+    WCHAR encoding[20];
+    DWORD num_bytes, buflen = sizeof(encoding);
+
+    if (query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, encoding,
&buflen, NULL ) &&
+        !strcmpiW( encoding, chunked ))
+    {
+        ret = receive_data_chunked( request, buffer, to_read, &num_bytes, async );
+    }
+    else
+        ret = receive_data( request, buffer, to_read, &num_bytes, async );
+
+    if (async)
+    {
+        if (ret) send_callback( &request->hdr,
WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, num_bytes );
+        else
+        {
+            WINHTTP_ASYNC_RESULT result;
+            result.dwResult = API_READ_DATA;
+            result.dwError  = get_last_error();
+            send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR,
&result, sizeof(result) );
+        }
+    }
+    if (ret)
+    {
+        if (read) *read = num_bytes;
+        if (!num_bytes) finished_reading( request );
+    }
+    return ret;
+}
+
+/* read any content returned by the server so that the connection can be reused */
+static void drain_content( request_t *request )
+{
+    DWORD bytes_read;
+    char buffer[2048];
+
+    if (!request->content_length) return;
+    for (;;)
+    {
+        if (!read_data( request, buffer, sizeof(buffer), &bytes_read, FALSE ) ||
!bytes_read) return;
+    }
+}
+
+static void record_cookies( request_t *request )
+{
+    unsigned int i;
+
+    for (i = 0; i < request->num_headers; i++)
+    {
+        header_t *set_cookie = &request->headers[i];
+        if (!strcmpiW( set_cookie->field, attr_set_cookie ) &&
!set_cookie->is_request)
+        {
+            set_cookies( request, set_cookie->value );
+        }
+    }
+}
+
+static BOOL receive_response( request_t *request, BOOL async )
+{
+    BOOL ret;
+    DWORD size, query, status;
+
+    for (;;)
+    {
+        if (!(ret = read_reply( request ))) break;
+
+        size = sizeof(DWORD);
+        query = WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER;
+        if (!(ret = query_headers( request, query, NULL, &status, &size, NULL )))
break;
+
+        size = sizeof(DWORD);
+        query = WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER;
+        if (!query_headers( request, query, NULL, &request->content_length,
&size, NULL ))
+            request->content_length = ~0u;
+
+        if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES))
record_cookies( request );
+
+        if (status == 301 || status == 302)
+        {
+            if (request->hdr.disable_flags & WINHTTP_DISABLE_REDIRECTS) break;
+
+            drain_content( request );
+            if (!(ret = handle_redirect( request ))) break;
+
+            clear_response_headers( request );
+            ret = send_request( request, NULL, 0, NULL, 0, 0, 0, FALSE ); /* recurse
synchronously */
+            continue;
+        }
+        if (status == 401) FIXME("authentication not supported\n");
+        break;
+    }
+
+    if (async)
+    {
+        if (ret) send_callback( &request->hdr,
WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NULL, 0 );
+        else
+        {
+            WINHTTP_ASYNC_RESULT result;
+            result.dwResult = API_RECEIVE_RESPONSE;
+            result.dwError  = get_last_error();
+            send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR,
&result, sizeof(result) );
+        }
+    }
+    return ret;
+}
+
+static void task_receive_response( task_header_t *task )
+{
+    receive_response_t *r = (receive_response_t *)task;
+    receive_response( r->hdr.request, TRUE );
+}
+
+/***********************************************************************
+ *          WinHttpReceiveResponse (winhttp.@)
+ */
+BOOL WINAPI WinHttpReceiveResponse( HINTERNET hrequest, LPVOID reserved )
+{
+    BOOL ret;
+    request_t *request;
+
+    TRACE("%p, %p\n", hrequest, reserved);
+
+    if (!(request = (request_t *)grab_object( hrequest )))
+    {
+        set_last_error( ERROR_INVALID_HANDLE );
+        return FALSE;
+    }
+    if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
+    {
+        release_object( &request->hdr );
+        set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
+        return FALSE;
+    }
+
+    if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+    {
+        receive_response_t *r;
+
+        if (!(r = heap_alloc( sizeof(receive_response_t) ))) return FALSE;
+        r->hdr.request = request;
+        r->hdr.proc    = task_receive_response;
+
+        addref_object( &request->hdr );
+        ret = queue_task( (task_header_t *)r );
+    }
+    else
+        ret = receive_response( request, FALSE );
+
+    release_object( &request->hdr );
+    return ret;
+}
+
+static BOOL query_data( request_t *request, LPDWORD available, BOOL async )
+{
+    BOOL ret;
+    DWORD num_bytes;
+
+    if ((ret = netconn_query_data_available( &request->netconn, &num_bytes
)))
+    {
+        if (request->content_read < request->content_length)
+        {
+            if (!num_bytes)
+            {
+                char buffer[4096];
+                size_t to_read = min( sizeof(buffer), request->content_length -
request->content_read );
+
+                ret = netconn_recv( &request->netconn, buffer, to_read, MSG_PEEK,
(int *)&num_bytes );
+                if (ret && !num_bytes) WARN("expected more data to be
available\n");
+            }
+        }
+        else if (num_bytes)
+        {
+            WARN("extra data available %u\n", num_bytes);
+            ret = FALSE;
+        }
+    }
+    TRACE("%u bytes available\n", num_bytes);
+
+    if (async)
+    {
+        if (ret) send_callback( &request->hdr,
WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, &num_bytes, sizeof(DWORD) );
+        else
+        {
+            WINHTTP_ASYNC_RESULT result;
+            result.dwResult = API_QUERY_DATA_AVAILABLE;
+            result.dwError  = get_last_error();
+            send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR,
&result, sizeof(result) );
+        }
+    }
+    if (ret && available) *available = num_bytes;
+    return ret;
+}
+
+static void task_query_data( task_header_t *task )
+{
+    query_data_t *q = (query_data_t *)task;
+    query_data( q->hdr.request, q->available, TRUE );
+}
+
+/***********************************************************************
+ *          WinHttpQueryDataAvailable (winhttp.@)
+ */
+BOOL WINAPI WinHttpQueryDataAvailable( HINTERNET hrequest, LPDWORD available )
+{
+    BOOL ret;
+    request_t *request;
+
+    TRACE("%p, %p\n", hrequest, available);
+
+    if (!(request = (request_t *)grab_object( hrequest )))
+    {
+        set_last_error( ERROR_INVALID_HANDLE );
+        return FALSE;
+    }
+    if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
+    {
+        release_object( &request->hdr );
+        set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
+        return FALSE;
+    }
+
+    if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+    {
+        query_data_t *q;
+
+        if (!(q = heap_alloc( sizeof(query_data_t) ))) return FALSE;
+        q->hdr.request = request;
+        q->hdr.proc    = task_query_data;
+        q->available   = available;
+
+        addref_object( &request->hdr );
+        ret = queue_task( (task_header_t *)q );
+    }
+    else
+        ret = query_data( request, available, FALSE );
+
+    release_object( &request->hdr );
+    return ret;
+}
+
+static void task_read_data( task_header_t *task )
+{
+    read_data_t *r = (read_data_t *)task;
+    read_data( r->hdr.request, r->buffer, r->to_read, r->read, TRUE );
+}
+
 /***********************************************************************
  *          WinHttpReadData (winhttp.@)
  */
 BOOL WINAPI WinHttpReadData( HINTERNET hrequest, LPVOID buffer, DWORD to_read, LPDWORD
read )
 {
-    static const WCHAR chunked[] =
{'c','h','u','n','k','e','d',0};
-
     BOOL ret;
     request_t *request;
-    WCHAR encoding[20];
-    DWORD num_bytes, buflen = sizeof(encoding);
 
     TRACE("%p, %p, %d, %p\n", hrequest, buffer, to_read, read);
 
@@ -1276,17 +1529,53 @@
         return FALSE;
     }
 
-    if (query_headers( request, WINHTTP_QUERY_TRANSFER_ENCODING, NULL, encoding,
&buflen, NULL ) &&
-        !strcmpiW( encoding, chunked ))
-    {
-        ret = read_data_chunked( request, buffer, to_read, &num_bytes,
request->hdr.flags & WINHTTP_FLAG_ASYNC );
+    if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+    {
+        read_data_t *r;
+
+        if (!(r = heap_alloc( sizeof(read_data_t) ))) return FALSE;
+        r->hdr.request = request;
+        r->hdr.proc    = task_read_data;
+        r->buffer      = buffer;
+        r->to_read     = to_read;
+        r->read        = read;
+
+        addref_object( &request->hdr );
+        ret = queue_task( (task_header_t *)r );
     }
     else
-        ret = read_data( request, buffer, to_read, &num_bytes, request->hdr.flags
& WINHTTP_FLAG_ASYNC );
-
-    if (ret && read) *read = num_bytes;
+        ret = read_data( request, buffer, to_read, read, FALSE );
+
     release_object( &request->hdr );
     return ret;
+}
+
+static BOOL write_data( request_t *request, LPCVOID buffer, DWORD to_write, LPDWORD
written, BOOL async )
+{
+    BOOL ret;
+    int num_bytes;
+
+    ret = netconn_send( &request->netconn, buffer, to_write, 0, &num_bytes );
+
+    if (async)
+    {
+        if (ret) send_callback( &request->hdr,
WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE, &num_bytes, sizeof(DWORD) );
+        else
+        {
+            WINHTTP_ASYNC_RESULT result;
+            result.dwResult = API_WRITE_DATA;
+            result.dwError  = get_last_error();
+            send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_ERROR,
&result, sizeof(result) );
+        }
+    }
+    if (ret && written) *written = num_bytes;
+    return ret;
+}
+
+static void task_write_data( task_header_t *task )
+{
+    write_data_t *w = (write_data_t *)task;
+    write_data( w->hdr.request, w->buffer, w->to_write, w->written, TRUE );
 }
 
 /***********************************************************************
@@ -1311,7 +1600,22 @@
         return FALSE;
     }
 
-    ret = netconn_send( &request->netconn, buffer, to_write, 0, (int *)written );
+    if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+    {
+        write_data_t *w;
+
+        if (!(w = heap_alloc( sizeof(write_data_t) ))) return FALSE;
+        w->hdr.request = request;
+        w->hdr.proc    = task_write_data;
+        w->buffer      = buffer;
+        w->to_write    = to_write;
+        w->written     = written;
+
+        addref_object( &request->hdr );
+        ret = queue_task( (task_header_t *)w );
+    }
+    else
+        ret = write_data( request, buffer, to_write, written, FALSE );
 
     release_object( &request->hdr );
     return ret;

Modified: trunk/reactos/dll/win32/winhttp/session.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/session.…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/session.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winhttp/session.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -25,6 +25,7 @@
 #include "windef.h"
 #include "winbase.h"
 #include "winhttp.h"
+#include "wincrypt.h"
 
 #include "winhttp_private.h"
 
@@ -36,11 +37,17 @@
     SetLastError( error );
 }
 
+DWORD get_last_error( void )
+{
+    /* FIXME */
+    return GetLastError();
+}
+
 void send_callback( object_header_t *hdr, DWORD status, LPVOID info, DWORD buflen )
 {
     TRACE("%p, 0x%08x, %p, %u\n", hdr, status, info, buflen);
 
-    if (hdr->notify_mask & status) hdr->callback( hdr->handle,
hdr->context, status, info, buflen );
+    if (hdr->callback && (hdr->notify_mask & status)) hdr->callback(
hdr->handle, hdr->context, status, info, buflen );
 }
 
 /***********************************************************************
@@ -58,9 +65,16 @@
 static void session_destroy( object_header_t *hdr )
 {
     session_t *session = (session_t *)hdr;
+    struct list *item, *next;
+    domain_t *domain;
 
     TRACE("%p\n", session);
 
+    LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
+    {
+        domain = LIST_ENTRY( item, domain_t, entry );
+        delete_domain( domain );
+    }
     heap_free( session->agent );
     heap_free( session->proxy_server );
     heap_free( session->proxy_bypass );
@@ -69,6 +83,30 @@
     heap_free( session );
 }
 
+static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buffer,
LPDWORD buflen )
+{
+    switch (option)
+    {
+    case WINHTTP_OPTION_REDIRECT_POLICY:
+    {
+        if (!buffer || *buflen < sizeof(DWORD))
+        {
+            *buflen = sizeof(DWORD);
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        *(DWORD *)buffer = hdr->redirect_policy;
+        *buflen = sizeof(DWORD);
+        return TRUE;
+    }
+    default:
+        FIXME("unimplemented option %u\n", option);
+        set_last_error( ERROR_INVALID_PARAMETER );
+        return FALSE;
+    }
+}
+
 static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD
buflen )
 {
     switch (option)
@@ -82,22 +120,33 @@
     }
     case WINHTTP_OPTION_REDIRECT_POLICY:
     {
-        DWORD policy = *(DWORD *)buffer;
-
+        DWORD policy;
+
+        if (buflen != sizeof(policy))
+        {
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        policy = *(DWORD *)buffer;
         TRACE("0x%x\n", policy);
         hdr->redirect_policy = policy;
         return TRUE;
     }
+    case WINHTTP_OPTION_DISABLE_FEATURE:
+        set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
+        return FALSE;
     default:
         FIXME("unimplemented option %u\n", option);
-        return TRUE;
+        set_last_error( ERROR_INVALID_PARAMETER );
+        return FALSE;
     }
 }
 
 static const object_vtbl_t session_vtbl =
 {
     session_destroy,
-    NULL,
+    session_query_option,
     session_set_option
 };
 
@@ -118,6 +167,8 @@
     session->hdr.flags = flags;
     session->hdr.refs = 1;
     session->access = access;
+    session->hdr.redirect_policy =
WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
+    list_init( &session->cookie_cache );
 
     if (agent && !(session->agent = strdupW( agent ))) goto end;
     if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
@@ -202,10 +253,10 @@
     list_add_head( &session->hdr.children, &connect->hdr.entry );
 
     if (server && !(connect->hostname = strdupW( server ))) goto end;
-    connect->hostport = port ? port : (connect->hdr.flags & WINHTTP_FLAG_SECURE
? 443 : 80);
+    connect->hostport = port;
 
     if (server && !(connect->servername = strdupW( server ))) goto end;
-    connect->serverport = port ? port : (connect->hdr.flags &
WINHTTP_FLAG_SECURE ? 443 : 80);
+    connect->serverport = port;
 
     if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
     connect->hdr.handle = hconnect;
@@ -225,7 +276,7 @@
 static void request_destroy( object_header_t *hdr )
 {
     request_t *request = (request_t *)hdr;
-    int i;
+    DWORD i;
 
     TRACE("%p\n", request);
 
@@ -251,15 +302,54 @@
     {
     case WINHTTP_OPTION_SECURITY_FLAGS:
     {
-        DWORD flags = 0;
-
+        DWORD flags;
+
+        if (!buffer || *buflen < sizeof(flags))
+        {
+            *buflen = sizeof(flags);
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        flags = 0;
         if (hdr->flags & WINHTTP_FLAG_SECURE) flags |= SECURITY_FLAG_SECURE;
         *(DWORD *)buffer = flags;
+        *buflen = sizeof(flags);
+        return TRUE;
+    }
+    case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
+    {
+        const CERT_CONTEXT *cert;
+        request_t *request = (request_t *)hdr;
+
+        if (!buffer || *buflen < sizeof(cert))
+        {
+            *buflen = sizeof(cert);
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
+        *(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
+        *buflen = sizeof(cert);
+        return TRUE;
+    }
+    case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
+    {
+        if (!buffer || *buflen < sizeof(DWORD))
+        {
+            *buflen = sizeof(DWORD);
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        *(DWORD *)buffer = 128; /* FIXME */
         *buflen = sizeof(DWORD);
         return TRUE;
     }
     default:
         FIXME("unimplemented option %u\n", option);
+        set_last_error( ERROR_INVALID_PARAMETER );
         return FALSE;
     }
 }
@@ -277,30 +367,52 @@
     }
     case WINHTTP_OPTION_DISABLE_FEATURE:
     {
-        DWORD disable = *(DWORD *)buffer;
-
+        DWORD disable;
+
+        if (buflen != sizeof(DWORD))
+        {
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        disable = *(DWORD *)buffer;
         TRACE("0x%x\n", disable);
-        hdr->disable_flags &= disable;
+        hdr->disable_flags |= disable;
         return TRUE;
     }
     case WINHTTP_OPTION_AUTOLOGON_POLICY:
     {
-        DWORD policy = *(DWORD *)buffer;
-
+        DWORD policy;
+
+        if (buflen != sizeof(DWORD))
+        {
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        policy = *(DWORD *)buffer;
         TRACE("0x%x\n", policy);
         hdr->logon_policy = policy;
         return TRUE;
     }
     case WINHTTP_OPTION_REDIRECT_POLICY:
     {
-        DWORD policy = *(DWORD *)buffer;
-
+        DWORD policy;
+
+        if (buflen != sizeof(DWORD))
+        {
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
+        policy = *(DWORD *)buffer;
         TRACE("0x%x\n", policy);
         hdr->redirect_policy = policy;
         return TRUE;
     }
     default:
         FIXME("unimplemented option %u\n", option);
+        set_last_error( ERROR_INVALID_PARAMETER );
         return TRUE;
     }
 }
@@ -355,9 +467,26 @@
 
     if (!netconn_init( &request->netconn, request->hdr.flags &
WINHTTP_FLAG_SECURE )) goto end;
 
-    if (verb && !(request->verb = strdupW( verb ))) goto end;
-    if (object && !(request->path = strdupW( object ))) goto end;
-    if (version && !(request->version = strdupW( version ))) goto end;
+    if (!verb || !verb[0]) verb = getW;
+    if (!(request->verb = strdupW( verb ))) goto end;
+
+    if (object)
+    {
+        WCHAR *path, *p;
+        unsigned int len;
+
+        len = strlenW( object ) + 1;
+        if (object[0] != '/') len++;
+        if (!(p = path = heap_alloc( len * sizeof(WCHAR) ))) goto end;
+
+        if (object[0] != '/') *p++ = '/';
+        strcpyW( p, object );
+        request->path = path;
+    }
+    else if (!(request->path = strdupW( slashW ))) goto end;
+
+    if (!version || !version[0]) version = http1_1;
+    if (!(request->version = strdupW( version ))) goto end;
 
     if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
     request->hdr.handle = hrequest;
@@ -394,19 +523,36 @@
 {
     BOOL ret = FALSE;
 
+    if (!buflen)
+    {
+        set_last_error( ERROR_INVALID_PARAMETER );
+        return FALSE;
+    }
+
     switch (option)
     {
     case WINHTTP_OPTION_CONTEXT_VALUE:
     {
+        if (!buffer || *buflen < sizeof(DWORD_PTR))
+        {
+            *buflen = sizeof(DWORD_PTR);
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
         *(DWORD_PTR *)buffer = hdr->context;
         *buflen = sizeof(DWORD_PTR);
         return TRUE;
     }
     default:
-    {
         if (hdr->vtbl->query_option) ret = hdr->vtbl->query_option( hdr,
option, buffer, buflen );
-        else FIXME("unimplemented option %u\n", option);
-    }
+        else
+        {
+            FIXME("unimplemented option %u\n", option);
+            set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
+            return FALSE;
+        }
+        break;
     }
     return ret;
 }
@@ -437,18 +583,34 @@
 {
     BOOL ret = TRUE;
 
+    if (!buffer)
+    {
+        set_last_error( ERROR_INVALID_PARAMETER );
+        return FALSE;
+    }
+
     switch (option)
     {
     case WINHTTP_OPTION_CONTEXT_VALUE:
     {
+        if (buflen != sizeof(DWORD_PTR))
+        {
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+
         hdr->context = *(DWORD_PTR *)buffer;
         return TRUE;
     }
     default:
-    {
         if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option,
buffer, buflen );
-        else FIXME("unimplemented option %u\n", option);
-    }
+        else
+        {
+            FIXME("unimplemented option %u\n", option);
+            set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
+            return FALSE;
+        }
+        break;
     }
     return ret;
 }

Added: trunk/reactos/dll/win32/winhttp/url.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/url.c?re…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/url.c (added)
+++ trunk/reactos/dll/win32/winhttp/url.c [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -1,0 +1,484 @@
+/*
+ * Copyright 2008 Hans Leidekker for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "config.h"
+#include <stdarg.h>
+
+#include "wine/debug.h"
+
+#include "windef.h"
+#include "winbase.h"
+#include "winreg.h"
+#include "winhttp.h"
+#include "shlwapi.h"
+
+#include "winhttp_private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
+
+static const WCHAR scheme_http[] = {'h','t','t','p',0};
+static const WCHAR scheme_https[] =
{'h','t','t','p','s',0};
+
+static BOOL set_component( WCHAR **str, DWORD *str_len, WCHAR *value, DWORD len, DWORD
flags )
+{
+    if (!*str)
+    {
+        if (len && (flags & ICU_DECODE))
+        {
+            set_last_error( ERROR_INVALID_PARAMETER );
+            return FALSE;
+        }
+        *str = value;
+        *str_len = len;
+    }
+    else
+    {
+        if (len > (*str_len) - 1)
+        {
+            *str_len = len + 1;
+            set_last_error( ERROR_INSUFFICIENT_BUFFER );
+            return FALSE;
+        }
+        memcpy( *str, value, len * sizeof(WCHAR) );
+        (*str)[len] = 0;
+        *str_len = len;
+    }
+    return TRUE;
+}
+
+static BOOL decode_url( LPCWSTR url, LPWSTR buffer, LPDWORD buflen )
+{
+    HRESULT hr = UrlCanonicalizeW( url, buffer, buflen, URL_WININET_COMPATIBILITY |
URL_UNESCAPE );
+    if (hr == E_POINTER) set_last_error( ERROR_INSUFFICIENT_BUFFER );
+    if (hr == E_INVALIDARG) set_last_error( ERROR_INVALID_PARAMETER );
+    return (SUCCEEDED(hr)) ? TRUE : FALSE;
+}
+
+/***********************************************************************
+ *          WinHttpCrackUrl (winhttp.@)
+ */
+BOOL WINAPI WinHttpCrackUrl( LPCWSTR url, DWORD len, DWORD flags, LPURL_COMPONENTSW uc )
+{
+    BOOL ret = FALSE;
+    WCHAR *p, *q, *r;
+    WCHAR *url_decoded = NULL;
+
+    TRACE("%s, %d, %x, %p\n", debugstr_w(url), len, flags, uc);
+
+    if (flags & ICU_ESCAPE) FIXME("flag ICU_ESCAPE not supported\n");
+
+    if (!url || !uc || uc->dwStructSize != sizeof(URL_COMPONENTS))
+    {
+        set_last_error( ERROR_INVALID_PARAMETER );
+        return FALSE;
+    }
+    if (!len) len = strlenW( url );
+
+    if (flags & ICU_DECODE)
+    {
+        WCHAR *url_tmp;
+        DWORD url_len = len + 1;
+
+        if (!(url_tmp = HeapAlloc( GetProcessHeap(), 0, url_len * sizeof(WCHAR) )))
+        {
+            set_last_error( ERROR_OUTOFMEMORY );
+            return FALSE;
+        }
+        memcpy( url_tmp, url, len * sizeof(WCHAR) );
+        url_tmp[len] = 0;
+        if (!(url_decoded = HeapAlloc( GetProcessHeap(), 0, url_len * sizeof(WCHAR) )))
+        {
+            HeapFree( GetProcessHeap(), 0, url_tmp );
+            set_last_error( ERROR_OUTOFMEMORY );
+            return FALSE;
+        }
+        if (decode_url( url_tmp, url_decoded, &url_len ))
+        {
+            len = url_len;
+            url = url_decoded;
+        }
+        HeapFree( GetProcessHeap(), 0, url_tmp );
+    }
+    if (!(p = strchrW( url, ':' )))
+    {
+        set_last_error( ERROR_WINHTTP_UNRECOGNIZED_SCHEME );
+        return FALSE;
+    }
+    if (p - url == 4 && !strncmpiW( url, scheme_http, 4 )) uc->nScheme =
INTERNET_SCHEME_HTTP;
+    else if (p - url == 5 && !strncmpiW( url, scheme_https, 5 )) uc->nScheme =
INTERNET_SCHEME_HTTPS;
+    else
+    {
+        set_last_error( ERROR_WINHTTP_UNRECOGNIZED_SCHEME );
+        goto exit;
+    }
+    if (!(set_component( &uc->lpszScheme, &uc->dwSchemeLength, (WCHAR
*)url, p - url, flags ))) goto exit;
+
+    p++; /* skip ':' */
+    if (!p[0] || p[0] != '/' || p[1] != '/') goto exit;
+    p += 2;
+
+    if (!p[0]) goto exit;
+    if ((q = memchrW( p, '@', len - (p - url) )))
+    {
+        if ((r = memchrW( p, ':', q - p )))
+        {
+            if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength,
p, r - p, flags ))) goto exit;
+            r++;
+            if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength,
r, q - r, flags ))) goto exit;
+        }
+        else
+        {
+            if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength,
p, q - p, flags ))) goto exit;
+            if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength,
NULL, 0, flags ))) goto exit;
+        }
+        p = q + 1;
+    }
+    else
+    {
+        if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength,
NULL, 0, flags ))) goto exit;
+        if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength,
NULL, 0, flags ))) goto exit;
+    }
+    if ((q = memchrW( p, '/', len - (p - url) )))
+    {
+        if ((r = memchrW( p, ':', q - p )))
+        {
+            if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength,
p, r - p, flags ))) goto exit;
+            r++;
+            uc->nPort = atoiW( r );
+        }
+        else
+        {
+            if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength,
p, q - p, flags ))) goto exit;
+            if (uc->nScheme == INTERNET_SCHEME_HTTP) uc->nPort =
INTERNET_DEFAULT_HTTP_PORT;
+            if (uc->nScheme == INTERNET_SCHEME_HTTPS) uc->nPort =
INTERNET_DEFAULT_HTTPS_PORT;
+        }
+
+        if ((r = memchrW( q, '?', len - (q - url) )))
+        {
+            if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, q,
r - q, flags ))) goto exit;
+            if (!(set_component( &uc->lpszExtraInfo,
&uc->dwExtraInfoLength, r, len - (r - url), flags ))) goto exit;
+        }
+        else
+        {
+            if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, q,
len - (q - url), flags ))) goto exit;
+            if (!(set_component( &uc->lpszExtraInfo,
&uc->dwExtraInfoLength, (WCHAR *)url + len, 0, flags ))) goto exit;
+        }
+    }
+    else
+    {
+        if ((r = memchrW( p, ':', len - (p - url) )))
+        {
+            if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength,
p, r - p, flags ))) goto exit;
+            r++;
+            uc->nPort = atoiW( r );
+        }
+        else
+        {
+            if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength,
p, len - (p - url), flags ))) goto exit;
+            if (uc->nScheme == INTERNET_SCHEME_HTTP) uc->nPort =
INTERNET_DEFAULT_HTTP_PORT;
+            if (uc->nScheme == INTERNET_SCHEME_HTTPS) uc->nPort =
INTERNET_DEFAULT_HTTPS_PORT;
+        }
+        if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, (WCHAR
*)url + len, 0, flags ))) goto exit;
+        if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength,
(WCHAR *)url + len, 0, flags ))) goto exit;
+    }
+
+    ret = TRUE;
+
+    TRACE("scheme(%s) host(%s) port(%d) path(%s) extra(%s)\n",
+          debugstr_wn( uc->lpszScheme, uc->dwSchemeLength ),
+          debugstr_wn( uc->lpszHostName, uc->dwHostNameLength ),
+          uc->nPort,
+          debugstr_wn( uc->lpszUrlPath, uc->dwUrlPathLength ),
+          debugstr_wn( uc->lpszExtraInfo, uc->dwExtraInfoLength ));
+
+exit:
+    HeapFree( GetProcessHeap(), 0, url_decoded );
+    return ret;
+}
+
+static INTERNET_SCHEME get_scheme( const WCHAR *scheme, DWORD len )
+{
+    if (!strncmpW( scheme, scheme_http, len )) return INTERNET_SCHEME_HTTP;
+    if (!strncmpW( scheme, scheme_https, len )) return INTERNET_SCHEME_HTTPS;
+    return 0;
+}
+
+static const WCHAR *get_scheme_string( INTERNET_SCHEME scheme )
+{
+    if (scheme == INTERNET_SCHEME_HTTP) return scheme_http;
+    if (scheme == INTERNET_SCHEME_HTTPS) return scheme_https;
+    return NULL;
+}
+
+static BOOL uses_default_port( INTERNET_SCHEME scheme, INTERNET_PORT port )
+{
+    if ((scheme == INTERNET_SCHEME_HTTP) && (port == INTERNET_DEFAULT_HTTP_PORT))
return TRUE;
+    if ((scheme == INTERNET_SCHEME_HTTPS) && (port ==
INTERNET_DEFAULT_HTTPS_PORT)) return TRUE;
+    return FALSE;
+}
+
+static BOOL need_escape( WCHAR c )
+{
+    if (isalnumW( c )) return FALSE;
+
+    if (c <= 31 || c >= 127) return TRUE;
+    else
+    {
+        switch (c)
+        {
+        case ' ':
+        case '"':
+        case '#':
+        case '%':
+        case '<':
+        case '>':
+        case ']':
+        case '\\':
+        case '[':
+        case '^':
+        case '`':
+        case '{':
+        case '|':
+        case '}':
+        case '~':
+            return TRUE;
+        default:
+            return FALSE;
+        }
+    }
+}
+
+static DWORD copy_escape( WCHAR *dst, const WCHAR *src, DWORD len )
+{
+    static const WCHAR hex[] =
{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+    DWORD ret = len;
+    unsigned int i;
+    WCHAR *p = dst;
+
+    for (i = 0; i < len; i++, p++)
+    {
+        if (need_escape( src[i] ))
+        {
+            p[0] = '%';
+            p[1] = hex[(src[i] >> 4) & 0xf];
+            p[2] = hex[src[i] & 0xf];
+            ret += 2;
+            p += 2;
+        }
+        else *p = src[i];
+    }
+    dst[ret] = 0;
+    return ret;
+}
+
+static DWORD comp_length( DWORD len, DWORD flags, WCHAR *comp )
+{
+    DWORD ret;
+    unsigned int i;
+
+    ret = len ? len : strlenW( comp );
+    if (!(flags & ICU_ESCAPE)) return ret;
+    for (i = 0; i < len; i++) if (need_escape( comp[i] )) ret += 2;
+    return ret;
+}
+
+static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len )
+{
+    static const WCHAR formatW[] = {'%','d',0};
+    INTERNET_SCHEME scheme;
+
+    *len = 0;
+    if (uc->lpszScheme)
+    {
+        DWORD scheme_len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme );
+        *len += scheme_len;
+        scheme = get_scheme( uc->lpszScheme, scheme_len );
+    }
+    else
+    {
+        scheme = uc->nScheme;
+        if (!scheme) scheme = INTERNET_SCHEME_HTTP;
+        *len += strlenW( get_scheme_string( scheme ) );
+    }
+    *len += 1; /* ':' */
+    if (uc->lpszHostName) *len += 2; /* "//" */
+
+    if (uc->lpszUserName)
+    {
+        *len += comp_length( uc->dwUserNameLength, 0, uc->lpszUserName );
+        *len += 1; /* "@" */
+    }
+    else
+    {
+        if (uc->lpszPassword)
+        {
+            set_last_error( ERROR_INVALID_PARAMETER );
+            return FALSE;
+        }
+    }
+    if (uc->lpszPassword)
+    {
+        *len += 1; /* ":" */
+        *len += comp_length( uc->dwPasswordLength, 0, uc->lpszPassword );
+    }
+    if (uc->lpszHostName)
+    {
+        *len += comp_length( uc->dwHostNameLength, 0, uc->lpszHostName );
+
+        if (!uses_default_port( scheme, uc->nPort ))
+        {
+            WCHAR port[sizeof("65535")];
+
+            sprintfW( port, formatW, uc->nPort );
+            *len += strlenW( port );
+            *len += 1; /* ":" */
+        }
+        if (uc->lpszUrlPath && *uc->lpszUrlPath != '/') *len += 1;
/* '/' */
+    }
+    if (uc->lpszUrlPath) *len += comp_length( uc->dwUrlPathLength, flags,
uc->lpszUrlPath );
+    if (uc->lpszExtraInfo) *len += comp_length( uc->dwExtraInfoLength, flags,
uc->lpszExtraInfo );
+    return TRUE;
+}
+
+/***********************************************************************
+ *          WinHttpCreateUrl (winhttp.@)
+ */
+BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDWORD
required )
+{
+    static const WCHAR formatW[] = {'%','d',0};
+    static const WCHAR twoslashW[] = {'/','/'};
+
+    DWORD len;
+    INTERNET_SCHEME scheme;
+
+    TRACE("%p, 0x%08x, %p, %p\n", uc, flags, url, required);
+
+    if (!uc || uc->dwStructSize != sizeof(URL_COMPONENTS) || !required)
+    {
+        set_last_error( ERROR_INVALID_PARAMETER );
+        return FALSE;
+    }
+
+    if (!calc_length( uc, flags, &len )) return FALSE;
+
+    if (!url || *required < len)
+    {
+        *required = len + 1;
+        set_last_error( ERROR_INSUFFICIENT_BUFFER );
+        return FALSE;
+    }
+
+    url[0] = 0;
+    *required = len;
+    if (uc->lpszScheme)
+    {
+        len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme );
+        memcpy( url, uc->lpszScheme, len * sizeof(WCHAR) );
+        url += len;
+
+        scheme = get_scheme( uc->lpszScheme, len );
+    }
+    else
+    {
+        const WCHAR *schemeW;
+        scheme = uc->nScheme;
+
+        if (!scheme) scheme = INTERNET_SCHEME_HTTP;
+
+        schemeW = get_scheme_string( scheme );
+        len = strlenW( schemeW );
+        memcpy( url, schemeW, len * sizeof(WCHAR) );
+        url += len;
+    }
+
+    /* all schemes are followed by at least a colon */
+    *url = ':';
+    url++;
+
+    if (uc->lpszHostName)
+    {
+        memcpy( url, twoslashW, sizeof(twoslashW) );
+        url += sizeof(twoslashW) / sizeof(twoslashW[0]);
+    }
+    if (uc->lpszUserName)
+    {
+        len = comp_length( uc->dwUserNameLength, 0, uc->lpszUserName );
+        memcpy( url, uc->lpszUserName, len * sizeof(WCHAR) );
+        url += len;
+
+        if (uc->lpszPassword)
+        {
+            *url = ':';
+            url++;
+
+            len = comp_length( uc->dwPasswordLength, 0, uc->lpszPassword );
+            memcpy( url, uc->lpszPassword, len * sizeof(WCHAR) );
+            url += len;
+        }
+        *url = '@';
+        url++;
+    }
+    if (uc->lpszHostName)
+    {
+        len = comp_length( uc->dwHostNameLength, 0, uc->lpszHostName );
+        memcpy( url, uc->lpszHostName, len * sizeof(WCHAR) );
+        url += len;
+
+        if (!uses_default_port( scheme, uc->nPort ))
+        {
+            WCHAR port[sizeof("65535")];
+
+            sprintfW( port, formatW, uc->nPort );
+            *url = ':';
+            url++;
+
+            len = strlenW( port );
+            memcpy( url, port, len * sizeof(WCHAR) );
+            url += len;
+        }
+
+        /* add slash between hostname and path if necessary */
+        if (uc->lpszUrlPath && *uc->lpszUrlPath != '/')
+        {
+            *url = '/';
+            url++;
+        }
+    }
+    if (uc->lpszUrlPath)
+    {
+        len = comp_length( uc->dwUrlPathLength, 0, uc->lpszUrlPath );
+        if (flags & ICU_ESCAPE) url += copy_escape( url, uc->lpszUrlPath, len );
+        else
+        {
+            memcpy( url, uc->lpszUrlPath, len * sizeof(WCHAR) );
+            url += len;
+        }
+    }
+    if (uc->lpszExtraInfo)
+    {
+        len = comp_length( uc->dwExtraInfoLength, 0, uc->lpszExtraInfo );
+        if (flags & ICU_ESCAPE) url += copy_escape( url, uc->lpszExtraInfo, len
);
+        else
+        {
+            memcpy( url, uc->lpszExtraInfo, len * sizeof(WCHAR) );
+            url += len;
+        }
+    }
+    *url = 0;
+    return TRUE;
+}

Propchange: trunk/reactos/dll/win32/winhttp/url.c
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: trunk/reactos/dll/win32/winhttp/winhttp.rbuild
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/winhttp.…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/winhttp.rbuild [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winhttp/winhttp.rbuild [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -7,12 +7,15 @@
 	<include base="winhttp">.</include>
 	<include base="ReactOS">include/reactos/wine</include>
 	<define name="__WINESRC__" />
+	<file>cookie.c</file>
 	<file>handle.c</file>
 	<file>main.c</file>
 	<file>net.c</file>
 	<file>request.c</file>
 	<file>session.c</file>
+	<file>url.c</file>
 	<library>wine</library>
+	<library>shlwapi</library>
 	<library>wininet</library>
 	<library>ws2_32</library>
 	<library>kernel32</library>

Modified: trunk/reactos/dll/win32/winhttp/winhttp_private.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/winhttp/winhttp_…
==============================================================================
--- trunk/reactos/dll/win32/winhttp/winhttp_private.h [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/winhttp/winhttp_private.h [iso-8859-1] Sun Jun  7 16:32:05
2009
@@ -26,6 +26,7 @@
 #include "wine/list.h"
 #include "wine/unicode.h"
 
+#include <sys/types.h>
 #ifdef HAVE_NETINET_IN_H
 # include <netinet/in.h>
 #endif
@@ -33,14 +34,17 @@
 # include <netdb.h>
 #endif
 #if defined(__MINGW32__) || defined (_MSC_VER)
-#  include "ws2tcpip.h"
-#  ifndef MSG_WAITALL
-#  define MSG_WAITALL 0
-#  endif
+# include <ws2tcpip.h>
 #else
-#  define closesocket close
-#  define ioctlsocket ioctl
-#endif /* __MINGW32__ */
+# define closesocket close
+# define ioctlsocket ioctl
+#endif
+
+static const WCHAR getW[]    = {'G','E','T',0};
+static const WCHAR postW[]   = {'P','O','S','T',0};
+static const WCHAR slashW[]  = {'/',0};
+static const WCHAR http1_0[] =
{'H','T','T','P','/','1','.','0',0};
+static const WCHAR http1_1[] =
{'H','T','T','P','/','1','.','1',0};
 
 typedef struct _object_header_t object_header_t;
 
@@ -71,6 +75,21 @@
 
 typedef struct
 {
+    struct list entry;
+    WCHAR *name;
+    struct list cookies;
+} domain_t;
+
+typedef struct
+{
+    struct list entry;
+    WCHAR *name;
+    WCHAR *value;
+    WCHAR *path;
+} cookie_t;
+
+typedef struct
+{
     object_header_t hdr;
     LPWSTR agent;
     DWORD access;
@@ -78,6 +97,7 @@
     LPWSTR proxy_bypass;
     LPWSTR proxy_username;
     LPWSTR proxy_password;
+    struct list cookie_cache;
 } session_t;
 
 typedef struct
@@ -97,7 +117,6 @@
 {
     int socket;
     BOOL secure; /* SSL active on connection? */
-    void *ssl_ctx;
     void *ssl_conn;
     char *peek_msg;
     char *peek_msg_mem;
@@ -127,6 +146,52 @@
     DWORD num_headers;
 } request_t;
 
+typedef struct _task_header_t task_header_t;
+
+struct _task_header_t
+{
+    request_t *request;
+    void (*proc)( task_header_t * );
+};
+
+typedef struct
+{
+    task_header_t hdr;
+    LPWSTR headers;
+    DWORD headers_len;
+    LPVOID optional;
+    DWORD optional_len;
+    DWORD total_len;
+    DWORD_PTR context;
+} send_request_t;
+
+typedef struct
+{
+    task_header_t hdr;
+} receive_response_t;
+
+typedef struct
+{
+    task_header_t hdr;
+    LPDWORD available;
+} query_data_t;
+
+typedef struct
+{
+    task_header_t hdr;
+    LPVOID buffer;
+    DWORD to_read;
+    LPDWORD read;
+} read_data_t;
+
+typedef struct
+{
+    task_header_t hdr;
+    LPCVOID buffer;
+    DWORD to_write;
+    LPDWORD written;
+} write_data_t;
+
 object_header_t *addref_object( object_header_t * );
 object_header_t *grab_object( HINTERNET );
 void release_object( object_header_t * );
@@ -134,6 +199,7 @@
 BOOL free_handle( HINTERNET );
 
 void set_last_error( DWORD );
+DWORD get_last_error( void );
 void send_callback( object_header_t *, DWORD, LPVOID, DWORD );
 void close_connection( request_t * );
 
@@ -148,6 +214,12 @@
 BOOL netconn_resolve( WCHAR *, INTERNET_PORT, struct sockaddr_in * );
 BOOL netconn_secure_connect( netconn_t * );
 BOOL netconn_send( netconn_t *, const void *, size_t, int, int * );
+const void *netconn_get_certificate( netconn_t * );
+
+BOOL set_cookies( request_t *, const WCHAR * );
+BOOL add_cookie_headers( request_t * );
+BOOL add_request_headers( request_t *, LPCWSTR, DWORD, DWORD );
+void delete_domain( domain_t * );
 
 static inline void *heap_alloc( SIZE_T size )
 {

Modified: trunk/reactos/include/psdk/winhttp.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/include/psdk/winhttp.h?rev…
==============================================================================
--- trunk/reactos/include/psdk/winhttp.h [iso-8859-1] (original)
+++ trunk/reactos/include/psdk/winhttp.h [iso-8859-1] Sun Jun  7 16:32:05 2009
@@ -35,6 +35,8 @@
 #define INTERNET_SCHEME_HTTP            1
 #define INTERNET_SCHEME_HTTPS           2
 typedef int INTERNET_SCHEME, *LPINTERNET_SCHEME;
+
+#define ICU_ESCAPE  0x80000000
 
 /* flags for WinHttpOpen */
 #define WINHTTP_FLAG_ASYNC                  0x10000000