* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#include "winhttp_private.h"
+#define COBJMACROS
+#include "config.h"
+#include "wine/port.h"
+#include <stdarg.h>
+#include <assert.h>
#ifdef HAVE_ARPA_INET_H
# include <arpa/inet.h>
#endif
-#include <assert.h>
-#include <winuser.h>
-#include <httprequest.h>
-#include <httprequestid.h>
+#include "windef.h"
+#include "winbase.h"
+#include "ole2.h"
+#include "initguid.h"
+#include "httprequest.h"
+#include "httprequestid.h"
+#include "schannel.h"
+#include "winhttp.h"
+
+#include "winhttp_private.h"
+
+#include "wine/debug.h"
+WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
+
+#ifdef __REACTOS__
#include "inet_ntop.c"
+#endif
+
+#define DEFAULT_KEEP_ALIVE_TIMEOUT 30000
static const WCHAR attr_accept[] = {'A','c','c','e','p','t',0};
static const WCHAR attr_accept_charset[] = {'A','c','c','e','p','t','-','C','h','a','r','s','e','t', 0};
static BOOL insert_header( request_t *request, header_t *header )
{
- DWORD count;
+ DWORD count = request->num_headers + 1;
header_t *hdrs;
- count = request->num_headers + 1;
- if (count > 1)
+ if (request->headers)
hdrs = heap_realloc_zero( request->headers, sizeof(header_t) * count );
else
- hdrs = heap_alloc_zero( sizeof(header_t) * count );
-
- if (hdrs)
- {
- request->headers = hdrs;
- request->headers[count - 1].field = strdupW( header->field );
- request->headers[count - 1].value = strdupW( header->value );
- request->headers[count - 1].is_request = header->is_request;
- request->num_headers++;
- return TRUE;
- }
- return FALSE;
+ hdrs = heap_alloc_zero( sizeof(header_t) );
+ if (!hdrs) return FALSE;
+
+ request->headers = hdrs;
+ request->headers[count - 1].field = strdupW( header->field );
+ request->headers[count - 1].value = strdupW( header->value );
+ request->headers[count - 1].is_request = header->is_request;
+ request->num_headers = count;
+ return TRUE;
}
static BOOL delete_header( request_t *request, DWORD index )
return TRUE;
}
-static BOOL process_header( request_t *request, LPCWSTR field, LPCWSTR value, DWORD flags, BOOL request_only )
+BOOL process_header( request_t *request, LPCWSTR field, LPCWSTR value, DWORD flags, BOOL request_only )
{
int index;
header_t hdr;
BOOL ret;
request_t *request;
- TRACE("%p, %s, 0x%x, 0x%08x\n", hrequest, debugstr_w(headers), len, flags);
+ TRACE("%p, %s, %u, 0x%08x\n", hrequest, debugstr_wn(headers, len), len, flags);
if (!headers || !len)
{
static const WCHAR http[] = { 'h','t','t','p',0 };
static const WCHAR https[] = { 'h','t','t','p','s',0 };
static const WCHAR fmt[] = { '%','s',':','/','/','%','s',0 };
- LPCWSTR scheme = request->netconn.secure ? https : http;
+ LPCWSTR scheme = (request->netconn ? request->netconn->secure : (request->hdr.flags & WINHTTP_FLAG_SECURE)) ? https : http;
int len;
len = strlenW( scheme ) + strlenW( request->connect->hostname );
return ret;
}
-static LPWSTR concatenate_string_list( LPCWSTR *list, int len )
-{
- LPCWSTR *t;
- LPWSTR str;
-
- for( t = list; *t ; t++ )
- len += strlenW( *t );
- len++;
-
- str = heap_alloc( len * sizeof(WCHAR) );
- if (!str) return NULL;
- *str = 0;
+#undef ARRAYSIZE
+#define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0]))
- for( t = list; *t ; t++ )
- strcatW( str, *t );
+static const WCHAR basicW[] = {'B','a','s','i','c',0};
+static const WCHAR ntlmW[] = {'N','T','L','M',0};
+static const WCHAR passportW[] = {'P','a','s','s','p','o','r','t',0};
+static const WCHAR digestW[] = {'D','i','g','e','s','t',0};
+static const WCHAR negotiateW[] = {'N','e','g','o','t','i','a','t','e',0};
- return str;
+static const struct
+{
+ const WCHAR *str;
+ unsigned int len;
+ DWORD scheme;
}
+auth_schemes[] =
+{
+ { basicW, ARRAYSIZE(basicW) - 1, WINHTTP_AUTH_SCHEME_BASIC },
+ { ntlmW, ARRAYSIZE(ntlmW) - 1, WINHTTP_AUTH_SCHEME_NTLM },
+ { passportW, ARRAYSIZE(passportW) - 1, WINHTTP_AUTH_SCHEME_PASSPORT },
+ { digestW, ARRAYSIZE(digestW) - 1, WINHTTP_AUTH_SCHEME_DIGEST },
+ { negotiateW, ARRAYSIZE(negotiateW) - 1, WINHTTP_AUTH_SCHEME_NEGOTIATE }
+};
+static const unsigned int num_auth_schemes = sizeof(auth_schemes)/sizeof(auth_schemes[0]);
-static LPWSTR build_header_request_string( request_t *request, LPCWSTR verb,
- LPCWSTR path, LPCWSTR version )
+static enum auth_scheme scheme_from_flag( DWORD flag )
{
- static const WCHAR crlf[] = {'\r','\n',0};
- static const WCHAR space[] = { ' ',0 };
- static const WCHAR colon[] = { ':',' ',0 };
- static const WCHAR twocrlf[] = {'\r','\n','\r','\n', 0};
- LPWSTR requestString;
- DWORD len, n;
- LPCWSTR *req;
- UINT i;
- LPWSTR p;
+ int i;
- /* allocate space for an array of all the string pointers to be added */
- len = (request->num_headers) * 4 + 10;
- req = heap_alloc( len * sizeof(LPCWSTR) );
- if (!req) return NULL;
+ for (i = 0; i < num_auth_schemes; i++) if (flag == auth_schemes[i].scheme) return i;
+ return SCHEME_INVALID;
+}
- /* add the verb, path and HTTP version string */
- n = 0;
- req[n++] = verb;
- req[n++] = space;
- req[n++] = path;
- req[n++] = space;
- req[n++] = version;
+static DWORD auth_scheme_from_header( WCHAR *header )
+{
+ unsigned int i;
- /* Append custom request headers */
- for (i = 0; i < request->num_headers; i++)
+ for (i = 0; i < num_auth_schemes; i++)
{
- if (request->headers[i].is_request)
- {
- req[n++] = crlf;
- req[n++] = request->headers[i].field;
- req[n++] = colon;
- req[n++] = request->headers[i].value;
-
- TRACE("Adding custom header %s (%s)\n",
- debugstr_w(request->headers[i].field),
- debugstr_w(request->headers[i].value));
- }
+ if (!strncmpiW( header, auth_schemes[i].str, auth_schemes[i].len ) &&
+ (header[auth_schemes[i].len] == ' ' || !header[auth_schemes[i].len])) return auth_schemes[i].scheme;
}
-
- if( n >= len )
- ERR("oops. buffer overrun\n");
-
- req[n] = NULL;
- requestString = concatenate_string_list( req, 4 );
- heap_free( req );
- if (!requestString) return NULL;
-
- /*
- * Set (header) termination string for request
- * Make sure there are exactly two new lines at the end of the request
- */
- p = &requestString[strlenW(requestString)-1];
- while ( (*p == '\n') || (*p == '\r') )
- p--;
- strcpyW( p+1, twocrlf );
-
- return requestString;
+ return 0;
}
-static BOOL read_reply( request_t *request );
-
-static BOOL secure_proxy_connect( request_t *request )
+static BOOL query_auth_schemes( request_t *request, DWORD level, LPDWORD supported, LPDWORD first )
{
- static const WCHAR verbConnect[] = {'C','O','N','N','E','C','T',0};
- static const WCHAR fmt[] = {'%','s',':','%','u',0};
+ DWORD index = 0, supported_schemes = 0, first_scheme = 0;
BOOL ret = FALSE;
- LPWSTR path;
- connect_t *connect = request->connect;
- path = heap_alloc( (strlenW( connect->hostname ) + 13) * sizeof(WCHAR) );
- if (path)
+ for (;;)
{
- LPWSTR requestString;
-
- sprintfW( path, fmt, connect->hostname, connect->hostport );
- requestString = build_header_request_string( request, verbConnect,
- path, http1_1 );
- heap_free( path );
- if (requestString)
- {
- LPSTR req_ascii = strdupWA( requestString );
+ WCHAR *buffer;
+ DWORD size, scheme;
- heap_free( requestString );
- if (req_ascii)
- {
- int len = strlen( req_ascii ), bytes_sent;
+ size = 0;
+ query_headers( request, level, NULL, NULL, &size, &index );
+ if (get_last_error() != ERROR_INSUFFICIENT_BUFFER) break;
- ret = netconn_send( &request->netconn, req_ascii, len, &bytes_sent );
- heap_free( req_ascii );
- if (ret)
- ret = read_reply( request );
- }
+ index--;
+ if (!(buffer = heap_alloc( size ))) return FALSE;
+ if (!query_headers( request, level, NULL, buffer, &size, &index ))
+ {
+ heap_free( buffer );
+ return FALSE;
}
- }
- return ret;
-}
+ scheme = auth_scheme_from_header( buffer );
+ heap_free( buffer );
+ if (!scheme) continue;
-#ifndef INET6_ADDRSTRLEN
-#define INET6_ADDRSTRLEN 46
-#endif
+ if (!first_scheme) first_scheme = scheme;
+ supported_schemes |= scheme;
-static WCHAR *addr_to_str( struct sockaddr *addr )
-{
- char buf[INET6_ADDRSTRLEN];
- void *src;
+ ret = TRUE;
+ }
- switch (addr->sa_family)
+ if (ret)
{
- case AF_INET:
- src = &((struct sockaddr_in *)addr)->sin_addr;
- break;
- case AF_INET6:
- src = &((struct sockaddr_in6 *)addr)->sin6_addr;
- break;
- default:
- WARN("unsupported address family %d\n", addr->sa_family);
- return NULL;
+ *supported = supported_schemes;
+ *first = first_scheme;
}
- if (!inet_ntop( addr->sa_family, src, buf, sizeof(buf) )) return NULL;
- return strdupAW( buf );
+ return ret;
}
-static BOOL open_connection( request_t *request )
+/***********************************************************************
+ * WinHttpQueryAuthSchemes (winhttp.@)
+ */
+BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target )
{
- connect_t *connect;
- WCHAR *addressW = NULL;
- INTERNET_PORT port;
- socklen_t slen;
- struct sockaddr *saddr;
- DWORD len;
-
- if (netconn_connected( &request->netconn )) goto done;
+ BOOL ret = FALSE;
+ request_t *request;
- connect = request->connect;
- port = connect->serverport ? connect->serverport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
- saddr = (struct sockaddr *)&connect->sockaddr;
- slen = sizeof(struct sockaddr);
+ TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target);
- if (!connect->resolved)
+ if (!(request = (request_t *)grab_object( hrequest )))
{
- len = strlenW( connect->servername ) + 1;
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, connect->servername, len );
-
- if (!netconn_resolve( connect->servername, port, saddr, &slen, request->resolve_timeout )) return FALSE;
- connect->resolved = TRUE;
-
- if (!(addressW = addr_to_str( saddr ))) return FALSE;
- len = strlenW( addressW ) + 1;
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, addressW, len );
+ set_last_error( ERROR_INVALID_HANDLE );
+ return FALSE;
}
- if (!addressW && !(addressW = addr_to_str( saddr ))) return FALSE;
- TRACE("connecting to %s:%u\n", debugstr_w(addressW), port);
-
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, addressW, 0 );
-
- if (!netconn_create( &request->netconn, saddr->sa_family, SOCK_STREAM, 0 ))
+ if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
{
- heap_free( addressW );
+ release_object( &request->hdr );
+ set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
return FALSE;
}
- netconn_set_timeout( &request->netconn, TRUE, request->send_timeout );
- netconn_set_timeout( &request->netconn, FALSE, request->recv_timeout );
- if (!netconn_connect( &request->netconn, saddr, slen, request->connect_timeout ))
+ if (!supported || !first || !target)
{
- netconn_close( &request->netconn );
- heap_free( addressW );
+ release_object( &request->hdr );
+ set_last_error( ERROR_INVALID_PARAMETER );
return FALSE;
+
}
- if (request->hdr.flags & WINHTTP_FLAG_SECURE)
+
+ if (query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first ))
{
- if (connect->session->proxy_server &&
- strcmpiW( connect->hostname, connect->servername ))
- {
- if (!secure_proxy_connect( request ))
- {
- heap_free( addressW );
- return FALSE;
- }
- }
- if (!netconn_secure_connect( &request->netconn, connect->hostname ))
- {
- netconn_close( &request->netconn );
- heap_free( addressW );
- return FALSE;
- }
+ *target = WINHTTP_AUTH_TARGET_SERVER;
+ ret = TRUE;
+ }
+ else if (query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first ))
+ {
+ *target = WINHTTP_AUTH_TARGET_PROXY;
+ ret = TRUE;
}
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, addressW, strlenW(addressW) + 1 );
-
-done:
- request->read_pos = request->read_size = 0;
- request->read_chunked = FALSE;
- request->read_chunked_size = ~0u;
- request->read_chunked_eof = FALSE;
- heap_free( addressW );
- return TRUE;
+ release_object( &request->hdr );
+ if (ret) set_last_error( ERROR_SUCCESS );
+ return ret;
}
-void close_connection( request_t *request )
+static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 )
{
- if (!netconn_connected( &request->netconn )) return;
+ UINT n = 0, x;
+ static const char base64enc[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, 0, 0 );
- netconn_close( &request->netconn );
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, 0, 0 );
-}
+ while (len > 0)
+ {
+ /* first 6 bits, all from bin[0] */
+ base64[n++] = base64enc[(bin[0] & 0xfc) >> 2];
+ x = (bin[0] & 3) << 4;
-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;
+ /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
+ if (len == 1)
+ {
+ base64[n++] = base64enc[x];
+ base64[n++] = '=';
+ base64[n++] = '=';
+ break;
+ }
+ base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)];
+ x = (bin[1] & 0x0f) << 2;
- port = connect->hostport ? connect->hostport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
+ /* next 6 bits 4 from bin[1] and 2 from bin[2] */
+ if (len == 2)
+ {
+ base64[n++] = base64enc[x];
+ base64[n++] = '=';
+ break;
+ }
+ base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)];
- if (port == INTERNET_DEFAULT_HTTP_PORT || port == INTERNET_DEFAULT_HTTPS_PORT)
- {
- return process_header( request, attr_host, connect->hostname, modifier, TRUE );
+ /* last 6 bits, all from bin [2] */
+ base64[n++] = base64enc[bin[2] & 0x3f];
+ bin += 3;
+ len -= 3;
}
- len = strlenW( connect->hostname ) + 7; /* sizeof(":65335") */
- if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
- sprintfW( host, fmt, connect->hostname, port );
- ret = process_header( request, attr_host, host, modifier, TRUE );
- heap_free( host );
- return ret;
+ base64[n] = 0;
+ return n;
}
-static void clear_response_headers( request_t *request )
+static inline char decode_char( WCHAR c )
{
- unsigned int i;
-
- for (i = 0; i < request->num_headers; i++)
- {
- if (!request->headers[i].field) continue;
- if (!request->headers[i].value) continue;
- if (request->headers[i].is_request) continue;
- delete_header( request, i );
- i--;
- }
+ if (c >= 'A' && c <= 'Z') return c - 'A';
+ if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+ if (c >= '0' && c <= '9') return c - '0' + 52;
+ if (c == '+') return 62;
+ if (c == '/') return 63;
+ return 64;
}
-static BOOL send_request( request_t *request, LPCWSTR headers, DWORD headers_len, LPVOID optional,
- DWORD optional_len, DWORD total_len, DWORD_PTR context, BOOL async )
+static unsigned int decode_base64( const WCHAR *base64, unsigned int len, char *buf )
{
- 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};
-
- BOOL ret = FALSE;
- connect_t *connect = request->connect;
- session_t *session = connect->session;
- WCHAR *req = NULL;
- char *req_ascii;
- int bytes_sent;
- DWORD len, i, flags;
-
- clear_response_headers( request );
+ unsigned int i = 0;
+ char c0, c1, c2, c3;
+ const WCHAR *p = base64;
- flags = WINHTTP_ADDREQ_FLAG_ADD|WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA;
- for (i = 0; i < request->num_accept_types; i++)
+ while (len > 4)
{
- process_header( request, attr_accept, request->accept_types[i], flags, TRUE );
- }
- if (session->agent)
- process_header( request, attr_user_agent, session->agent, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
-
- if (connect->hostname)
- add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
+ if ((c0 = decode_char( p[0] )) > 63) return 0;
+ if ((c1 = decode_char( p[1] )) > 63) return 0;
+ if ((c2 = decode_char( p[2] )) > 63) return 0;
+ if ((c3 = decode_char( p[3] )) > 63) return 0;
- if (total_len || (request->verb && !strcmpW( request->verb, postW )))
- {
- WCHAR length[21]; /* decimal long int + null */
- sprintfW( length, length_fmt, total_len );
- process_header( request, attr_content_length, length, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
- }
- if (!(request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE))
- {
- process_header( request, attr_connection, keep_alive, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
- }
- if (request->hdr.flags & WINHTTP_FLAG_REFRESH)
- {
- process_header( request, attr_pragma, no_cache, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
- process_header( request, attr_cache_control, no_cache, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
+ if (buf)
+ {
+ buf[i + 0] = (c0 << 2) | (c1 >> 4);
+ buf[i + 1] = (c1 << 4) | (c2 >> 2);
+ buf[i + 2] = (c2 << 6) | c3;
+ }
+ len -= 4;
+ i += 3;
+ p += 4;
}
- if (headers && !add_request_headers( request, headers, headers_len, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))
+ if (p[2] == '=')
{
- TRACE("failed to add request headers\n");
- return FALSE;
+ if ((c0 = decode_char( p[0] )) > 63) return 0;
+ if ((c1 = decode_char( p[1] )) > 63) return 0;
+
+ if (buf) buf[i] = (c0 << 2) | (c1 >> 4);
+ i++;
}
- if (!(request->hdr.disable_flags & WINHTTP_DISABLE_COOKIES) && !add_cookie_headers( request ))
+ else if (p[3] == '=')
{
- WARN("failed to add cookie headers\n");
- return FALSE;
- }
-
- if (context) request->hdr.context = context;
-
- if (!(ret = open_connection( request ))) goto end;
- if (!(req = build_request_string( request ))) goto end;
-
- if (!(req_ascii = strdupWA( req ))) goto end;
- TRACE("full request: %s\n", debugstr_a(req_ascii));
- len = strlen(req_ascii);
-
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 );
-
- ret = netconn_send( &request->netconn, req_ascii, len, &bytes_sent );
- heap_free( req_ascii );
- if (!ret) goto end;
+ if ((c0 = decode_char( p[0] )) > 63) return 0;
+ if ((c1 = decode_char( p[1] )) > 63) return 0;
+ if ((c2 = decode_char( p[2] )) > 63) return 0;
- if (optional_len)
- {
- if (!netconn_send( &request->netconn, optional, optional_len, &bytes_sent )) goto end;
- request->optional = optional;
- request->optional_len = optional_len;
- len += optional_len;
+ if (buf)
+ {
+ buf[i + 0] = (c0 << 2) | (c1 >> 4);
+ buf[i + 1] = (c1 << 4) | (c2 >> 2);
+ }
+ i += 2;
}
- send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_SENT, &len, sizeof(len) );
-
-end:
- if (async)
+ else
{
- if (ret) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NULL, 0 );
- else
+ if ((c0 = decode_char( p[0] )) > 63) return 0;
+ if ((c1 = decode_char( p[1] )) > 63) return 0;
+ if ((c2 = decode_char( p[2] )) > 63) return 0;
+ if ((c3 = decode_char( p[3] )) > 63) return 0;
+
+ if (buf)
{
- 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) );
+ buf[i + 0] = (c0 << 2) | (c1 >> 4);
+ buf[i + 1] = (c1 << 4) | (c2 >> 2);
+ buf[i + 2] = (c2 << 6) | c3;
}
+ i += 3;
}
- heap_free( req );
- return ret;
+ return i;
}
-static void task_send_request( task_header_t *task )
+static struct authinfo *alloc_authinfo(void)
{
- 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 );
+ struct authinfo *ret;
+
+ if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
+
+ SecInvalidateHandle( &ret->cred );
+ SecInvalidateHandle( &ret->ctx );
+ memset( &ret->exp, 0, sizeof(ret->exp) );
+ ret->scheme = 0;
+ ret->attr = 0;
+ ret->max_token = 0;
+ ret->data = NULL;
+ ret->data_len = 0;
+ ret->finished = FALSE;
+ return ret;
}
-/***********************************************************************
- * WinHttpSendRequest (winhttp.@)
- */
-BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD headers_len,
- LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context )
+void destroy_authinfo( struct authinfo *authinfo )
{
- BOOL ret;
- request_t *request;
-
- TRACE("%p, %s, 0x%x, %u, %u, %lx\n",
- hrequest, debugstr_w(headers), headers_len, optional_len, total_len, context);
+ if (!authinfo) return;
- 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 (SecIsValidHandle( &authinfo->ctx ))
+ DeleteSecurityContext( &authinfo->ctx );
+ if (SecIsValidHandle( &authinfo->cred ))
+ FreeCredentialsHandle( &authinfo->cred );
- if (headers && !headers_len) headers_len = strlenW( headers );
+ heap_free( authinfo->data );
+ heap_free( authinfo );
+}
- if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+static BOOL get_authvalue( request_t *request, DWORD level, DWORD scheme, WCHAR *buffer, DWORD len )
+{
+ DWORD size, index = 0;
+ for (;;)
{
- 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 );
+ size = len;
+ if (!query_headers( request, level, NULL, buffer, &size, &index )) return FALSE;
+ if (auth_scheme_from_header( buffer ) == scheme) break;
}
- else
- ret = send_request( request, headers, headers_len, optional, optional_len, total_len, context, FALSE );
-
- release_object( &request->hdr );
- if (ret) set_last_error( ERROR_SUCCESS );
- return ret;
+ return TRUE;
}
-#undef ARRAYSIZE
-#define ARRAYSIZE(array) (sizeof(array) / sizeof((array)[0]))
-
-static const WCHAR basicW[] = {'B','a','s','i','c',0};
-static const WCHAR ntlmW[] = {'N','T','L','M',0};
-static const WCHAR passportW[] = {'P','a','s','s','p','o','r','t',0};
-static const WCHAR digestW[] = {'D','i','g','e','s','t',0};
-static const WCHAR negotiateW[] = {'N','e','g','o','t','i','a','t','e',0};
-
-static const struct
-{
- const WCHAR *str;
- unsigned int len;
- DWORD scheme;
-}
-auth_schemes[] =
-{
- { basicW, ARRAYSIZE(basicW) - 1, WINHTTP_AUTH_SCHEME_BASIC },
- { ntlmW, ARRAYSIZE(ntlmW) - 1, WINHTTP_AUTH_SCHEME_NTLM },
- { passportW, ARRAYSIZE(passportW) - 1, WINHTTP_AUTH_SCHEME_PASSPORT },
- { digestW, ARRAYSIZE(digestW) - 1, WINHTTP_AUTH_SCHEME_DIGEST },
- { negotiateW, ARRAYSIZE(negotiateW) - 1, WINHTTP_AUTH_SCHEME_NEGOTIATE }
-};
-static const unsigned int num_auth_schemes = sizeof(auth_schemes)/sizeof(auth_schemes[0]);
-
-static enum auth_scheme scheme_from_flag( DWORD flag )
-{
- int i;
-
- for (i = 0; i < num_auth_schemes; i++) if (flag == auth_schemes[i].scheme) return i;
- return SCHEME_INVALID;
-}
-
-static DWORD auth_scheme_from_header( WCHAR *header )
+static BOOL do_authorization( request_t *request, DWORD target, DWORD scheme_flag )
{
- unsigned int i;
-
- for (i = 0; i < num_auth_schemes; i++)
- {
- if (!strncmpiW( header, auth_schemes[i].str, auth_schemes[i].len ) &&
- (header[auth_schemes[i].len] == ' ' || !header[auth_schemes[i].len])) return auth_schemes[i].scheme;
- }
- return 0;
-}
+ struct authinfo *authinfo, **auth_ptr;
+ enum auth_scheme scheme = scheme_from_flag( scheme_flag );
+ const WCHAR *auth_target, *username, *password;
+ WCHAR auth_value[2048], *auth_reply;
+ DWORD len = sizeof(auth_value), len_scheme, flags;
+ BOOL ret, has_auth_value;
-static BOOL query_auth_schemes( request_t *request, DWORD level, LPDWORD supported, LPDWORD first )
-{
- DWORD index = 0;
- BOOL ret = FALSE;
+ if (scheme == SCHEME_INVALID) return FALSE;
- for (;;)
+ switch (target)
{
- WCHAR *buffer;
- DWORD size, scheme;
-
- size = 0;
- query_headers( request, level, NULL, NULL, &size, &index );
- if (get_last_error() != ERROR_INSUFFICIENT_BUFFER) break;
-
- index--;
- if (!(buffer = heap_alloc( size ))) return FALSE;
- if (!query_headers( request, level, NULL, buffer, &size, &index ))
+ case WINHTTP_AUTH_TARGET_SERVER:
+ has_auth_value = get_authvalue( request, WINHTTP_QUERY_WWW_AUTHENTICATE, scheme_flag, auth_value, len );
+ auth_ptr = &request->authinfo;
+ auth_target = attr_authorization;
+ if (request->creds[TARGET_SERVER][scheme].username)
{
- heap_free( buffer );
- return FALSE;
+ if (scheme != SCHEME_BASIC && !has_auth_value) return FALSE;
+ username = request->creds[TARGET_SERVER][scheme].username;
+ password = request->creds[TARGET_SERVER][scheme].password;
}
- scheme = auth_scheme_from_header( buffer );
- heap_free( buffer );
- if (!scheme) break;
-
- if (first && index == 1)
- *first = *supported = scheme;
else
- *supported |= scheme;
-
- ret = TRUE;
- }
- return ret;
-}
-
-/***********************************************************************
- * WinHttpQueryAuthSchemes (winhttp.@)
- */
-BOOL WINAPI WinHttpQueryAuthSchemes( HINTERNET hrequest, LPDWORD supported, LPDWORD first, LPDWORD target )
-{
- BOOL ret = FALSE;
- request_t *request;
+ {
+ if (!has_auth_value) return FALSE;
+ username = request->connect->username;
+ password = request->connect->password;
+ }
+ break;
- TRACE("%p, %p, %p, %p\n", hrequest, supported, first, target);
+ case WINHTTP_AUTH_TARGET_PROXY:
+ if (!get_authvalue( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, scheme_flag, auth_value, len ))
+ return FALSE;
+ auth_ptr = &request->proxy_authinfo;
+ auth_target = attr_proxy_authorization;
+ if (request->creds[TARGET_PROXY][scheme].username)
+ {
+ username = request->creds[TARGET_PROXY][scheme].username;
+ password = request->creds[TARGET_PROXY][scheme].password;
+ }
+ else
+ {
+ username = request->connect->session->proxy_username;
+ password = request->connect->session->proxy_password;
+ }
+ break;
- if (!(request = (request_t *)grab_object( hrequest )))
- {
- set_last_error( ERROR_INVALID_HANDLE );
+ default:
+ WARN("unknown target %x\n", target);
return FALSE;
}
- if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
+ authinfo = *auth_ptr;
+
+ switch (scheme)
{
- release_object( &request->hdr );
- set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
- return FALSE;
- }
- if (!supported || !first || !target)
+ case SCHEME_BASIC:
{
- release_object( &request->hdr );
- set_last_error( ERROR_INVALID_PARAMETER );
- return FALSE;
+ int userlen, passlen;
- }
+ if (!username || !password) return FALSE;
+ if ((!authinfo && !(authinfo = alloc_authinfo())) || authinfo->finished) return FALSE;
- if (query_auth_schemes( request, WINHTTP_QUERY_WWW_AUTHENTICATE, supported, first ))
- {
- *target = WINHTTP_AUTH_TARGET_SERVER;
- ret = TRUE;
- }
- else if (query_auth_schemes( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, supported, first ))
- {
- *target = WINHTTP_AUTH_TARGET_PROXY;
- ret = TRUE;
- }
+ userlen = WideCharToMultiByte( CP_UTF8, 0, username, strlenW( username ), NULL, 0, NULL, NULL );
+ passlen = WideCharToMultiByte( CP_UTF8, 0, password, strlenW( password ), NULL, 0, NULL, NULL );
- release_object( &request->hdr );
- if (ret) set_last_error( ERROR_SUCCESS );
- return ret;
-}
+ authinfo->data_len = userlen + 1 + passlen;
+ if (!(authinfo->data = heap_alloc( authinfo->data_len ))) return FALSE;
-static UINT encode_base64( const char *bin, unsigned int len, WCHAR *base64 )
-{
- UINT n = 0, x;
- static const char base64enc[] =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ WideCharToMultiByte( CP_UTF8, 0, username, -1, authinfo->data, userlen, NULL, NULL );
+ authinfo->data[userlen] = ':';
+ WideCharToMultiByte( CP_UTF8, 0, password, -1, authinfo->data + userlen + 1, passlen, NULL, NULL );
- while (len > 0)
+ authinfo->scheme = SCHEME_BASIC;
+ authinfo->finished = TRUE;
+ break;
+ }
+ case SCHEME_NTLM:
+ case SCHEME_NEGOTIATE:
{
- /* first 6 bits, all from bin[0] */
- base64[n++] = base64enc[(bin[0] & 0xfc) >> 2];
- x = (bin[0] & 3) << 4;
+ SECURITY_STATUS status;
+ SecBufferDesc out_desc, in_desc;
+ SecBuffer out, in;
+ ULONG flags = ISC_REQ_CONNECTION|ISC_REQ_USE_DCE_STYLE|ISC_REQ_MUTUAL_AUTH|ISC_REQ_DELEGATE;
+ const WCHAR *p;
+ BOOL first = FALSE;
- /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
- if (len == 1)
+ if (!authinfo)
{
- base64[n++] = base64enc[x];
- base64[n++] = '=';
- base64[n++] = '=';
- break;
+ TimeStamp exp;
+ SEC_WINNT_AUTH_IDENTITY_W id;
+ WCHAR *domain, *user;
+
+ if (!username || !password || !(authinfo = alloc_authinfo())) return FALSE;
+
+ first = TRUE;
+ domain = (WCHAR *)username;
+ user = strchrW( username, '\\' );
+
+ if (user) user++;
+ else
+ {
+ user = (WCHAR *)username;
+ domain = NULL;
+ }
+ id.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
+ id.User = user;
+ id.UserLength = strlenW( user );
+ id.Domain = domain;
+ id.DomainLength = domain ? user - domain - 1 : 0;
+ id.Password = (WCHAR *)password;
+ id.PasswordLength = strlenW( password );
+
+ status = AcquireCredentialsHandleW( NULL, (SEC_WCHAR *)auth_schemes[scheme].str,
+ SECPKG_CRED_OUTBOUND, NULL, &id, NULL, NULL,
+ &authinfo->cred, &exp );
+ if (status == SEC_E_OK)
+ {
+ PSecPkgInfoW info;
+ status = QuerySecurityPackageInfoW( (SEC_WCHAR *)auth_schemes[scheme].str, &info );
+ if (status == SEC_E_OK)
+ {
+ authinfo->max_token = info->cbMaxToken;
+ FreeContextBuffer( info );
+ }
+ }
+ if (status != SEC_E_OK)
+ {
+ WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
+ debugstr_w(auth_schemes[scheme].str), status);
+ heap_free( authinfo );
+ return FALSE;
+ }
+ authinfo->scheme = scheme;
}
- base64[n++] = base64enc[x | ((bin[1] & 0xf0) >> 4)];
- x = (bin[1] & 0x0f) << 2;
+ else if (authinfo->finished) return FALSE;
- /* next 6 bits 4 from bin[1] and 2 from bin[2] */
- if (len == 2)
+ if ((strlenW( auth_value ) < auth_schemes[authinfo->scheme].len ||
+ strncmpiW( auth_value, auth_schemes[authinfo->scheme].str, auth_schemes[authinfo->scheme].len )))
{
- base64[n++] = base64enc[x];
- base64[n++] = '=';
- break;
+ ERR("authentication scheme changed from %s to %s\n",
+ debugstr_w(auth_schemes[authinfo->scheme].str), debugstr_w(auth_value));
+ destroy_authinfo( authinfo );
+ *auth_ptr = NULL;
+ return FALSE;
}
- base64[n++] = base64enc[x | ((bin[2] & 0xc0) >> 6)];
+ in.BufferType = SECBUFFER_TOKEN;
+ in.cbBuffer = 0;
+ in.pvBuffer = NULL;
- /* last 6 bits, all from bin [2] */
- base64[n++] = base64enc[bin[2] & 0x3f];
- bin += 3;
- len -= 3;
- }
- base64[n] = 0;
- return n;
-}
+ in_desc.ulVersion = 0;
+ in_desc.cBuffers = 1;
+ in_desc.pBuffers = ∈
-static inline char decode_char( WCHAR c )
-{
- if (c >= 'A' && c <= 'Z') return c - 'A';
- if (c >= 'a' && c <= 'z') return c - 'a' + 26;
- if (c >= '0' && c <= '9') return c - '0' + 52;
- if (c == '+') return 62;
- if (c == '/') return 63;
- return 64;
-}
-
-static unsigned int decode_base64( const WCHAR *base64, unsigned int len, char *buf )
-{
- unsigned int i = 0;
- char c0, c1, c2, c3;
- const WCHAR *p = base64;
-
- while (len > 4)
- {
- if ((c0 = decode_char( p[0] )) > 63) return 0;
- if ((c1 = decode_char( p[1] )) > 63) return 0;
- if ((c2 = decode_char( p[2] )) > 63) return 0;
- if ((c3 = decode_char( p[3] )) > 63) return 0;
-
- if (buf)
+ p = auth_value + auth_schemes[scheme].len;
+ if (*p == ' ')
{
- buf[i + 0] = (c0 << 2) | (c1 >> 4);
- buf[i + 1] = (c1 << 4) | (c2 >> 2);
- buf[i + 2] = (c2 << 6) | c3;
+ int len = strlenW( ++p );
+ in.cbBuffer = decode_base64( p, len, NULL );
+ if (!(in.pvBuffer = heap_alloc( in.cbBuffer ))) {
+ destroy_authinfo( authinfo );
+ *auth_ptr = NULL;
+ return FALSE;
+ }
+ decode_base64( p, len, in.pvBuffer );
}
- len -= 4;
- i += 3;
- p += 4;
- }
- if (p[2] == '=')
- {
- if ((c0 = decode_char( p[0] )) > 63) return 0;
- if ((c1 = decode_char( p[1] )) > 63) return 0;
-
- if (buf) buf[i] = (c0 << 2) | (c1 >> 4);
- i++;
- }
- else if (p[3] == '=')
- {
- if ((c0 = decode_char( p[0] )) > 63) return 0;
- if ((c1 = decode_char( p[1] )) > 63) return 0;
- if ((c2 = decode_char( p[2] )) > 63) return 0;
-
- if (buf)
+ out.BufferType = SECBUFFER_TOKEN;
+ out.cbBuffer = authinfo->max_token;
+ if (!(out.pvBuffer = heap_alloc( authinfo->max_token )))
{
- buf[i + 0] = (c0 << 2) | (c1 >> 4);
- buf[i + 1] = (c1 << 4) | (c2 >> 2);
+ heap_free( in.pvBuffer );
+ destroy_authinfo( authinfo );
+ *auth_ptr = NULL;
+ return FALSE;
}
- i += 2;
- }
- else
- {
- if ((c0 = decode_char( p[0] )) > 63) return 0;
- if ((c1 = decode_char( p[1] )) > 63) return 0;
- if ((c2 = decode_char( p[2] )) > 63) return 0;
- if ((c3 = decode_char( p[3] )) > 63) return 0;
+ out_desc.ulVersion = 0;
+ out_desc.cBuffers = 1;
+ out_desc.pBuffers = &out;
- if (buf)
+ status = InitializeSecurityContextW( first ? &authinfo->cred : NULL, first ? NULL : &authinfo->ctx,
+ first ? request->connect->servername : NULL, flags, 0,
+ SECURITY_NETWORK_DREP, in.pvBuffer ? &in_desc : NULL, 0,
+ &authinfo->ctx, &out_desc, &authinfo->attr, &authinfo->exp );
+ heap_free( in.pvBuffer );
+ if (status == SEC_E_OK)
{
- buf[i + 0] = (c0 << 2) | (c1 >> 4);
- buf[i + 1] = (c1 << 4) | (c2 >> 2);
- buf[i + 2] = (c2 << 6) | c3;
+ heap_free( authinfo->data );
+ authinfo->data = out.pvBuffer;
+ authinfo->data_len = out.cbBuffer;
+ authinfo->finished = TRUE;
+ TRACE("sending last auth packet\n");
}
- i += 3;
+ else if (status == SEC_I_CONTINUE_NEEDED)
+ {
+ heap_free( authinfo->data );
+ authinfo->data = out.pvBuffer;
+ authinfo->data_len = out.cbBuffer;
+ TRACE("sending next auth packet\n");
+ }
+ else
+ {
+ ERR("InitializeSecurityContextW failed with error 0x%08x\n", status);
+ heap_free( out.pvBuffer );
+ destroy_authinfo( authinfo );
+ *auth_ptr = NULL;
+ return FALSE;
+ }
+ break;
}
- return i;
-}
+ default:
+ ERR("invalid scheme %u\n", scheme);
+ return FALSE;
+ }
+ *auth_ptr = authinfo;
-static struct authinfo *alloc_authinfo(void)
-{
- struct authinfo *ret;
+ len_scheme = auth_schemes[authinfo->scheme].len;
+ len = len_scheme + 1 + ((authinfo->data_len + 2) * 4) / 3;
+ if (!(auth_reply = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
- if (!(ret = heap_alloc( sizeof(*ret) ))) return NULL;
+ memcpy( auth_reply, auth_schemes[authinfo->scheme].str, len_scheme * sizeof(WCHAR) );
+ auth_reply[len_scheme] = ' ';
+ encode_base64( authinfo->data, authinfo->data_len, auth_reply + len_scheme + 1 );
- SecInvalidateHandle( &ret->cred );
- SecInvalidateHandle( &ret->ctx );
- memset( &ret->exp, 0, sizeof(ret->exp) );
- ret->scheme = 0;
- ret->attr = 0;
- ret->max_token = 0;
- ret->data = NULL;
- ret->data_len = 0;
- ret->finished = FALSE;
+ flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
+ ret = process_header( request, auth_target, auth_reply, flags, TRUE );
+ heap_free( auth_reply );
return ret;
}
-void destroy_authinfo( struct authinfo *authinfo )
+static LPWSTR concatenate_string_list( LPCWSTR *list, int len )
{
- if (!authinfo) return;
+ LPCWSTR *t;
+ LPWSTR str;
- if (SecIsValidHandle( &authinfo->ctx ))
- DeleteSecurityContext( &authinfo->ctx );
- if (SecIsValidHandle( &authinfo->cred ))
- FreeCredentialsHandle( &authinfo->cred );
+ for( t = list; *t ; t++ )
+ len += strlenW( *t );
+ len++;
- heap_free( authinfo->data );
- heap_free( authinfo );
-}
+ str = heap_alloc( len * sizeof(WCHAR) );
+ if (!str) return NULL;
+ *str = 0;
-static BOOL get_authvalue( request_t *request, DWORD level, DWORD scheme, WCHAR *buffer, DWORD len )
-{
- DWORD size, index = 0;
- for (;;)
- {
- size = len;
- if (!query_headers( request, level, NULL, buffer, &size, &index )) return FALSE;
- if (auth_scheme_from_header( buffer ) == scheme) break;
- }
- return TRUE;
+ for( t = list; *t ; t++ )
+ strcatW( str, *t );
+
+ return str;
}
-static BOOL do_authorization( request_t *request, DWORD target, DWORD scheme_flag )
+static LPWSTR build_header_request_string( request_t *request, LPCWSTR verb,
+ LPCWSTR path, LPCWSTR version )
{
- struct authinfo *authinfo, **auth_ptr;
- enum auth_scheme scheme = scheme_from_flag( scheme_flag );
- const WCHAR *auth_target, *username, *password;
- WCHAR auth_value[2048], *auth_reply;
- DWORD len = sizeof(auth_value), len_scheme, flags;
- BOOL ret;
+ static const WCHAR crlf[] = {'\r','\n',0};
+ static const WCHAR space[] = { ' ',0 };
+ static const WCHAR colon[] = { ':',' ',0 };
+ static const WCHAR twocrlf[] = {'\r','\n','\r','\n', 0};
+ LPWSTR requestString;
+ DWORD len, n;
+ LPCWSTR *req;
+ UINT i;
+ LPWSTR p;
- if (scheme == SCHEME_INVALID) return FALSE;
+ /* allocate space for an array of all the string pointers to be added */
+ len = (request->num_headers) * 4 + 10;
+ req = heap_alloc( len * sizeof(LPCWSTR) );
+ if (!req) return NULL;
- switch (target)
+ /* add the verb, path and HTTP version string */
+ n = 0;
+ req[n++] = verb;
+ req[n++] = space;
+ req[n++] = path;
+ req[n++] = space;
+ req[n++] = version;
+
+ /* Append custom request headers */
+ for (i = 0; i < request->num_headers; i++)
{
- case WINHTTP_AUTH_TARGET_SERVER:
- if (!get_authvalue( request, WINHTTP_QUERY_WWW_AUTHENTICATE, scheme_flag, auth_value, len ))
- return FALSE;
- auth_ptr = &request->authinfo;
- auth_target = attr_authorization;
- if (request->creds[TARGET_SERVER][scheme].username)
- {
- username = request->creds[TARGET_SERVER][scheme].username;
- password = request->creds[TARGET_SERVER][scheme].password;
- }
- else
+ if (request->headers[i].is_request)
{
- username = request->connect->username;
- password = request->connect->password;
- }
- break;
+ req[n++] = crlf;
+ req[n++] = request->headers[i].field;
+ req[n++] = colon;
+ req[n++] = request->headers[i].value;
- case WINHTTP_AUTH_TARGET_PROXY:
- if (!get_authvalue( request, WINHTTP_QUERY_PROXY_AUTHENTICATE, scheme_flag, auth_value, len ))
- return FALSE;
- auth_ptr = &request->proxy_authinfo;
- auth_target = attr_proxy_authorization;
- if (request->creds[TARGET_PROXY][scheme].username)
- {
- username = request->creds[TARGET_PROXY][scheme].username;
- password = request->creds[TARGET_PROXY][scheme].password;
- }
- else
- {
- username = request->connect->session->proxy_username;
- password = request->connect->session->proxy_password;
+ TRACE("Adding custom header %s (%s)\n",
+ debugstr_w(request->headers[i].field),
+ debugstr_w(request->headers[i].value));
}
- break;
-
- default:
- WARN("unknown target %x\n", target);
- return FALSE;
}
- authinfo = *auth_ptr;
-
- switch (scheme)
- {
- case SCHEME_BASIC:
- {
- int userlen, passlen;
- if (!username || !password) return FALSE;
- if ((!authinfo && !(authinfo = alloc_authinfo())) || authinfo->finished) return FALSE;
+ if( n >= len )
+ ERR("oops. buffer overrun\n");
- userlen = WideCharToMultiByte( CP_UTF8, 0, username, strlenW( username ), NULL, 0, NULL, NULL );
- passlen = WideCharToMultiByte( CP_UTF8, 0, password, strlenW( password ), NULL, 0, NULL, NULL );
+ req[n] = NULL;
+ requestString = concatenate_string_list( req, 4 );
+ heap_free( req );
+ if (!requestString) return NULL;
- authinfo->data_len = userlen + 1 + passlen;
- if (!(authinfo->data = heap_alloc( authinfo->data_len ))) return FALSE;
+ /*
+ * Set (header) termination string for request
+ * Make sure there are exactly two new lines at the end of the request
+ */
+ p = &requestString[strlenW(requestString)-1];
+ while ( (*p == '\n') || (*p == '\r') )
+ p--;
+ strcpyW( p+1, twocrlf );
- WideCharToMultiByte( CP_UTF8, 0, username, -1, authinfo->data, userlen, NULL, NULL );
- authinfo->data[userlen] = ':';
- WideCharToMultiByte( CP_UTF8, 0, password, -1, authinfo->data + userlen + 1, passlen, NULL, NULL );
+ return requestString;
+}
- authinfo->scheme = SCHEME_BASIC;
- authinfo->finished = TRUE;
- break;
- }
- case SCHEME_NTLM:
- case SCHEME_NEGOTIATE:
- {
- SECURITY_STATUS status;
- SecBufferDesc out_desc, in_desc;
- SecBuffer out, in;
- ULONG flags = ISC_REQ_CONNECTION|ISC_REQ_USE_DCE_STYLE|ISC_REQ_MUTUAL_AUTH|ISC_REQ_DELEGATE;
- const WCHAR *p;
- BOOL first = FALSE;
+static BOOL read_reply( request_t *request );
- if (!authinfo)
- {
- TimeStamp exp;
- SEC_WINNT_AUTH_IDENTITY_W id;
- WCHAR *domain, *user;
+static BOOL secure_proxy_connect( request_t *request )
+{
+ static const WCHAR verbConnect[] = {'C','O','N','N','E','C','T',0};
+ static const WCHAR fmt[] = {'%','s',':','%','u',0};
+ BOOL ret = FALSE;
+ LPWSTR path;
+ connect_t *connect = request->connect;
- if (!username || !password || !(authinfo = alloc_authinfo())) return FALSE;
+ path = heap_alloc( (strlenW( connect->hostname ) + 13) * sizeof(WCHAR) );
+ if (path)
+ {
+ LPWSTR requestString;
- first = TRUE;
- domain = (WCHAR *)username;
- user = strchrW( username, '\\' );
+ sprintfW( path, fmt, connect->hostname, connect->hostport );
+ requestString = build_header_request_string( request, verbConnect,
+ path, http1_1 );
+ heap_free( path );
+ if (requestString)
+ {
+ LPSTR req_ascii = strdupWA( requestString );
- if (user) user++;
- else
+ heap_free( requestString );
+ if (req_ascii)
{
- user = (WCHAR *)username;
- domain = NULL;
+ int len = strlen( req_ascii ), bytes_sent;
+
+ ret = netconn_send( request->netconn, req_ascii, len, &bytes_sent );
+ heap_free( req_ascii );
+ if (ret)
+ ret = read_reply( request );
}
- id.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
- id.User = user;
- id.UserLength = strlenW( user );
- id.Domain = domain;
- id.DomainLength = domain ? user - domain - 1 : 0;
- id.Password = (WCHAR *)password;
- id.PasswordLength = strlenW( password );
+ }
+ }
+ return ret;
+}
- status = AcquireCredentialsHandleW( NULL, (SEC_WCHAR *)auth_schemes[scheme].str,
- SECPKG_CRED_OUTBOUND, NULL, &id, NULL, NULL,
- &authinfo->cred, &exp );
- if (status == SEC_E_OK)
+#ifndef INET6_ADDRSTRLEN
+#define INET6_ADDRSTRLEN 46
+#endif
+
+static WCHAR *addr_to_str( struct sockaddr_storage *addr )
+{
+ char buf[INET6_ADDRSTRLEN];
+ void *src;
+
+ switch (addr->ss_family)
+ {
+ case AF_INET:
+ src = &((struct sockaddr_in *)addr)->sin_addr;
+ break;
+ case AF_INET6:
+ src = &((struct sockaddr_in6 *)addr)->sin6_addr;
+ break;
+ default:
+ WARN("unsupported address family %d\n", addr->ss_family);
+ return NULL;
+ }
+ if (!inet_ntop( addr->ss_family, src, buf, sizeof(buf) )) return NULL;
+ return strdupAW( buf );
+}
+
+static CRITICAL_SECTION connection_pool_cs;
+static CRITICAL_SECTION_DEBUG connection_pool_debug =
+{
+ 0, 0, &connection_pool_cs,
+ { &connection_pool_debug.ProcessLocksList, &connection_pool_debug.ProcessLocksList },
+ 0, 0, { (DWORD_PTR)(__FILE__ ": connection_pool_cs") }
+};
+static CRITICAL_SECTION connection_pool_cs = { &connection_pool_debug, -1, 0, 0, 0, 0 };
+
+static struct list connection_pool = LIST_INIT( connection_pool );
+
+void release_host( hostdata_t *host )
+{
+ LONG ref;
+
+ EnterCriticalSection( &connection_pool_cs );
+ if (!(ref = --host->ref)) list_remove( &host->entry );
+ LeaveCriticalSection( &connection_pool_cs );
+ if (ref) return;
+
+ assert( list_empty( &host->connections ) );
+ heap_free( host->hostname );
+ heap_free( host );
+}
+
+static BOOL connection_collector_running;
+
+static DWORD WINAPI connection_collector(void *arg)
+{
+ unsigned int remaining_connections;
+ netconn_t *netconn, *next_netconn;
+ hostdata_t *host, *next_host;
+ ULONGLONG now;
+
+ do
+ {
+ /* FIXME: Use more sophisticated method */
+ Sleep(5000);
+ remaining_connections = 0;
+ now = GetTickCount64();
+
+ EnterCriticalSection(&connection_pool_cs);
+
+ LIST_FOR_EACH_ENTRY_SAFE(host, next_host, &connection_pool, hostdata_t, entry)
+ {
+ LIST_FOR_EACH_ENTRY_SAFE(netconn, next_netconn, &host->connections, netconn_t, entry)
{
- PSecPkgInfoW info;
- status = QuerySecurityPackageInfoW( (SEC_WCHAR *)auth_schemes[scheme].str, &info );
- if (status == SEC_E_OK)
+ if (netconn->keep_until < now)
{
- authinfo->max_token = info->cbMaxToken;
- FreeContextBuffer( info );
+ TRACE("freeing %p\n", netconn);
+ list_remove(&netconn->entry);
+ netconn_close(netconn);
+ }
+ else
+ {
+ remaining_connections++;
}
}
- if (status != SEC_E_OK)
- {
- WARN("AcquireCredentialsHandleW for scheme %s failed with error 0x%08x\n",
- debugstr_w(auth_schemes[scheme].str), status);
- heap_free( authinfo );
- return FALSE;
- }
- authinfo->scheme = scheme;
}
- else if (authinfo->finished) return FALSE;
- if ((strlenW( auth_value ) < auth_schemes[authinfo->scheme].len ||
- strncmpiW( auth_value, auth_schemes[authinfo->scheme].str, auth_schemes[authinfo->scheme].len )))
- {
- ERR("authentication scheme changed from %s to %s\n",
- debugstr_w(auth_schemes[authinfo->scheme].str), debugstr_w(auth_value));
- destroy_authinfo( authinfo );
- *auth_ptr = NULL;
- return FALSE;
- }
- in.BufferType = SECBUFFER_TOKEN;
- in.cbBuffer = 0;
- in.pvBuffer = NULL;
+ if (!remaining_connections) connection_collector_running = FALSE;
- in_desc.ulVersion = 0;
- in_desc.cBuffers = 1;
- in_desc.pBuffers = ∈
+ LeaveCriticalSection(&connection_pool_cs);
+ } while(remaining_connections);
- p = auth_value + auth_schemes[scheme].len;
- if (*p == ' ')
+ FreeLibraryAndExitThread( winhttp_instance, 0 );
+}
+
+static void cache_connection( netconn_t *netconn )
+{
+ TRACE( "caching connection %p\n", netconn );
+
+ EnterCriticalSection( &connection_pool_cs );
+
+ netconn->keep_until = GetTickCount64() + DEFAULT_KEEP_ALIVE_TIMEOUT;
+ list_add_head( &netconn->host->connections, &netconn->entry );
+
+ if (!connection_collector_running)
+ {
+ HMODULE module;
+ HANDLE thread;
+
+ GetModuleHandleExW( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const WCHAR*)winhttp_instance, &module );
+
+ thread = CreateThread(NULL, 0, connection_collector, NULL, 0, NULL);
+ if (thread)
{
- int len = strlenW( ++p );
- in.cbBuffer = decode_base64( p, len, NULL );
- if (!(in.pvBuffer = heap_alloc( in.cbBuffer ))) {
- destroy_authinfo( authinfo );
- *auth_ptr = NULL;
- return FALSE;
- }
- decode_base64( p, len, in.pvBuffer );
+ CloseHandle( thread );
+ connection_collector_running = TRUE;
}
- out.BufferType = SECBUFFER_TOKEN;
- out.cbBuffer = authinfo->max_token;
- if (!(out.pvBuffer = heap_alloc( authinfo->max_token )))
+ else
{
- heap_free( in.pvBuffer );
- destroy_authinfo( authinfo );
- *auth_ptr = NULL;
- return FALSE;
+ FreeLibrary( winhttp_instance );
}
- out_desc.ulVersion = 0;
- out_desc.cBuffers = 1;
- out_desc.pBuffers = &out;
+ }
- status = InitializeSecurityContextW( first ? &authinfo->cred : NULL, first ? NULL : &authinfo->ctx,
- first ? request->connect->servername : NULL, flags, 0,
- SECURITY_NETWORK_DREP, in.pvBuffer ? &in_desc : NULL, 0,
- &authinfo->ctx, &out_desc, &authinfo->attr, &authinfo->exp );
- heap_free( in.pvBuffer );
- if (status == SEC_E_OK)
+ LeaveCriticalSection( &connection_pool_cs );
+}
+
+static DWORD map_secure_protocols( DWORD mask )
+{
+ DWORD ret = 0;
+ if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_SSL2) ret |= SP_PROT_SSL2_CLIENT;
+ if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_SSL3) ret |= SP_PROT_SSL3_CLIENT;
+ if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_TLS1) ret |= SP_PROT_TLS1_CLIENT;
+ if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1) ret |= SP_PROT_TLS1_1_CLIENT;
+ if (mask & WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2) ret |= SP_PROT_TLS1_2_CLIENT;
+ return ret;
+}
+
+static BOOL ensure_cred_handle( session_t *session )
+{
+ SCHANNEL_CRED cred;
+ SECURITY_STATUS status;
+
+ if (session->cred_handle_initialized) return TRUE;
+
+ memset( &cred, 0, sizeof(cred) );
+ cred.dwVersion = SCHANNEL_CRED_VERSION;
+ cred.grbitEnabledProtocols = map_secure_protocols( session->secure_protocols );
+ if ((status = AcquireCredentialsHandleW( NULL, (WCHAR *)UNISP_NAME_W, SECPKG_CRED_OUTBOUND, NULL, &cred,
+ NULL, NULL, &session->cred_handle, NULL )) != SEC_E_OK)
+ {
+ WARN( "AcquireCredentialsHandleW failed: 0x%08x\n", status );
+ return FALSE;
+ }
+ session->cred_handle_initialized = TRUE;
+ return TRUE;
+}
+
+static BOOL open_connection( request_t *request )
+{
+ BOOL is_secure = request->hdr.flags & WINHTTP_FLAG_SECURE;
+ hostdata_t *host = NULL, *iter;
+ netconn_t *netconn = NULL;
+ connect_t *connect;
+ WCHAR *addressW = NULL;
+ INTERNET_PORT port;
+ DWORD len;
+
+ if (request->netconn) goto done;
+
+ connect = request->connect;
+ port = connect->serverport ? connect->serverport : (request->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
+
+ EnterCriticalSection( &connection_pool_cs );
+
+ LIST_FOR_EACH_ENTRY( iter, &connection_pool, hostdata_t, entry )
+ {
+ if (iter->port == port && !strcmpW( connect->servername, iter->hostname ) && !is_secure == !iter->secure)
{
- heap_free( authinfo->data );
- authinfo->data = out.pvBuffer;
- authinfo->data_len = out.cbBuffer;
- authinfo->finished = TRUE;
- TRACE("sending last auth packet\n");
+ host = iter;
+ host->ref++;
+ break;
}
- else if (status == SEC_I_CONTINUE_NEEDED)
+ }
+
+ if (!host)
+ {
+ if ((host = heap_alloc( sizeof(*host) )))
{
- heap_free( authinfo->data );
- authinfo->data = out.pvBuffer;
- authinfo->data_len = out.cbBuffer;
- TRACE("sending next auth packet\n");
+ host->ref = 1;
+ host->secure = is_secure;
+ host->port = port;
+ list_init( &host->connections );
+ if ((host->hostname = strdupW( connect->servername )))
+ {
+ list_add_head( &connection_pool, &host->entry );
+ }
+ else
+ {
+ heap_free( host );
+ host = NULL;
+ }
}
- else
+ }
+
+ LeaveCriticalSection( &connection_pool_cs );
+
+ if (!host) return FALSE;
+
+ for (;;)
+ {
+ EnterCriticalSection( &connection_pool_cs );
+ if (!list_empty( &host->connections ))
{
- ERR("InitializeSecurityContextW failed with error 0x%08x\n", status);
- heap_free( out.pvBuffer );
- destroy_authinfo( authinfo );
- *auth_ptr = NULL;
- return FALSE;
+ netconn = LIST_ENTRY( list_head( &host->connections ), netconn_t, entry );
+ list_remove( &netconn->entry );
}
- break;
+ LeaveCriticalSection( &connection_pool_cs );
+ if (!netconn) break;
+
+ if (netconn_is_alive( netconn )) break;
+ TRACE("connection %p no longer alive, closing\n", netconn);
+ netconn_close( netconn );
+ netconn = NULL;
+ }
+
+ if (!connect->resolved && netconn)
+ {
+ connect->sockaddr = netconn->sockaddr;
+ connect->resolved = TRUE;
+ }
+
+ if (!connect->resolved)
+ {
+ len = strlenW( host->hostname ) + 1;
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, host->hostname, len );
+
+ if (!netconn_resolve( host->hostname, port, &connect->sockaddr, request->resolve_timeout ))
+ {
+ release_host( host );
+ return FALSE;
+ }
+ connect->resolved = TRUE;
+
+ if (!(addressW = addr_to_str( &connect->sockaddr )))
+ {
+ release_host( host );
+ return FALSE;
+ }
+ len = strlenW( addressW ) + 1;
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, addressW, len );
+ }
+
+ if (!netconn)
+ {
+ if (!addressW && !(addressW = addr_to_str( &connect->sockaddr )))
+ {
+ release_host( host );
+ return FALSE;
+ }
+
+ TRACE("connecting to %s:%u\n", debugstr_w(addressW), port);
+
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, addressW, 0 );
+
+ if (!(netconn = netconn_create( host, &connect->sockaddr, request->connect_timeout )))
+ {
+ heap_free( addressW );
+ release_host( host );
+ return FALSE;
+ }
+ netconn_set_timeout( netconn, TRUE, request->send_timeout );
+ netconn_set_timeout( netconn, FALSE, request->recv_timeout );
+ if (is_secure)
+ {
+ if (connect->session->proxy_server &&
+ strcmpiW( connect->hostname, connect->servername ))
+ {
+ if (!secure_proxy_connect( request ))
+ {
+ heap_free( addressW );
+ netconn_close( netconn );
+ return FALSE;
+ }
+ }
+ if (!ensure_cred_handle( connect->session ) ||
+ !netconn_secure_connect( netconn, connect->hostname, request->security_flags,
+ &connect->session->cred_handle ))
+ {
+ heap_free( addressW );
+ netconn_close( netconn );
+ return FALSE;
+ }
+ }
+
+ request->netconn = netconn;
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, addressW, strlenW(addressW) + 1 );
+ }
+ else
+ {
+ TRACE("using connection %p\n", netconn);
+
+ netconn_set_timeout( netconn, TRUE, request->send_timeout );
+ netconn_set_timeout( netconn, FALSE, request->recv_timeout );
+ request->netconn = netconn;
+ }
+
+done:
+ request->read_pos = request->read_size = 0;
+ request->read_chunked = FALSE;
+ request->read_chunked_size = ~0u;
+ request->read_chunked_eof = FALSE;
+ heap_free( addressW );
+ return TRUE;
+}
+
+void close_connection( request_t *request )
+{
+ if (!request->netconn) return;
+
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, 0, 0 );
+ netconn_close( request->netconn );
+ request->netconn = NULL;
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, 0, 0 );
+}
+
+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, connect->hostname, modifier, TRUE );
+ }
+ len = strlenW( connect->hostname ) + 7; /* sizeof(":65335") */
+ if (!(host = heap_alloc( len * sizeof(WCHAR) ))) return FALSE;
+ sprintfW( host, fmt, connect->hostname, port );
+ ret = process_header( request, attr_host, host, modifier, TRUE );
+ heap_free( host );
+ return ret;
+}
+
+static void clear_response_headers( request_t *request )
+{
+ unsigned int i;
+
+ for (i = 0; i < request->num_headers; i++)
+ {
+ if (!request->headers[i].field) continue;
+ if (!request->headers[i].value) continue;
+ if (request->headers[i].is_request) continue;
+ delete_header( request, i );
+ i--;
+ }
+}
+
+/* remove some amount of data from the read buffer */
+static void remove_data( request_t *request, int count )
+{
+ if (!(request->read_size -= count)) request->read_pos = 0;
+ else request->read_pos += count;
+}
+
+/* read some more data into the read buffer */
+static BOOL read_more_data( request_t *request, int maxlen, BOOL notify )
+{
+ int len;
+ BOOL ret;
+
+ if (request->read_chunked_eof) return FALSE;
+
+ if (request->read_size && request->read_pos)
+ {
+ /* move existing data to the start of the buffer */
+ memmove( request->read_buf, request->read_buf + request->read_pos, request->read_size );
+ request->read_pos = 0;
+ }
+ if (maxlen == -1) maxlen = sizeof(request->read_buf);
+
+ if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NULL, 0 );
+
+ ret = netconn_recv( request->netconn, request->read_buf + request->read_size,
+ maxlen - request->read_size, 0, &len );
+
+ if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, &len, sizeof(len) );
+
+ request->read_size += len;
+ return ret;
+}
+
+/* discard data contents until we reach end of line */
+static BOOL discard_eol( request_t *request, BOOL notify )
+{
+ do
+ {
+ char *eol = memchr( request->read_buf + request->read_pos, '\n', request->read_size );
+ if (eol)
+ {
+ remove_data( request, (eol + 1) - (request->read_buf + request->read_pos) );
+ break;
+ }
+ request->read_pos = request->read_size = 0; /* discard everything */
+ if (!read_more_data( request, -1, notify )) return FALSE;
+ } while (request->read_size);
+ return TRUE;
+}
+
+/* read the size of the next chunk */
+static BOOL start_next_chunk( request_t *request, BOOL notify )
+{
+ DWORD chunk_size = 0;
+
+ assert(!request->read_chunked_size || request->read_chunked_size == ~0u);
+
+ if (request->read_chunked_eof) return FALSE;
+
+ /* read terminator for the previous chunk */
+ if (!request->read_chunked_size && !discard_eol( request, notify )) return FALSE;
+
+ for (;;)
+ {
+ while (request->read_size)
+ {
+ char ch = request->read_buf[request->read_pos];
+ if (ch >= '0' && ch <= '9') chunk_size = chunk_size * 16 + ch - '0';
+ else if (ch >= 'a' && ch <= 'f') chunk_size = chunk_size * 16 + ch - 'a' + 10;
+ else if (ch >= 'A' && ch <= 'F') chunk_size = chunk_size * 16 + ch - 'A' + 10;
+ else if (ch == ';' || ch == '\r' || ch == '\n')
+ {
+ TRACE("reading %u byte chunk\n", chunk_size);
+
+ if (request->content_length == ~0u) request->content_length = chunk_size;
+ else request->content_length += chunk_size;
+
+ request->read_chunked_size = chunk_size;
+ if (!chunk_size) request->read_chunked_eof = TRUE;
+
+ return discard_eol( request, notify );
+ }
+ remove_data( request, 1 );
+ }
+ if (!read_more_data( request, -1, notify )) return FALSE;
+ if (!request->read_size)
+ {
+ request->content_length = request->content_read = 0;
+ request->read_chunked_size = 0;
+ return TRUE;
+ }
+ }
+}
+
+static BOOL refill_buffer( request_t *request, BOOL notify )
+{
+ int len = sizeof(request->read_buf);
+
+ if (request->read_chunked)
+ {
+ if (request->read_chunked_eof) return FALSE;
+ if (request->read_chunked_size == ~0u || !request->read_chunked_size)
+ {
+ if (!start_next_chunk( request, notify )) return FALSE;
+ }
+ len = min( len, request->read_chunked_size );
+ }
+ else if (request->content_length != ~0u)
+ {
+ len = min( len, request->content_length - request->content_read );
+ }
+
+ if (len <= request->read_size) return TRUE;
+ if (!read_more_data( request, len, notify )) return FALSE;
+ if (!request->read_size) request->content_length = request->content_read = 0;
+ 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->netconn) return;
+
+ 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 );
+ return;
+ }
+
+ cache_connection( request->netconn );
+ request->netconn = NULL;
+}
+
+/* return the size of data available to be read immediately */
+static DWORD get_available_data( request_t *request )
+{
+ if (request->read_chunked) return min( request->read_chunked_size, request->read_size );
+ return request->read_size;
+}
+
+/* check if we have reached the end of the data to read */
+static BOOL end_of_read_data( request_t *request )
+{
+ if (!request->content_length) return TRUE;
+ if (request->read_chunked) return request->read_chunked_eof;
+ if (request->content_length == ~0u) return FALSE;
+ return (request->content_length == request->content_read);
+}
+
+static BOOL read_data( request_t *request, void *buffer, DWORD size, DWORD *read, BOOL async )
+{
+ int count, bytes_read = 0;
+
+ if (end_of_read_data( request )) goto done;
+
+ while (size)
+ {
+ if (!(count = get_available_data( request )))
+ {
+ if (!refill_buffer( request, async )) goto done;
+ if (!(count = get_available_data( request ))) goto done;
+ }
+ count = min( count, size );
+ memcpy( (char *)buffer + bytes_read, request->read_buf + request->read_pos, count );
+ remove_data( request, count );
+ if (request->read_chunked) request->read_chunked_size -= count;
+ size -= count;
+ bytes_read += count;
+ request->content_read += count;
+ if (end_of_read_data( request )) goto done;
+ }
+ if (request->read_chunked && !request->read_chunked_size) refill_buffer( request, async );
+
+done:
+ TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, request->content_read, request->content_length );
+
+ if (async) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, bytes_read );
+ if (read) *read = bytes_read;
+ if (end_of_read_data( request )) finished_reading( request );
+ return TRUE;
+}
+
+/* read any content returned by the server so that the connection can be reused */
+static void drain_content( request_t *request )
+{
+ DWORD size, bytes_read, bytes_total = 0, bytes_left = request->content_length - request->content_read;
+ char buffer[2048];
+
+ refill_buffer( request, FALSE );
+ for (;;)
+ {
+ if (request->read_chunked) size = sizeof(buffer);
+ else
+ {
+ if (bytes_total >= bytes_left) return;
+ size = min( sizeof(buffer), bytes_left - bytes_total );
+ }
+ if (!read_data( request, buffer, size, &bytes_read, FALSE ) || !bytes_read) return;
+ bytes_total += bytes_read;
+ }
+}
+
+static BOOL send_request( request_t *request, LPCWSTR headers, DWORD headers_len, LPVOID optional,
+ 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};
+
+ BOOL ret = FALSE;
+ connect_t *connect = request->connect;
+ session_t *session = connect->session;
+ WCHAR *req = NULL;
+ char *req_ascii;
+ int bytes_sent;
+ DWORD len;
+
+ clear_response_headers( request );
+ drain_content( request );
+
+ if (session->agent)
+ process_header( request, attr_user_agent, session->agent, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
+
+ if (connect->hostname)
+ add_host_header( request, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW );
+
+ if (request->creds[TARGET_SERVER][SCHEME_BASIC].username)
+ do_authorization( request, WINHTTP_AUTH_TARGET_SERVER, WINHTTP_AUTH_SCHEME_BASIC );
+
+ if (total_len || (request->verb && !strcmpW( request->verb, postW )))
+ {
+ WCHAR length[21]; /* decimal long int + null */
+ sprintfW( length, length_fmt, total_len );
+ process_header( request, attr_content_length, length, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
+ }
+ if (!(request->hdr.disable_flags & WINHTTP_DISABLE_KEEP_ALIVE))
+ {
+ process_header( request, attr_connection, keep_alive, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
+ }
+ if (request->hdr.flags & WINHTTP_FLAG_REFRESH)
+ {
+ process_header( request, attr_pragma, no_cache, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
+ process_header( request, attr_cache_control, no_cache, WINHTTP_ADDREQ_FLAG_ADD_IF_NEW, TRUE );
+ }
+ if (headers && !add_request_headers( request, headers, headers_len, WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE ))
+ {
+ 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 (context) request->hdr.context = context;
+
+ if (!(ret = open_connection( request ))) goto end;
+ if (!(req = build_request_string( request ))) goto end;
+
+ if (!(req_ascii = strdupWA( req ))) goto end;
+ TRACE("full request: %s\n", debugstr_a(req_ascii));
+ len = strlen(req_ascii);
+
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST, NULL, 0 );
+
+ ret = netconn_send( request->netconn, req_ascii, len, &bytes_sent );
+ heap_free( req_ascii );
+ if (!ret) goto end;
+
+ if (optional_len)
+ {
+ if (!netconn_send( request->netconn, optional, optional_len, &bytes_sent )) goto end;
+ request->optional = optional;
+ request->optional_len = optional_len;
+ len += optional_len;
+ }
+ send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REQUEST_SENT, &len, sizeof(len) );
+
+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 );
+}
+
+/***********************************************************************
+ * WinHttpSendRequest (winhttp.@)
+ */
+BOOL WINAPI WinHttpSendRequest( HINTERNET hrequest, LPCWSTR headers, DWORD headers_len,
+ LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context )
+{
+ BOOL ret;
+ request_t *request;
+
+ TRACE("%p, %s, %u, %u, %u, %lx\n", hrequest, debugstr_wn(headers, headers_len), headers_len, optional_len,
+ total_len, context);
+
+ if (!(request = (request_t *)grab_object( hrequest )))
+ {
+ set_last_error( ERROR_INVALID_HANDLE );
+ return FALSE;
}
- default:
- ERR("invalid scheme %u\n", scheme);
+ if (request->hdr.type != WINHTTP_HANDLE_TYPE_REQUEST)
+ {
+ release_object( &request->hdr );
+ set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
return FALSE;
}
- *auth_ptr = authinfo;
- len_scheme = auth_schemes[authinfo->scheme].len;
- len = len_scheme + 1 + ((authinfo->data_len + 2) * 4) / 3;
- if (!(auth_reply = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
+ if (headers && !headers_len) headers_len = strlenW( headers );
- memcpy( auth_reply, auth_schemes[authinfo->scheme].str, len_scheme * sizeof(WCHAR) );
- auth_reply[len_scheme] = ' ';
- encode_base64( authinfo->data, authinfo->data_len, auth_reply + len_scheme + 1 );
+ if (request->connect->hdr.flags & WINHTTP_FLAG_ASYNC)
+ {
+ send_request_t *s;
- flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE;
- ret = process_header( request, auth_target, auth_reply, flags, TRUE );
- heap_free( auth_reply );
+ 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 );
+ if (ret) set_last_error( ERROR_SUCCESS );
return ret;
}
return request->content_length;
}
-/* read some more data into the read buffer */
-static BOOL read_more_data( request_t *request, int maxlen, BOOL notify )
-{
- int len;
- BOOL ret;
-
- if (request->read_chunked_eof) return FALSE;
-
- if (request->read_size && request->read_pos)
- {
- /* move existing data to the start of the buffer */
- memmove( request->read_buf, request->read_buf + request->read_pos, request->read_size );
- request->read_pos = 0;
- }
- if (maxlen == -1) maxlen = sizeof(request->read_buf);
-
- if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NULL, 0 );
-
- ret = netconn_recv( &request->netconn, request->read_buf + request->read_size,
- maxlen - request->read_size, 0, &len );
-
- if (notify) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, &len, sizeof(len) );
-
- request->read_size += len;
- return ret;
-}
-
-/* remove some amount of data from the read buffer */
-static void remove_data( request_t *request, int count )
-{
- if (!(request->read_size -= count)) request->read_pos = 0;
- else request->read_pos += count;
-}
-
static BOOL read_line( request_t *request, char *buffer, DWORD *len )
{
int count, bytes_read, pos = 0;
return TRUE;
}
-/* discard data contents until we reach end of line */
-static BOOL discard_eol( request_t *request, BOOL notify )
-{
- do
- {
- char *eol = memchr( request->read_buf + request->read_pos, '\n', request->read_size );
- if (eol)
- {
- remove_data( request, (eol + 1) - (request->read_buf + request->read_pos) );
- break;
- }
- request->read_pos = request->read_size = 0; /* discard everything */
- if (!read_more_data( request, -1, notify )) return FALSE;
- } while (request->read_size);
- return TRUE;
-}
-
-/* read the size of the next chunk */
-static BOOL start_next_chunk( request_t *request, BOOL notify )
-{
- DWORD chunk_size = 0;
-
- assert(!request->read_chunked_size || request->read_chunked_size == ~0u);
-
- if (request->read_chunked_eof) return FALSE;
-
- /* read terminator for the previous chunk */
- if (!request->read_chunked_size && !discard_eol( request, notify )) return FALSE;
-
- for (;;)
- {
- while (request->read_size)
- {
- char ch = request->read_buf[request->read_pos];
- if (ch >= '0' && ch <= '9') chunk_size = chunk_size * 16 + ch - '0';
- else if (ch >= 'a' && ch <= 'f') chunk_size = chunk_size * 16 + ch - 'a' + 10;
- else if (ch >= 'A' && ch <= 'F') chunk_size = chunk_size * 16 + ch - 'A' + 10;
- else if (ch == ';' || ch == '\r' || ch == '\n')
- {
- TRACE("reading %u byte chunk\n", chunk_size);
-
- if (request->content_length == ~0u) request->content_length = chunk_size;
- else request->content_length += chunk_size;
-
- request->read_chunked_size = chunk_size;
- if (!chunk_size) request->read_chunked_eof = TRUE;
-
- return discard_eol( request, notify );
- }
- remove_data( request, 1 );
- }
- if (!read_more_data( request, -1, notify )) return FALSE;
- if (!request->read_size)
- {
- request->content_length = request->content_read = 0;
- request->read_chunked_size = 0;
- return TRUE;
- }
- }
-}
-
-/* return the size of data available to be read immediately */
-static DWORD get_available_data( request_t *request )
-{
- if (request->read_chunked) return min( request->read_chunked_size, request->read_size );
- return request->read_size;
-}
-
-/* check if we have reached the end of the data to read */
-static BOOL end_of_read_data( request_t *request )
-{
- if (!request->content_length) return TRUE;
- if (request->read_chunked) return request->read_chunked_eof;
- if (request->content_length == ~0u) return FALSE;
- return (request->content_length == request->content_read);
-}
-
-static BOOL refill_buffer( request_t *request, BOOL notify )
-{
- int len = sizeof(request->read_buf);
-
- if (request->read_chunked)
- {
- if (request->read_chunked_eof) return FALSE;
- if (request->read_chunked_size == ~0u || !request->read_chunked_size)
- {
- if (!start_next_chunk( request, notify )) return FALSE;
- }
- len = min( len, request->read_chunked_size );
- }
- else if (request->content_length != ~0u)
- {
- len = min( len, request->content_length - request->content_read );
- }
-
- if (len <= request->read_size) return TRUE;
- if (!read_more_data( request, len, notify )) return FALSE;
- if (!request->read_size) request->content_length = request->content_read = 0;
- return TRUE;
-}
-
#define MAX_REPLY_LEN 1460
#define INITIAL_HEADER_BUFFER_LEN 512
WCHAR *versionW, *status_textW, *raw_headers;
WCHAR status_codeW[4]; /* sizeof("nnn") */
- if (!netconn_connected( &request->netconn )) return FALSE;
+ if (!request->netconn) return FALSE;
do
{
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 );
-}
-
-static BOOL read_data( request_t *request, void *buffer, DWORD size, DWORD *read, BOOL async )
-{
- int count, bytes_read = 0;
-
- if (end_of_read_data( request )) goto done;
-
- while (size)
- {
- if (!(count = get_available_data( request )))
- {
- if (!refill_buffer( request, async )) goto done;
- if (!(count = get_available_data( request ))) goto done;
- }
- count = min( count, size );
- memcpy( (char *)buffer + bytes_read, request->read_buf + request->read_pos, count );
- remove_data( request, count );
- if (request->read_chunked) request->read_chunked_size -= count;
- size -= count;
- bytes_read += count;
- request->content_read += count;
- if (end_of_read_data( request )) goto done;
- }
- if (request->read_chunked && !request->read_chunked_size) refill_buffer( request, async );
-
-done:
- TRACE( "retrieved %u bytes (%u/%u)\n", bytes_read, request->content_read, request->content_length );
-
- if (async) send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, buffer, bytes_read );
- if (read) *read = bytes_read;
- if (end_of_read_data( request )) finished_reading( request );
- 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];
-
- refill_buffer( request, FALSE );
- for (;;)
- {
- if (!read_data( request, buffer, sizeof(buffer), &bytes_read, FALSE ) || !bytes_read) return;
- }
-}
-
static void record_cookies( request_t *request )
{
unsigned int i;
heap_free( request->path );
request->path = path;
- drain_content( request );
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_url + 1 );
}
else
request->hdr.flags |= WINHTTP_FLAG_SECURE;
}
- drain_content( request );
send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_REDIRECT, location, len_url + 1 );
len = uc.dwHostNameLength;
connect->hostport = port;
if (!(ret = set_server_for_hostname( connect, hostname, port ))) goto end;
- netconn_close( &request->netconn );
- if (!(ret = netconn_init( &request->netconn ))) goto end;
+ netconn_close( request->netconn );
+ request->netconn = NULL;
+ request->content_length = request->content_read = 0;
request->read_pos = request->read_size = 0;
- request->read_chunked = FALSE;
- request->read_chunked_eof = FALSE;
+ request->read_chunked = request->read_chunked_eof = FALSE;
}
else heap_free( hostname );
if (request->hdr.disable_flags & WINHTTP_DISABLE_AUTHENTICATION) break;
if (!handle_authorization( request, status )) break;
- drain_content( request );
/* recurse synchronously */
if ((ret = send_request( request, NULL, 0, request->optional, request->optional_len, 0, 0, FALSE ))) continue;
if (end_of_read_data( request )) goto done;
count = get_available_data( request );
- if (!request->read_chunked)
- count += netconn_query_data_available( &request->netconn );
+ if (!request->read_chunked && request->netconn)
+ count += netconn_query_data_available( request->netconn );
if (!count)
{
refill_buffer( request, async );
count = get_available_data( request );
- if (!request->read_chunked)
- count += netconn_query_data_available( &request->netconn );
+ if (!request->read_chunked && request->netconn)
+ count += netconn_query_data_available( request->netconn );
}
done:
BOOL ret;
int num_bytes;
- ret = netconn_send( &request->netconn, buffer, to_write, &num_bytes );
+ ret = netconn_send( request->netconn, buffer, to_write, &num_bytes );
if (async)
{
projects / reactos.git / blobdiff