dlls/winhttp/session.c

   1 /*
   2  * Copyright 2008 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21 #include "wine/debug.h"
  22
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winhttp.h"
  29 #include "wincrypt.h"
  30 #include "winreg.h"
  31
  32 #include "winhttp_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
  35
  36 #define DEFAULT_RESOLVE_TIMEOUT     0
  37 #define DEFAULT_CONNECT_TIMEOUT     20000
  38 #define DEFAULT_SEND_TIMEOUT        30000
  39 #define DEFAULT_RECEIVE_TIMEOUT     30000
  40
  41 void set_last_error( DWORD error )
  42 {
  43     /* FIXME */
  44     SetLastError( error );
  45 }
  46
  47 DWORD get_last_error( void )
  48 {
  49     /* FIXME */
  50     return GetLastError();
  51 }
  52
  53 void send_callback( object_header_t *hdr, DWORD status, LPVOID info, DWORD buflen )
  54 {
  55     TRACE("%p, 0x%08x, %p, %u\n", hdr, status, info, buflen);
  56
  57     if (hdr->callback && (hdr->notify_mask & status)) hdr->callback( hdr->handle, hdr->context, status, info, buflen );
  58 }
  59
  60 /***********************************************************************
  61  *          WinHttpCheckPlatform (winhttp.@)
  62  */
  63 BOOL WINAPI WinHttpCheckPlatform( void )
  64 {
  65     TRACE("\n");
  66     return TRUE;
  67 }
  68
  69 /***********************************************************************
  70  *          session_destroy (internal)
  71  */
  72 static void session_destroy( object_header_t *hdr )
  73 {
  74     session_t *session = (session_t *)hdr;
  75     struct list *item, *next;
  76     domain_t *domain;
  77
  78     TRACE("%p\n", session);
  79
  80     LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
  81     {
  82         domain = LIST_ENTRY( item, domain_t, entry );
  83         delete_domain( domain );
  84     }
  85     heap_free( session->agent );
  86     heap_free( session->proxy_server );
  87     heap_free( session->proxy_bypass );
  88     heap_free( session->proxy_username );
  89     heap_free( session->proxy_password );
  90     heap_free( session );
  91 }
  92
  93 static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
  94 {
  95     session_t *session = (session_t *)hdr;
  96
  97     switch (option)
  98     {
  99     case WINHTTP_OPTION_REDIRECT_POLICY:
 100     {
 101         if (!buffer || *buflen < sizeof(DWORD))
 102         {
 103             *buflen = sizeof(DWORD);
 104             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 105             return FALSE;
 106         }
 107
 108         *(DWORD *)buffer = hdr->redirect_policy;
 109         *buflen = sizeof(DWORD);
 110         return TRUE;
 111     }
 112     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 113         *(DWORD *)buffer = session->resolve_timeout;
 114         *buflen = sizeof(DWORD);
 115         return TRUE;
 116     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 117         *(DWORD *)buffer = session->connect_timeout;
 118         *buflen = sizeof(DWORD);
 119         return TRUE;
 120     case WINHTTP_OPTION_SEND_TIMEOUT:
 121         *(DWORD *)buffer = session->send_timeout;
 122         *buflen = sizeof(DWORD);
 123         return TRUE;
 124     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 125         *(DWORD *)buffer = session->recv_timeout;
 126         *buflen = sizeof(DWORD);
 127         return TRUE;
 128     default:
 129         FIXME("unimplemented option %u\n", option);
 130         set_last_error( ERROR_INVALID_PARAMETER );
 131         return FALSE;
 132     }
 133 }
 134
 135 static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 136 {
 137     session_t *session = (session_t *)hdr;
 138
 139     switch (option)
 140     {
 141     case WINHTTP_OPTION_PROXY:
 142     {
 143         WINHTTP_PROXY_INFO *pi = buffer;
 144
 145         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
 146         return TRUE;
 147     }
 148     case WINHTTP_OPTION_REDIRECT_POLICY:
 149     {
 150         DWORD policy;
 151
 152         if (buflen != sizeof(policy))
 153         {
 154             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 155             return FALSE;
 156         }
 157
 158         policy = *(DWORD *)buffer;
 159         TRACE("0x%x\n", policy);
 160         hdr->redirect_policy = policy;
 161         return TRUE;
 162     }
 163     case WINHTTP_OPTION_DISABLE_FEATURE:
 164         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 165         return FALSE;
 166     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 167         session->resolve_timeout = *(DWORD *)buffer;
 168         return TRUE;
 169     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 170         session->connect_timeout = *(DWORD *)buffer;
 171         return TRUE;
 172     case WINHTTP_OPTION_SEND_TIMEOUT:
 173         session->send_timeout = *(DWORD *)buffer;
 174         return TRUE;
 175     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 176         session->recv_timeout = *(DWORD *)buffer;
 177         return TRUE;
 178     default:
 179         FIXME("unimplemented option %u\n", option);
 180         set_last_error( ERROR_INVALID_PARAMETER );
 181         return FALSE;
 182     }
 183 }
 184
 185 static const object_vtbl_t session_vtbl =
 186 {
 187     session_destroy,
 188     session_query_option,
 189     session_set_option
 190 };
 191
 192 /***********************************************************************
 193  *          WinHttpOpen (winhttp.@)
 194  */
 195 HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags )
 196 {
 197     session_t *session;
 198     HINTERNET handle = NULL;
 199
 200     TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags);
 201
 202     if (!(session = heap_alloc_zero( sizeof(session_t) ))) return NULL;
 203
 204     session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
 205     session->hdr.vtbl = &session_vtbl;
 206     session->hdr.flags = flags;
 207     session->hdr.refs = 1;
 208     session->hdr.redirect_policy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
 209     session->resolve_timeout = DEFAULT_RESOLVE_TIMEOUT;
 210     session->connect_timeout = DEFAULT_CONNECT_TIMEOUT;
 211     session->send_timeout = DEFAULT_SEND_TIMEOUT;
 212     session->recv_timeout = DEFAULT_RECEIVE_TIMEOUT;
 213     list_init( &session->cookie_cache );
 214
 215     if (agent && !(session->agent = strdupW( agent ))) goto end;
 216     if (access == WINHTTP_ACCESS_TYPE_DEFAULT_PROXY)
 217     {
 218         WINHTTP_PROXY_INFO info;
 219
 220         WinHttpGetDefaultProxyConfiguration( &info );
 221         session->access = info.dwAccessType;
 222         if (info.lpszProxy && !(session->proxy_server = strdupW( info.lpszProxy )))
 223         {
 224             GlobalFree( (LPWSTR)info.lpszProxy );
 225             GlobalFree( (LPWSTR)info.lpszProxyBypass );
 226             goto end;
 227         }
 228         if (info.lpszProxyBypass && !(session->proxy_bypass = strdupW( info.lpszProxyBypass )))
 229         {
 230             GlobalFree( (LPWSTR)info.lpszProxy );
 231             GlobalFree( (LPWSTR)info.lpszProxyBypass );
 232             goto end;
 233         }
 234     }
 235     else if (access == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
 236     {
 237         session->access = access;
 238         if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
 239         if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end;
 240     }
 241
 242     if (!(handle = alloc_handle( &session->hdr ))) goto end;
 243     session->hdr.handle = handle;
 244
 245 end:
 246     release_object( &session->hdr );
 247     TRACE("returning %p\n", handle);
 248     return handle;
 249 }
 250
 251 /***********************************************************************
 252  *          connect_destroy (internal)
 253  */
 254 static void connect_destroy( object_header_t *hdr )
 255 {
 256     connect_t *connect = (connect_t *)hdr;
 257
 258     TRACE("%p\n", connect);
 259
 260     release_object( &connect->session->hdr );
 261
 262     heap_free( connect->hostname );
 263     heap_free( connect->servername );
 264     heap_free( connect->username );
 265     heap_free( connect->password );
 266     heap_free( connect );
 267 }
 268
 269 static BOOL connect_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 270 {
 271     connect_t *connect = (connect_t *)hdr;
 272
 273     switch (option)
 274     {
 275     case WINHTTP_OPTION_PARENT_HANDLE:
 276     {
 277         if (!buffer || *buflen < sizeof(HINTERNET))
 278         {
 279             *buflen = sizeof(HINTERNET);
 280             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 281             return FALSE;
 282         }
 283
 284         *(HINTERNET *)buffer = ((object_header_t *)connect->session)->handle;
 285         *buflen = sizeof(HINTERNET);
 286         return TRUE;
 287     }
 288     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 289         *(DWORD *)buffer = connect->session->resolve_timeout;
 290         *buflen = sizeof(DWORD);
 291         return TRUE;
 292     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 293         *(DWORD *)buffer = connect->session->connect_timeout;
 294         *buflen = sizeof(DWORD);
 295         return TRUE;
 296     case WINHTTP_OPTION_SEND_TIMEOUT:
 297         *(DWORD *)buffer = connect->session->send_timeout;
 298         *buflen = sizeof(DWORD);
 299         return TRUE;
 300     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 301         *(DWORD *)buffer = connect->session->recv_timeout;
 302         *buflen = sizeof(DWORD);
 303         return TRUE;
 304     default:
 305         FIXME("unimplemented option %u\n", option);
 306         set_last_error( ERROR_INVALID_PARAMETER );
 307         return FALSE;
 308     }
 309 }
 310
 311 static const object_vtbl_t connect_vtbl =
 312 {
 313     connect_destroy,
 314     connect_query_option,
 315     NULL
 316 };
 317
 318 static BOOL domain_matches(LPCWSTR server, LPCWSTR domain)
 319 {
 320     static const WCHAR localW[] = { '<','l','o','c','a','l','>',0 };
 321     BOOL ret = FALSE;
 322
 323     if (!strcmpiW( domain, localW ) && !strchrW( server, '.' ))
 324         ret = TRUE;
 325     else if (*domain == '*')
 326     {
 327         if (domain[1] == '.')
 328         {
 329             LPCWSTR dot;
 330
 331             /* For a hostname to match a wildcard, the last domain must match
 332              * the wildcard exactly.  E.g. if the wildcard is *.a.b, and the
 333              * hostname is www.foo.a.b, it matches, but a.b does not.
 334              */
 335             dot = strchrW( server, '.' );
 336             if (dot)
 337             {
 338                 int len = strlenW( dot + 1 );
 339
 340                 if (len > strlenW( domain + 2 ))
 341                 {
 342                     LPCWSTR ptr;
 343
 344                     /* The server's domain is longer than the wildcard, so it
 345                      * could be a subdomain.  Compare the last portion of the
 346                      * server's domain.
 347                      */
 348                     ptr = dot + len + 1 - strlenW( domain + 2 );
 349                     if (!strcmpiW( ptr, domain + 2 ))
 350                     {
 351                         /* This is only a match if the preceding character is
 352                          * a '.', i.e. that it is a matching domain.  E.g.
 353                          * if domain is '*.b.c' and server is 'www.ab.c' they
 354                          * do not match.
 355                          */
 356                         ret = *(ptr - 1) == '.';
 357                     }
 358                 }
 359                 else
 360                     ret = !strcmpiW( dot + 1, domain + 2 );
 361             }
 362         }
 363     }
 364     else
 365         ret = !strcmpiW( server, domain );
 366     return ret;
 367 }
 368
 369 /* Matches INTERNET_MAX_HOST_NAME_LENGTH in wininet.h, also RFC 1035 */
 370 #define MAX_HOST_NAME_LENGTH 256
 371
 372 static BOOL should_bypass_proxy(session_t *session, LPCWSTR server)
 373 {
 374     LPCWSTR ptr;
 375     BOOL ret = FALSE;
 376
 377     if (!session->proxy_bypass) return FALSE;
 378     ptr = session->proxy_bypass;
 379     do {
 380         LPCWSTR tmp = ptr;
 381
 382         ptr = strchrW( ptr, ';' );
 383         if (!ptr)
 384             ptr = strchrW( tmp, ' ' );
 385         if (ptr)
 386         {
 387             if (ptr - tmp < MAX_HOST_NAME_LENGTH)
 388             {
 389                 WCHAR domain[MAX_HOST_NAME_LENGTH];
 390
 391                 memcpy( domain, tmp, (ptr - tmp) * sizeof(WCHAR) );
 392                 domain[ptr - tmp] = 0;
 393                 ret = domain_matches( server, domain );
 394             }
 395             ptr += 1;
 396         }
 397         else if (*tmp)
 398             ret = domain_matches( server, tmp );
 399     } while (ptr && !ret);
 400     return ret;
 401 }
 402
 403 BOOL set_server_for_hostname( connect_t *connect, LPCWSTR server, INTERNET_PORT port )
 404 {
 405     session_t *session = connect->session;
 406     BOOL ret = TRUE;
 407
 408     if (session->proxy_server && !should_bypass_proxy(session, server))
 409     {
 410         LPCWSTR colon;
 411
 412         if ((colon = strchrW( session->proxy_server, ':' )))
 413         {
 414             if (!connect->servername || strncmpiW( connect->servername,
 415                 session->proxy_server, colon - session->proxy_server - 1 ))
 416             {
 417                 heap_free( connect->servername );
 418                 if (!(connect->servername = heap_alloc(
 419                     (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
 420                 {
 421                     ret = FALSE;
 422                     goto end;
 423                 }
 424                 memcpy( connect->servername, session->proxy_server,
 425                     (colon - session->proxy_server) * sizeof(WCHAR) );
 426                 connect->servername[colon - session->proxy_server] = 0;
 427                 if (*(colon + 1))
 428                     connect->serverport = atoiW( colon + 1 );
 429                 else
 430                     connect->serverport = INTERNET_DEFAULT_PORT;
 431             }
 432         }
 433         else
 434         {
 435             if (!connect->servername || strcmpiW( connect->servername,
 436                 session->proxy_server ))
 437             {
 438                 heap_free( connect->servername );
 439                 if (!(connect->servername = strdupW( session->proxy_server )))
 440                 {
 441                     ret = FALSE;
 442                     goto end;
 443                 }
 444                 connect->serverport = INTERNET_DEFAULT_PORT;
 445             }
 446         }
 447     }
 448     else if (server)
 449     {
 450         heap_free( connect->servername );
 451         if (!(connect->servername = strdupW( server )))
 452         {
 453             ret = FALSE;
 454             goto end;
 455         }
 456         connect->serverport = port;
 457     }
 458 end:
 459     return ret;
 460 }
 461
 462 /***********************************************************************
 463  *          WinHttpConnect (winhttp.@)
 464  */
 465 HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved )
 466 {
 467     connect_t *connect;
 468     session_t *session;
 469     HINTERNET hconnect = NULL;
 470
 471     TRACE("%p, %s, %u, %x\n", hsession, debugstr_w(server), port, reserved);
 472
 473     if (!server)
 474     {
 475         set_last_error( ERROR_INVALID_PARAMETER );
 476         return NULL;
 477     }
 478     if (!(session = (session_t *)grab_object( hsession )))
 479     {
 480         set_last_error( ERROR_INVALID_HANDLE );
 481         return NULL;
 482     }
 483     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
 484     {
 485         release_object( &session->hdr );
 486         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 487         return NULL;
 488     }
 489     if (!(connect = heap_alloc_zero( sizeof(connect_t) )))
 490     {
 491         release_object( &session->hdr );
 492         return NULL;
 493     }
 494     connect->hdr.type = WINHTTP_HANDLE_TYPE_CONNECT;
 495     connect->hdr.vtbl = &connect_vtbl;
 496     connect->hdr.refs = 1;
 497     connect->hdr.flags = session->hdr.flags;
 498     connect->hdr.callback = session->hdr.callback;
 499     connect->hdr.notify_mask = session->hdr.notify_mask;
 500     connect->hdr.context = session->hdr.context;
 501
 502     addref_object( &session->hdr );
 503     connect->session = session;
 504     list_add_head( &session->hdr.children, &connect->hdr.entry );
 505
 506     if (!(connect->hostname = strdupW( server ))) goto end;
 507     connect->hostport = port;
 508
 509     if (!set_server_for_hostname( connect, server, port ))
 510         goto end;
 511
 512     if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
 513     connect->hdr.handle = hconnect;
 514
 515     send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
 516
 517 end:
 518     release_object( &connect->hdr );
 519
 520     TRACE("returning %p\n", hconnect);
 521     return hconnect;
 522 }
 523
 524 /***********************************************************************
 525  *          request_destroy (internal)
 526  */
 527 static void request_destroy( object_header_t *hdr )
 528 {
 529     request_t *request = (request_t *)hdr;
 530     DWORD i;
 531
 532     TRACE("%p\n", request);
 533
 534     release_object( &request->connect->hdr );
 535
 536     heap_free( request->verb );
 537     heap_free( request->path );
 538     heap_free( request->version );
 539     heap_free( request->raw_headers );
 540     heap_free( request->status_text );
 541     for (i = 0; i < request->num_headers; i++)
 542     {
 543         heap_free( request->headers[i].field );
 544         heap_free( request->headers[i].value );
 545     }
 546     heap_free( request->headers );
 547     heap_free( request );
 548 }
 549
 550 static void str_to_buffer( WCHAR *buffer, const WCHAR *str, LPDWORD buflen )
 551 {
 552     int len = 0;
 553     if (str) len = strlenW( str );
 554     if (buffer && *buflen > len)
 555     {
 556         memcpy( buffer, str, len * sizeof(WCHAR) );
 557         buffer[len] = 0;
 558     }
 559     *buflen = len * sizeof(WCHAR);
 560 }
 561
 562 static WCHAR *blob_to_str( DWORD encoding, CERT_NAME_BLOB *blob )
 563 {
 564     WCHAR *ret;
 565     DWORD size, format = CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG;
 566
 567     size = CertNameToStrW( encoding, blob, format, NULL, 0 );
 568     if ((ret = LocalAlloc( 0, size * sizeof(WCHAR) )))
 569         CertNameToStrW( encoding, blob, format, ret, size );
 570
 571     return ret;
 572 }
 573
 574 static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 575 {
 576     request_t *request = (request_t *)hdr;
 577
 578     switch (option)
 579     {
 580     case WINHTTP_OPTION_SECURITY_FLAGS:
 581     {
 582         DWORD flags;
 583         int bits;
 584
 585         if (!buffer || *buflen < sizeof(flags))
 586         {
 587             *buflen = sizeof(flags);
 588             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 589             return FALSE;
 590         }
 591
 592         flags = 0;
 593         if (hdr->flags & WINHTTP_FLAG_SECURE) flags |= SECURITY_FLAG_SECURE;
 594         flags |= request->netconn.security_flags;
 595         bits = netconn_get_cipher_strength( &request->netconn );
 596         if (bits >= 128)
 597             flags |= SECURITY_FLAG_STRENGTH_STRONG;
 598         else if (bits >= 56)
 599             flags |= SECURITY_FLAG_STRENGTH_MEDIUM;
 600         else
 601             flags |= SECURITY_FLAG_STRENGTH_WEAK;
 602         *(DWORD *)buffer = flags;
 603         *buflen = sizeof(flags);
 604         return TRUE;
 605     }
 606     case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
 607     {
 608         const CERT_CONTEXT *cert;
 609
 610         if (!buffer || *buflen < sizeof(cert))
 611         {
 612             *buflen = sizeof(cert);
 613             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 614             return FALSE;
 615         }
 616
 617         if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
 618         *(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
 619         *buflen = sizeof(cert);
 620         return TRUE;
 621     }
 622     case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT:
 623     {
 624         const CERT_CONTEXT *cert;
 625         const CRYPT_OID_INFO *oidInfo;
 626         WINHTTP_CERTIFICATE_INFO *ci = buffer;
 627
 628         FIXME("partial stub\n");
 629
 630         if (!buffer || *buflen < sizeof(*ci))
 631         {
 632             *buflen = sizeof(*ci);
 633             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 634             return FALSE;
 635         }
 636         if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
 637
 638         ci->ftExpiry = cert->pCertInfo->NotAfter;
 639         ci->ftStart  = cert->pCertInfo->NotBefore;
 640         ci->lpszSubjectInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Subject );
 641         ci->lpszIssuerInfo  = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Issuer );
 642         ci->lpszProtocolName      = NULL;
 643         oidInfo = CryptFindOIDInfo( CRYPT_OID_INFO_OID_KEY,
 644                                     cert->pCertInfo->SignatureAlgorithm.pszObjId,
 645                                     0 );
 646         if (oidInfo)
 647             ci->lpszSignatureAlgName = (LPWSTR)oidInfo->pwszName;
 648         else
 649             ci->lpszSignatureAlgName  = NULL;
 650         ci->lpszEncryptionAlgName = NULL;
 651         ci->dwKeySize = netconn_get_cipher_strength( &request->netconn );
 652
 653         CertFreeCertificateContext( cert );
 654         *buflen = sizeof(*ci);
 655         return TRUE;
 656     }
 657     case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
 658     {
 659         if (!buffer || *buflen < sizeof(DWORD))
 660         {
 661             *buflen = sizeof(DWORD);
 662             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 663             return FALSE;
 664         }
 665
 666         *(DWORD *)buffer = netconn_get_cipher_strength( &request->netconn );
 667         *buflen = sizeof(DWORD);
 668         return TRUE;
 669     }
 670     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 671         *(DWORD *)buffer = request->resolve_timeout;
 672         *buflen = sizeof(DWORD);
 673         return TRUE;
 674     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 675         *(DWORD *)buffer = request->connect_timeout;
 676         *buflen = sizeof(DWORD);
 677         return TRUE;
 678     case WINHTTP_OPTION_SEND_TIMEOUT:
 679         *(DWORD *)buffer = request->send_timeout;
 680         *buflen = sizeof(DWORD);
 681         return TRUE;
 682     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 683         *(DWORD *)buffer = request->recv_timeout;
 684         *buflen = sizeof(DWORD);
 685         return TRUE;
 686
 687     case WINHTTP_OPTION_USERNAME:
 688         str_to_buffer( buffer, request->connect->username, buflen );
 689         return TRUE;
 690
 691     case WINHTTP_OPTION_PASSWORD:
 692         str_to_buffer( buffer, request->connect->password, buflen );
 693         return TRUE;
 694
 695     case WINHTTP_OPTION_PROXY_USERNAME:
 696         str_to_buffer( buffer, request->connect->session->proxy_username, buflen );
 697         return TRUE;
 698
 699     case WINHTTP_OPTION_PROXY_PASSWORD:
 700         str_to_buffer( buffer, request->connect->session->proxy_password, buflen );
 701         return TRUE;
 702
 703     default:
 704         FIXME("unimplemented option %u\n", option);
 705         set_last_error( ERROR_INVALID_PARAMETER );
 706         return FALSE;
 707     }
 708 }
 709
 710 static WCHAR *buffer_to_str( WCHAR *buffer, DWORD buflen )
 711 {
 712     WCHAR *ret;
 713     if ((ret = heap_alloc( (buflen + 1) * sizeof(WCHAR))))
 714     {
 715         memcpy( ret, buffer, buflen * sizeof(WCHAR) );
 716         ret[buflen] = 0;
 717         return ret;
 718     }
 719     set_last_error( ERROR_OUTOFMEMORY );
 720     return NULL;
 721 }
 722
 723 static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 724 {
 725     request_t *request = (request_t *)hdr;
 726
 727     switch (option)
 728     {
 729     case WINHTTP_OPTION_PROXY:
 730     {
 731         WINHTTP_PROXY_INFO *pi = buffer;
 732
 733         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
 734         return TRUE;
 735     }
 736     case WINHTTP_OPTION_DISABLE_FEATURE:
 737     {
 738         DWORD disable;
 739
 740         if (buflen != sizeof(DWORD))
 741         {
 742             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 743             return FALSE;
 744         }
 745
 746         disable = *(DWORD *)buffer;
 747         TRACE("0x%x\n", disable);
 748         hdr->disable_flags |= disable;
 749         return TRUE;
 750     }
 751     case WINHTTP_OPTION_AUTOLOGON_POLICY:
 752     {
 753         DWORD policy;
 754
 755         if (buflen != sizeof(DWORD))
 756         {
 757             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 758             return FALSE;
 759         }
 760
 761         policy = *(DWORD *)buffer;
 762         TRACE("0x%x\n", policy);
 763         hdr->logon_policy = policy;
 764         return TRUE;
 765     }
 766     case WINHTTP_OPTION_REDIRECT_POLICY:
 767     {
 768         DWORD policy;
 769
 770         if (buflen != sizeof(DWORD))
 771         {
 772             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 773             return FALSE;
 774         }
 775
 776         policy = *(DWORD *)buffer;
 777         TRACE("0x%x\n", policy);
 778         hdr->redirect_policy = policy;
 779         return TRUE;
 780     }
 781     case WINHTTP_OPTION_SECURITY_FLAGS:
 782     {
 783         DWORD flags;
 784
 785         if (buflen < sizeof(DWORD))
 786         {
 787             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 788             return FALSE;
 789         }
 790         flags = *(DWORD *)buffer;
 791         TRACE("0x%x\n", flags);
 792         if (!(flags & (SECURITY_FLAG_IGNORE_CERT_CN_INVALID   |
 793                        SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
 794                        SECURITY_FLAG_IGNORE_UNKNOWN_CA        |
 795                        SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE)))
 796         {
 797             set_last_error( ERROR_INVALID_PARAMETER );
 798             return FALSE;
 799         }
 800         request->netconn.security_flags = flags;
 801         return TRUE;
 802     }
 803     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 804         request->resolve_timeout = *(DWORD *)buffer;
 805         return TRUE;
 806     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 807         request->connect_timeout = *(DWORD *)buffer;
 808         return TRUE;
 809     case WINHTTP_OPTION_SEND_TIMEOUT:
 810         request->send_timeout = *(DWORD *)buffer;
 811         return TRUE;
 812     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 813         request->recv_timeout = *(DWORD *)buffer;
 814         return TRUE;
 815
 816     case WINHTTP_OPTION_USERNAME:
 817     {
 818         connect_t *connect = request->connect;
 819
 820         heap_free( connect->username );
 821         if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE;
 822         return TRUE;
 823     }
 824     case WINHTTP_OPTION_PASSWORD:
 825     {
 826         connect_t *connect = request->connect;
 827
 828         heap_free( connect->password );
 829         if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE;
 830         return TRUE;
 831     }
 832     case WINHTTP_OPTION_PROXY_USERNAME:
 833     {
 834         session_t *session = request->connect->session;
 835
 836         heap_free( session->proxy_username );
 837         if (!(session->proxy_username = buffer_to_str( buffer, buflen ))) return FALSE;
 838         return TRUE;
 839     }
 840     case WINHTTP_OPTION_PROXY_PASSWORD:
 841     {
 842         session_t *session = request->connect->session;
 843
 844         heap_free( session->proxy_password );
 845         if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE;
 846         return TRUE;
 847     }
 848     default:
 849         FIXME("unimplemented option %u\n", option);
 850         set_last_error( ERROR_INVALID_PARAMETER );
 851         return TRUE;
 852     }
 853 }
 854
 855 static const object_vtbl_t request_vtbl =
 856 {
 857     request_destroy,
 858     request_query_option,
 859     request_set_option
 860 };
 861
 862 /***********************************************************************
 863  *          WinHttpOpenRequest (winhttp.@)
 864  */
 865 HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version,
 866                                      LPCWSTR referrer, LPCWSTR *types, DWORD flags )
 867 {
 868     request_t *request;
 869     connect_t *connect;
 870     HINTERNET hrequest = NULL;
 871
 872     TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect, debugstr_w(verb), debugstr_w(object),
 873           debugstr_w(version), debugstr_w(referrer), types, flags);
 874
 875     if (!(connect = (connect_t *)grab_object( hconnect )))
 876     {
 877         set_last_error( ERROR_INVALID_HANDLE );
 878         return NULL;
 879     }
 880     if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
 881     {
 882         release_object( &connect->hdr );
 883         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 884         return NULL;
 885     }
 886     if (!(request = heap_alloc_zero( sizeof(request_t) )))
 887     {
 888         release_object( &connect->hdr );
 889         return NULL;
 890     }
 891     request->hdr.type = WINHTTP_HANDLE_TYPE_REQUEST;
 892     request->hdr.vtbl = &request_vtbl;
 893     request->hdr.refs = 1;
 894     request->hdr.flags = flags;
 895     request->hdr.callback = connect->hdr.callback;
 896     request->hdr.notify_mask = connect->hdr.notify_mask;
 897     request->hdr.context = connect->hdr.context;
 898
 899     addref_object( &connect->hdr );
 900     request->connect = connect;
 901     list_add_head( &connect->hdr.children, &request->hdr.entry );
 902
 903     if (!netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE )) goto end;
 904     request->resolve_timeout = connect->session->resolve_timeout;
 905     request->connect_timeout = connect->session->connect_timeout;
 906     request->send_timeout = connect->session->send_timeout;
 907     request->recv_timeout = connect->session->recv_timeout;
 908
 909     if (!verb || !verb[0]) verb = getW;
 910     if (!(request->verb = strdupW( verb ))) goto end;
 911
 912     if (object)
 913     {
 914         WCHAR *path, *p;
 915         unsigned int len;
 916
 917         len = strlenW( object ) + 1;
 918         if (object[0] != '/') len++;
 919         if (!(p = path = heap_alloc( len * sizeof(WCHAR) ))) goto end;
 920
 921         if (object[0] != '/') *p++ = '/';
 922         strcpyW( p, object );
 923         request->path = path;
 924     }
 925     else if (!(request->path = strdupW( slashW ))) goto end;
 926
 927     if (!version || !version[0]) version = http1_1;
 928     if (!(request->version = strdupW( version ))) goto end;
 929
 930     if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
 931     request->hdr.handle = hrequest;
 932
 933     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
 934
 935 end:
 936     release_object( &request->hdr );
 937
 938     TRACE("returning %p\n", hrequest);
 939     return hrequest;
 940 }
 941
 942 /***********************************************************************
 943  *          WinHttpCloseHandle (winhttp.@)
 944  */
 945 BOOL WINAPI WinHttpCloseHandle( HINTERNET handle )
 946 {
 947     object_header_t *hdr;
 948
 949     TRACE("%p\n", handle);
 950
 951     if (!(hdr = grab_object( handle )))
 952     {
 953         set_last_error( ERROR_INVALID_HANDLE );
 954         return FALSE;
 955     }
 956     release_object( hdr );
 957     free_handle( handle );
 958     return TRUE;
 959 }
 960
 961 static BOOL query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 962 {
 963     BOOL ret = FALSE;
 964
 965     if (!buflen)
 966     {
 967         set_last_error( ERROR_INVALID_PARAMETER );
 968         return FALSE;
 969     }
 970
 971     switch (option)
 972     {
 973     case WINHTTP_OPTION_CONTEXT_VALUE:
 974     {
 975         if (!buffer || *buflen < sizeof(DWORD_PTR))
 976         {
 977             *buflen = sizeof(DWORD_PTR);
 978             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 979             return FALSE;
 980         }
 981
 982         *(DWORD_PTR *)buffer = hdr->context;
 983         *buflen = sizeof(DWORD_PTR);
 984         return TRUE;
 985     }
 986     default:
 987         if (hdr->vtbl->query_option) ret = hdr->vtbl->query_option( hdr, option, buffer, buflen );
 988         else
 989         {
 990             FIXME("unimplemented option %u\n", option);
 991             set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 992             return FALSE;
 993         }
 994         break;
 995     }
 996     return ret;
 997 }
 998
 999 /***********************************************************************
1000  *          WinHttpQueryOption (winhttp.@)
1001  */
1002 BOOL WINAPI WinHttpQueryOption( HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen )
1003 {
1004     BOOL ret = FALSE;
1005     object_header_t *hdr;
1006
1007     TRACE("%p, %u, %p, %p\n", handle, option, buffer, buflen);
1008
1009     if (!(hdr = grab_object( handle )))
1010     {
1011         set_last_error( ERROR_INVALID_HANDLE );
1012         return FALSE;
1013     }
1014
1015     ret = query_option( hdr, option, buffer, buflen );
1016
1017     release_object( hdr );
1018     return ret;
1019 }
1020
1021 static BOOL set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
1022 {
1023     BOOL ret = TRUE;
1024
1025     if (!buffer)
1026     {
1027         set_last_error( ERROR_INVALID_PARAMETER );
1028         return FALSE;
1029     }
1030
1031     switch (option)
1032     {
1033     case WINHTTP_OPTION_CONTEXT_VALUE:
1034     {
1035         if (buflen != sizeof(DWORD_PTR))
1036         {
1037             set_last_error( ERROR_INSUFFICIENT_BUFFER );
1038             return FALSE;
1039         }
1040
1041         hdr->context = *(DWORD_PTR *)buffer;
1042         return TRUE;
1043     }
1044     default:
1045         if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option, buffer, buflen );
1046         else
1047         {
1048             FIXME("unimplemented option %u\n", option);
1049             set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1050             return FALSE;
1051         }
1052         break;
1053     }
1054     return ret;
1055 }
1056
1057 /***********************************************************************
1058  *          WinHttpSetOption (winhttp.@)
1059  */
1060 BOOL WINAPI WinHttpSetOption( HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen )
1061 {
1062     BOOL ret = FALSE;
1063     object_header_t *hdr;
1064
1065     TRACE("%p, %u, %p, %u\n", handle, option, buffer, buflen);
1066
1067     if (!(hdr = grab_object( handle )))
1068     {
1069         set_last_error( ERROR_INVALID_HANDLE );
1070         return FALSE;
1071     }
1072
1073     ret = set_option( hdr, option, buffer, buflen );
1074
1075     release_object( hdr );
1076     return ret;
1077 }
1078
1079 /***********************************************************************
1080  *          WinHttpDetectAutoProxyConfigUrl (winhttp.@)
1081  */
1082 BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url )
1083 {
1084     FIXME("0x%08x, %p\n", flags, url);
1085
1086     set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED );
1087     return FALSE;
1088 }
1089
1090 static const WCHAR Connections[] = {
1091     'S','o','f','t','w','a','r','e','\\',
1092     'M','i','c','r','o','s','o','f','t','\\',
1093     'W','i','n','d','o','w','s','\\',
1094     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1095     'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
1096     'C','o','n','n','e','c','t','i','o','n','s',0 };
1097 static const WCHAR WinHttpSettings[] = {
1098     'W','i','n','H','t','t','p','S','e','t','t','i','n','g','s',0 };
1099 static const DWORD WINHTTPSETTINGS_MAGIC = 0x18;
1100 static const DWORD WINHTTP_PROXY_TYPE_DIRECT = 1;
1101 static const DWORD WINHTTP_PROXY_TYPE_PROXY = 2;
1102
1103 struct winhttp_settings_header
1104 {
1105     DWORD magic;
1106     DWORD unknown; /* always zero? */
1107     DWORD flags;   /* one of WINHTTP_PROXY_TYPE_* */
1108 };
1109
1110 static inline void copy_char_to_wchar_sz(const BYTE *src, DWORD len, WCHAR *dst)
1111 {
1112     const BYTE *begin;
1113
1114     for (begin = src; src - begin < len; src++, dst++)
1115         *dst = *src;
1116     *dst = 0;
1117 }
1118
1119 /***********************************************************************
1120  *          WinHttpGetDefaultProxyConfiguration (winhttp.@)
1121  */
1122 BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
1123 {
1124     LONG l;
1125     HKEY key;
1126     BOOL got_from_reg = FALSE, direct = TRUE;
1127     char *envproxy;
1128
1129     TRACE("%p\n", info);
1130
1131     l = RegOpenKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, KEY_READ, &key );
1132     if (!l)
1133     {
1134         DWORD type, size = 0;
1135
1136         l = RegQueryValueExW( key, WinHttpSettings, NULL, &type, NULL, &size );
1137         if (!l && type == REG_BINARY &&
1138             size >= sizeof(struct winhttp_settings_header) + 2 * sizeof(DWORD))
1139         {
1140             BYTE *buf = heap_alloc( size );
1141
1142             if (buf)
1143             {
1144                 struct winhttp_settings_header *hdr =
1145                     (struct winhttp_settings_header *)buf;
1146                 DWORD *len = (DWORD *)(hdr + 1);
1147
1148                 l = RegQueryValueExW( key, WinHttpSettings, NULL, NULL, buf,
1149                     &size );
1150                 if (!l && hdr->magic == WINHTTPSETTINGS_MAGIC &&
1151                     hdr->unknown == 0)
1152                 {
1153                     if (hdr->flags & WINHTTP_PROXY_TYPE_PROXY)
1154                     {
1155                        BOOL sane = FALSE;
1156                        LPWSTR proxy = NULL;
1157                        LPWSTR proxy_bypass = NULL;
1158
1159                         /* Sanity-check length of proxy string */
1160                         if ((BYTE *)len - buf + *len <= size)
1161                         {
1162                             sane = TRUE;
1163                             proxy = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
1164                             if (proxy)
1165                                 copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy );
1166                             len = (DWORD *)((BYTE *)(len + 1) + *len);
1167                         }
1168                         if (sane)
1169                         {
1170                             /* Sanity-check length of proxy bypass string */
1171                             if ((BYTE *)len - buf + *len <= size)
1172                             {
1173                                 proxy_bypass = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
1174                                 if (proxy_bypass)
1175                                     copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy_bypass );
1176                             }
1177                             else
1178                             {
1179                                 sane = FALSE;
1180                                 GlobalFree( proxy );
1181                                 proxy = NULL;
1182                             }
1183                         }
1184                         info->lpszProxy = proxy;
1185                         info->lpszProxyBypass = proxy_bypass;
1186                         if (sane)
1187                         {
1188                             got_from_reg = TRUE;
1189                             direct = FALSE;
1190                             info->dwAccessType =
1191                                 WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1192                             TRACE("http proxy (from registry) = %s, bypass = %s\n",
1193                                 debugstr_w(info->lpszProxy),
1194                                 debugstr_w(info->lpszProxyBypass));
1195                         }
1196                     }
1197                 }
1198                 heap_free( buf );
1199             }
1200         }
1201         RegCloseKey( key );
1202     }
1203     if (!got_from_reg && (envproxy = getenv( "http_proxy" )))
1204     {
1205         char *colon, *http_proxy;
1206
1207         if ((colon = strchr( envproxy, ':' )))
1208         {
1209             if (*(colon + 1) == '/' && *(colon + 2) == '/')
1210             {
1211                 static const char http[] = "http://";
1212
1213                 /* It's a scheme, check that it's http */
1214                 if (!strncmp( envproxy, http, strlen( http ) ))
1215                     http_proxy = envproxy + strlen( http );
1216                 else
1217                 {
1218                     WARN("unsupported scheme in $http_proxy: %s\n", envproxy);
1219                     http_proxy = NULL;
1220                 }
1221             }
1222             else
1223                 http_proxy = envproxy;
1224         }
1225         else
1226             http_proxy = envproxy;
1227         if (http_proxy)
1228         {
1229             WCHAR *http_proxyW;
1230             int len;
1231
1232             len = MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, NULL, 0 );
1233             if ((http_proxyW = GlobalAlloc( 0, len * sizeof(WCHAR))))
1234             {
1235                 MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, http_proxyW, len );
1236                 direct = FALSE;
1237                 info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1238                 info->lpszProxy = http_proxyW;
1239                 info->lpszProxyBypass = NULL;
1240                 TRACE("http proxy (from environment) = %s\n",
1241                     debugstr_w(info->lpszProxy));
1242             }
1243         }
1244     }
1245     if (direct)
1246     {
1247         info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
1248         info->lpszProxy       = NULL;
1249         info->lpszProxyBypass = NULL;
1250     }
1251     return TRUE;
1252 }
1253
1254 /***********************************************************************
1255  *          WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
1256  */
1257 BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config )
1258 {
1259     TRACE("%p\n", config);
1260
1261     if (!config)
1262     {
1263         set_last_error( ERROR_INVALID_PARAMETER );
1264         return FALSE;
1265     }
1266
1267     /* FIXME: read from HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings */
1268
1269     FIXME("returning no proxy used\n");
1270     config->fAutoDetect       = FALSE;
1271     config->lpszAutoConfigUrl = NULL;
1272     config->lpszProxy         = NULL;
1273     config->lpszProxyBypass   = NULL;
1274
1275     return TRUE;
1276 }
1277
1278 /***********************************************************************
1279  *          WinHttpGetProxyForUrl (winhttp.@)
1280  */
1281 BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
1282                                    WINHTTP_PROXY_INFO *info )
1283 {
1284     FIXME("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
1285
1286     set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR );
1287     return FALSE;
1288 }
1289
1290 /***********************************************************************
1291  *          WinHttpSetDefaultProxyConfiguration (winhttp.@)
1292  */
1293 BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
1294 {
1295     LONG l;
1296     HKEY key;
1297     BOOL ret = FALSE;
1298     const WCHAR *src;
1299
1300     TRACE("%p\n", info);
1301
1302     if (!info)
1303     {
1304         set_last_error( ERROR_INVALID_PARAMETER );
1305         return FALSE;
1306     }
1307     switch (info->dwAccessType)
1308     {
1309     case WINHTTP_ACCESS_TYPE_NO_PROXY:
1310         break;
1311     case WINHTTP_ACCESS_TYPE_NAMED_PROXY:
1312         if (!info->lpszProxy)
1313         {
1314             set_last_error( ERROR_INVALID_PARAMETER );
1315             return FALSE;
1316         }
1317         /* Only ASCII characters are allowed */
1318         for (src = info->lpszProxy; *src; src++)
1319             if (*src > 0x7f)
1320             {
1321                 set_last_error( ERROR_INVALID_PARAMETER );
1322                 return FALSE;
1323             }
1324         if (info->lpszProxyBypass)
1325         {
1326             for (src = info->lpszProxyBypass; *src; src++)
1327                 if (*src > 0x7f)
1328                 {
1329                     set_last_error( ERROR_INVALID_PARAMETER );
1330                     return FALSE;
1331                 }
1332         }
1333         break;
1334     default:
1335         set_last_error( ERROR_INVALID_PARAMETER );
1336         return FALSE;
1337     }
1338
1339     l = RegCreateKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, NULL, 0,
1340         KEY_WRITE, NULL, &key, NULL );
1341     if (!l)
1342     {
1343         DWORD size = sizeof(struct winhttp_settings_header) + 2 * sizeof(DWORD);
1344         BYTE *buf;
1345
1346         if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
1347         {
1348             size += strlenW( info->lpszProxy );
1349             if (info->lpszProxyBypass)
1350                 size += strlenW( info->lpszProxyBypass );
1351         }
1352         buf = heap_alloc( size );
1353         if (buf)
1354         {
1355             struct winhttp_settings_header *hdr =
1356                 (struct winhttp_settings_header *)buf;
1357             DWORD *len = (DWORD *)(hdr + 1);
1358
1359             hdr->magic = WINHTTPSETTINGS_MAGIC;
1360             hdr->unknown = 0;
1361             if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
1362             {
1363                 BYTE *dst;
1364
1365                 hdr->flags = WINHTTP_PROXY_TYPE_PROXY;
1366                 *len++ = strlenW( info->lpszProxy );
1367                 for (dst = (BYTE *)len, src = info->lpszProxy; *src;
1368                     src++, dst++)
1369                     *dst = *src;
1370                 len = (DWORD *)dst;
1371                 if (info->lpszProxyBypass)
1372                 {
1373                     *len++ = strlenW( info->lpszProxyBypass );
1374                     for (dst = (BYTE *)len, src = info->lpszProxyBypass; *src;
1375                         src++, dst++)
1376                         *dst = *src;
1377                 }
1378                 else
1379                     *len++ = 0;
1380             }
1381             else
1382             {
1383                 hdr->flags = WINHTTP_PROXY_TYPE_DIRECT;
1384                 *len++ = 0;
1385                 *len++ = 0;
1386             }
1387             l = RegSetValueExW( key, WinHttpSettings, 0, REG_BINARY, buf, size );
1388             if (!l)
1389                 ret = TRUE;
1390             heap_free( buf );
1391         }
1392         RegCloseKey( key );
1393     }
1394     return ret;
1395 }
1396
1397 /***********************************************************************
1398  *          WinHttpSetStatusCallback (winhttp.@)
1399  */
1400 WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHTTP_STATUS_CALLBACK callback,
1401                                                          DWORD flags, DWORD_PTR reserved )
1402 {
1403     object_header_t *hdr;
1404     WINHTTP_STATUS_CALLBACK ret;
1405
1406     TRACE("%p, %p, 0x%08x, 0x%lx\n", handle, callback, flags, reserved);
1407
1408     if (!(hdr = grab_object( handle )))
1409     {
1410         set_last_error( ERROR_INVALID_HANDLE );
1411         return WINHTTP_INVALID_STATUS_CALLBACK;
1412     }
1413     ret = hdr->callback;
1414     hdr->callback = callback;
1415     hdr->notify_mask = flags;
1416
1417     release_object( hdr );
1418     return ret;
1419 }
1420
1421 /***********************************************************************
1422  *          WinHttpSetTimeouts (winhttp.@)
1423  */
1424 BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive )
1425 {
1426     BOOL ret = TRUE;
1427     object_header_t *hdr;
1428     request_t *request;
1429     session_t *session;
1430
1431     TRACE("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive);
1432
1433     if (resolve < -1 || connect < -1 || send < -1 || receive < -1)
1434     {
1435         set_last_error( ERROR_INVALID_PARAMETER );
1436         return FALSE;
1437     }
1438
1439     if (!(hdr = grab_object( handle )))
1440     {
1441         set_last_error( ERROR_INVALID_HANDLE );
1442         return FALSE;
1443     }
1444
1445     switch(hdr->type)
1446     {
1447         case WINHTTP_HANDLE_TYPE_REQUEST:
1448             request = (request_t *)hdr;
1449             request->connect_timeout = connect;
1450
1451             if (resolve < 0) resolve = 0;
1452             request->resolve_timeout = resolve;
1453
1454             if (send < 0) send = 0;
1455             request->send_timeout = send;
1456
1457             if (receive < 0) receive = 0;
1458             request->recv_timeout = receive;
1459
1460             if (netconn_connected( &request->netconn ))
1461             {
1462                 if (netconn_set_timeout( &request->netconn, TRUE, send )) ret = FALSE;
1463                 if (netconn_set_timeout( &request->netconn, FALSE, receive )) ret = FALSE;
1464             }
1465
1466             release_object( &request->hdr );
1467             break;
1468
1469         case WINHTTP_HANDLE_TYPE_SESSION:
1470             session = (session_t *)hdr;
1471             session->connect_timeout = connect;
1472
1473             if (resolve < 0) resolve = 0;
1474             session->resolve_timeout = resolve;
1475
1476             if (send < 0) send = 0;
1477             session->send_timeout = send;
1478
1479             if (receive < 0) receive = 0;
1480             session->recv_timeout = receive;
1481             break;
1482
1483         default:
1484             release_object( hdr );
1485             set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1486             return FALSE;
1487     }
1488     return ret;
1489 }
1490
1491 static const WCHAR wkday[7][4] =
1492     {{'S','u','n', 0}, {'M','o','n', 0}, {'T','u','e', 0}, {'W','e','d', 0},
1493      {'T','h','u', 0}, {'F','r','i', 0}, {'S','a','t', 0}};
1494 static const WCHAR month[12][4] =
1495     {{'J','a','n', 0}, {'F','e','b', 0}, {'M','a','r', 0}, {'A','p','r', 0},
1496      {'M','a','y', 0}, {'J','u','n', 0}, {'J','u','l', 0}, {'A','u','g', 0},
1497      {'S','e','p', 0}, {'O','c','t', 0}, {'N','o','v', 0}, {'D','e','c', 0}};
1498
1499 /***********************************************************************
1500  *           WinHttpTimeFromSystemTime (WININET.@)
1501  */
1502 BOOL WINAPI WinHttpTimeFromSystemTime( const SYSTEMTIME *time, LPWSTR string )
1503 {
1504     static const WCHAR format[] =
1505         {'%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
1506          '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0};
1507
1508     TRACE("%p, %p\n", time, string);
1509
1510     if (!time || !string) return FALSE;
1511
1512     sprintfW( string, format,
1513               wkday[time->wDayOfWeek],
1514               time->wDay,
1515               month[time->wMonth - 1],
1516               time->wYear,
1517               time->wHour,
1518               time->wMinute,
1519               time->wSecond );
1520
1521     return TRUE;
1522 }
1523
1524 /***********************************************************************
1525  *           WinHttpTimeToSystemTime (WININET.@)
1526  */
1527 BOOL WINAPI WinHttpTimeToSystemTime( LPCWSTR string, SYSTEMTIME *time )
1528 {
1529     unsigned int i;
1530     const WCHAR *s = string;
1531     WCHAR *end;
1532
1533     TRACE("%s, %p\n", debugstr_w(string), time);
1534
1535     if (!string || !time) return FALSE;
1536
1537     /* Windows does this too */
1538     GetSystemTime( time );
1539
1540     /*  Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
1541      *  a SYSTEMTIME structure.
1542      */
1543
1544     while (*s && !isalphaW( *s )) s++;
1545     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
1546     time->wDayOfWeek = 7;
1547
1548     for (i = 0; i < 7; i++)
1549     {
1550         if (toupperW( wkday[i][0] ) == toupperW( s[0] ) &&
1551             toupperW( wkday[i][1] ) == toupperW( s[1] ) &&
1552             toupperW( wkday[i][2] ) == toupperW( s[2] ) )
1553         {
1554             time->wDayOfWeek = i;
1555             break;
1556         }
1557     }
1558
1559     if (time->wDayOfWeek > 6) return TRUE;
1560     while (*s && !isdigitW( *s )) s++;
1561     time->wDay = strtolW( s, &end, 10 );
1562     s = end;
1563
1564     while (*s && !isalphaW( *s )) s++;
1565     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
1566     time->wMonth = 0;
1567
1568     for (i = 0; i < 12; i++)
1569     {
1570         if (toupperW( month[i][0]) == toupperW( s[0] ) &&
1571             toupperW( month[i][1]) == toupperW( s[1] ) &&
1572             toupperW( month[i][2]) == toupperW( s[2] ) )
1573         {
1574             time->wMonth = i + 1;
1575             break;
1576         }
1577     }
1578     if (time->wMonth == 0) return TRUE;
1579
1580     while (*s && !isdigitW( *s )) s++;
1581     if (*s == '\0') return TRUE;
1582     time->wYear = strtolW( s, &end, 10 );
1583     s = end;
1584
1585     while (*s && !isdigitW( *s )) s++;
1586     if (*s == '\0') return TRUE;
1587     time->wHour = strtolW( s, &end, 10 );
1588     s = end;
1589
1590     while (*s && !isdigitW( *s )) s++;
1591     if (*s == '\0') return TRUE;
1592     time->wMinute = strtolW( s, &end, 10 );
1593     s = end;
1594
1595     while (*s && !isdigitW( *s )) s++;
1596     if (*s == '\0') return TRUE;
1597     time->wSecond = strtolW( s, &end, 10 );
1598     s = end;
1599
1600     time->wMilliseconds = 0;
1601     return TRUE;
1602 }