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 #define COBJMACROS
  32 #include "ole2.h"
  33 #include "dispex.h"
  34 #include "activscp.h"
  35
  36 #include "winhttp_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
  39
  40 #define DEFAULT_RESOLVE_TIMEOUT     0
  41 #define DEFAULT_CONNECT_TIMEOUT     20000
  42 #define DEFAULT_SEND_TIMEOUT        30000
  43 #define DEFAULT_RECEIVE_TIMEOUT     30000
  44
  45 static const WCHAR global_funcsW[] = {'g','l','o','b','a','l','_','f','u','n','c','s',0};
  46 static const WCHAR dns_resolveW[] = {'d','n','s','_','r','e','s','o','l','v','e',0};
  47
  48 void set_last_error( DWORD error )
  49 {
  50     /* FIXME */
  51     SetLastError( error );
  52 }
  53
  54 DWORD get_last_error( void )
  55 {
  56     /* FIXME */
  57     return GetLastError();
  58 }
  59
  60 void send_callback( object_header_t *hdr, DWORD status, LPVOID info, DWORD buflen )
  61 {
  62     TRACE("%p, 0x%08x, %p, %u\n", hdr, status, info, buflen);
  63
  64     if (hdr->callback && (hdr->notify_mask & status)) hdr->callback( hdr->handle, hdr->context, status, info, buflen );
  65 }
  66
  67 /***********************************************************************
  68  *          WinHttpCheckPlatform (winhttp.@)
  69  */
  70 BOOL WINAPI WinHttpCheckPlatform( void )
  71 {
  72     TRACE("\n");
  73     return TRUE;
  74 }
  75
  76 /***********************************************************************
  77  *          session_destroy (internal)
  78  */
  79 static void session_destroy( object_header_t *hdr )
  80 {
  81     session_t *session = (session_t *)hdr;
  82     struct list *item, *next;
  83     domain_t *domain;
  84
  85     TRACE("%p\n", session);
  86
  87     LIST_FOR_EACH_SAFE( item, next, &session->cookie_cache )
  88     {
  89         domain = LIST_ENTRY( item, domain_t, entry );
  90         delete_domain( domain );
  91     }
  92     heap_free( session->agent );
  93     heap_free( session->proxy_server );
  94     heap_free( session->proxy_bypass );
  95     heap_free( session->proxy_username );
  96     heap_free( session->proxy_password );
  97     heap_free( session );
  98 }
  99
 100 static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 101 {
 102     session_t *session = (session_t *)hdr;
 103
 104     switch (option)
 105     {
 106     case WINHTTP_OPTION_REDIRECT_POLICY:
 107     {
 108         if (!buffer || *buflen < sizeof(DWORD))
 109         {
 110             *buflen = sizeof(DWORD);
 111             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 112             return FALSE;
 113         }
 114
 115         *(DWORD *)buffer = hdr->redirect_policy;
 116         *buflen = sizeof(DWORD);
 117         return TRUE;
 118     }
 119     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 120         *(DWORD *)buffer = session->resolve_timeout;
 121         *buflen = sizeof(DWORD);
 122         return TRUE;
 123     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 124         *(DWORD *)buffer = session->connect_timeout;
 125         *buflen = sizeof(DWORD);
 126         return TRUE;
 127     case WINHTTP_OPTION_SEND_TIMEOUT:
 128         *(DWORD *)buffer = session->send_timeout;
 129         *buflen = sizeof(DWORD);
 130         return TRUE;
 131     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 132         *(DWORD *)buffer = session->recv_timeout;
 133         *buflen = sizeof(DWORD);
 134         return TRUE;
 135     default:
 136         FIXME("unimplemented option %u\n", option);
 137         set_last_error( ERROR_INVALID_PARAMETER );
 138         return FALSE;
 139     }
 140 }
 141
 142 static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 143 {
 144     session_t *session = (session_t *)hdr;
 145
 146     switch (option)
 147     {
 148     case WINHTTP_OPTION_PROXY:
 149     {
 150         WINHTTP_PROXY_INFO *pi = buffer;
 151
 152         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
 153         return TRUE;
 154     }
 155     case WINHTTP_OPTION_REDIRECT_POLICY:
 156     {
 157         DWORD policy;
 158
 159         if (buflen != sizeof(policy))
 160         {
 161             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 162             return FALSE;
 163         }
 164
 165         policy = *(DWORD *)buffer;
 166         TRACE("0x%x\n", policy);
 167         hdr->redirect_policy = policy;
 168         return TRUE;
 169     }
 170     case WINHTTP_OPTION_DISABLE_FEATURE:
 171         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 172         return FALSE;
 173     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 174         session->resolve_timeout = *(DWORD *)buffer;
 175         return TRUE;
 176     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 177         session->connect_timeout = *(DWORD *)buffer;
 178         return TRUE;
 179     case WINHTTP_OPTION_SEND_TIMEOUT:
 180         session->send_timeout = *(DWORD *)buffer;
 181         return TRUE;
 182     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 183         session->recv_timeout = *(DWORD *)buffer;
 184         return TRUE;
 185     default:
 186         FIXME("unimplemented option %u\n", option);
 187         set_last_error( ERROR_INVALID_PARAMETER );
 188         return FALSE;
 189     }
 190 }
 191
 192 static const object_vtbl_t session_vtbl =
 193 {
 194     session_destroy,
 195     session_query_option,
 196     session_set_option
 197 };
 198
 199 /***********************************************************************
 200  *          WinHttpOpen (winhttp.@)
 201  */
 202 HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags )
 203 {
 204     session_t *session;
 205     HINTERNET handle = NULL;
 206
 207     TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags);
 208
 209     if (!(session = heap_alloc_zero( sizeof(session_t) ))) return NULL;
 210
 211     session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
 212     session->hdr.vtbl = &session_vtbl;
 213     session->hdr.flags = flags;
 214     session->hdr.refs = 1;
 215     session->hdr.redirect_policy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
 216     list_init( &session->hdr.children );
 217     session->resolve_timeout = DEFAULT_RESOLVE_TIMEOUT;
 218     session->connect_timeout = DEFAULT_CONNECT_TIMEOUT;
 219     session->send_timeout = DEFAULT_SEND_TIMEOUT;
 220     session->recv_timeout = DEFAULT_RECEIVE_TIMEOUT;
 221     list_init( &session->cookie_cache );
 222
 223     if (agent && !(session->agent = strdupW( agent ))) goto end;
 224     if (access == WINHTTP_ACCESS_TYPE_DEFAULT_PROXY)
 225     {
 226         WINHTTP_PROXY_INFO info;
 227
 228         WinHttpGetDefaultProxyConfiguration( &info );
 229         session->access = info.dwAccessType;
 230         if (info.lpszProxy && !(session->proxy_server = strdupW( info.lpszProxy )))
 231         {
 232             GlobalFree( (LPWSTR)info.lpszProxy );
 233             GlobalFree( (LPWSTR)info.lpszProxyBypass );
 234             goto end;
 235         }
 236         if (info.lpszProxyBypass && !(session->proxy_bypass = strdupW( info.lpszProxyBypass )))
 237         {
 238             GlobalFree( (LPWSTR)info.lpszProxy );
 239             GlobalFree( (LPWSTR)info.lpszProxyBypass );
 240             goto end;
 241         }
 242     }
 243     else if (access == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
 244     {
 245         session->access = access;
 246         if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
 247         if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end;
 248     }
 249
 250     if (!(handle = alloc_handle( &session->hdr ))) goto end;
 251     session->hdr.handle = handle;
 252
 253 end:
 254     release_object( &session->hdr );
 255     TRACE("returning %p\n", handle);
 256     return handle;
 257 }
 258
 259 /***********************************************************************
 260  *          connect_destroy (internal)
 261  */
 262 static void connect_destroy( object_header_t *hdr )
 263 {
 264     connect_t *connect = (connect_t *)hdr;
 265
 266     TRACE("%p\n", connect);
 267
 268     release_object( &connect->session->hdr );
 269
 270     heap_free( connect->hostname );
 271     heap_free( connect->servername );
 272     heap_free( connect->username );
 273     heap_free( connect->password );
 274     heap_free( connect );
 275 }
 276
 277 static BOOL connect_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 278 {
 279     connect_t *connect = (connect_t *)hdr;
 280
 281     switch (option)
 282     {
 283     case WINHTTP_OPTION_PARENT_HANDLE:
 284     {
 285         if (!buffer || *buflen < sizeof(HINTERNET))
 286         {
 287             *buflen = sizeof(HINTERNET);
 288             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 289             return FALSE;
 290         }
 291
 292         *(HINTERNET *)buffer = ((object_header_t *)connect->session)->handle;
 293         *buflen = sizeof(HINTERNET);
 294         return TRUE;
 295     }
 296     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 297         *(DWORD *)buffer = connect->session->resolve_timeout;
 298         *buflen = sizeof(DWORD);
 299         return TRUE;
 300     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 301         *(DWORD *)buffer = connect->session->connect_timeout;
 302         *buflen = sizeof(DWORD);
 303         return TRUE;
 304     case WINHTTP_OPTION_SEND_TIMEOUT:
 305         *(DWORD *)buffer = connect->session->send_timeout;
 306         *buflen = sizeof(DWORD);
 307         return TRUE;
 308     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 309         *(DWORD *)buffer = connect->session->recv_timeout;
 310         *buflen = sizeof(DWORD);
 311         return TRUE;
 312     default:
 313         FIXME("unimplemented option %u\n", option);
 314         set_last_error( ERROR_INVALID_PARAMETER );
 315         return FALSE;
 316     }
 317 }
 318
 319 static const object_vtbl_t connect_vtbl =
 320 {
 321     connect_destroy,
 322     connect_query_option,
 323     NULL
 324 };
 325
 326 static BOOL domain_matches(LPCWSTR server, LPCWSTR domain)
 327 {
 328     static const WCHAR localW[] = { '<','l','o','c','a','l','>',0 };
 329     BOOL ret = FALSE;
 330
 331     if (!strcmpiW( domain, localW ) && !strchrW( server, '.' ))
 332         ret = TRUE;
 333     else if (*domain == '*')
 334     {
 335         if (domain[1] == '.')
 336         {
 337             LPCWSTR dot;
 338
 339             /* For a hostname to match a wildcard, the last domain must match
 340              * the wildcard exactly.  E.g. if the wildcard is *.a.b, and the
 341              * hostname is www.foo.a.b, it matches, but a.b does not.
 342              */
 343             dot = strchrW( server, '.' );
 344             if (dot)
 345             {
 346                 int len = strlenW( dot + 1 );
 347
 348                 if (len > strlenW( domain + 2 ))
 349                 {
 350                     LPCWSTR ptr;
 351
 352                     /* The server's domain is longer than the wildcard, so it
 353                      * could be a subdomain.  Compare the last portion of the
 354                      * server's domain.
 355                      */
 356                     ptr = dot + len + 1 - strlenW( domain + 2 );
 357                     if (!strcmpiW( ptr, domain + 2 ))
 358                     {
 359                         /* This is only a match if the preceding character is
 360                          * a '.', i.e. that it is a matching domain.  E.g.
 361                          * if domain is '*.b.c' and server is 'www.ab.c' they
 362                          * do not match.
 363                          */
 364                         ret = *(ptr - 1) == '.';
 365                     }
 366                 }
 367                 else
 368                     ret = !strcmpiW( dot + 1, domain + 2 );
 369             }
 370         }
 371     }
 372     else
 373         ret = !strcmpiW( server, domain );
 374     return ret;
 375 }
 376
 377 /* Matches INTERNET_MAX_HOST_NAME_LENGTH in wininet.h, also RFC 1035 */
 378 #define MAX_HOST_NAME_LENGTH 256
 379
 380 static BOOL should_bypass_proxy(session_t *session, LPCWSTR server)
 381 {
 382     LPCWSTR ptr;
 383     BOOL ret = FALSE;
 384
 385     if (!session->proxy_bypass) return FALSE;
 386     ptr = session->proxy_bypass;
 387     do {
 388         LPCWSTR tmp = ptr;
 389
 390         ptr = strchrW( ptr, ';' );
 391         if (!ptr)
 392             ptr = strchrW( tmp, ' ' );
 393         if (ptr)
 394         {
 395             if (ptr - tmp < MAX_HOST_NAME_LENGTH)
 396             {
 397                 WCHAR domain[MAX_HOST_NAME_LENGTH];
 398
 399                 memcpy( domain, tmp, (ptr - tmp) * sizeof(WCHAR) );
 400                 domain[ptr - tmp] = 0;
 401                 ret = domain_matches( server, domain );
 402             }
 403             ptr += 1;
 404         }
 405         else if (*tmp)
 406             ret = domain_matches( server, tmp );
 407     } while (ptr && !ret);
 408     return ret;
 409 }
 410
 411 BOOL set_server_for_hostname( connect_t *connect, LPCWSTR server, INTERNET_PORT port )
 412 {
 413     session_t *session = connect->session;
 414     BOOL ret = TRUE;
 415
 416     if (session->proxy_server && !should_bypass_proxy(session, server))
 417     {
 418         LPCWSTR colon;
 419
 420         if ((colon = strchrW( session->proxy_server, ':' )))
 421         {
 422             if (!connect->servername || strncmpiW( connect->servername,
 423                 session->proxy_server, colon - session->proxy_server - 1 ))
 424             {
 425                 heap_free( connect->servername );
 426                 connect->resolved = FALSE;
 427                 if (!(connect->servername = heap_alloc(
 428                     (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
 429                 {
 430                     ret = FALSE;
 431                     goto end;
 432                 }
 433                 memcpy( connect->servername, session->proxy_server,
 434                     (colon - session->proxy_server) * sizeof(WCHAR) );
 435                 connect->servername[colon - session->proxy_server] = 0;
 436                 if (*(colon + 1))
 437                     connect->serverport = atoiW( colon + 1 );
 438                 else
 439                     connect->serverport = INTERNET_DEFAULT_PORT;
 440             }
 441         }
 442         else
 443         {
 444             if (!connect->servername || strcmpiW( connect->servername,
 445                 session->proxy_server ))
 446             {
 447                 heap_free( connect->servername );
 448                 connect->resolved = FALSE;
 449                 if (!(connect->servername = strdupW( session->proxy_server )))
 450                 {
 451                     ret = FALSE;
 452                     goto end;
 453                 }
 454                 connect->serverport = INTERNET_DEFAULT_PORT;
 455             }
 456         }
 457     }
 458     else if (server)
 459     {
 460         heap_free( connect->servername );
 461         connect->resolved = FALSE;
 462         if (!(connect->servername = strdupW( server )))
 463         {
 464             ret = FALSE;
 465             goto end;
 466         }
 467         connect->serverport = port;
 468     }
 469 end:
 470     return ret;
 471 }
 472
 473 /***********************************************************************
 474  *          WinHttpConnect (winhttp.@)
 475  */
 476 HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved )
 477 {
 478     connect_t *connect;
 479     session_t *session;
 480     HINTERNET hconnect = NULL;
 481
 482     TRACE("%p, %s, %u, %x\n", hsession, debugstr_w(server), port, reserved);
 483
 484     if (!server)
 485     {
 486         set_last_error( ERROR_INVALID_PARAMETER );
 487         return NULL;
 488     }
 489     if (!(session = (session_t *)grab_object( hsession )))
 490     {
 491         set_last_error( ERROR_INVALID_HANDLE );
 492         return NULL;
 493     }
 494     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
 495     {
 496         release_object( &session->hdr );
 497         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 498         return NULL;
 499     }
 500     if (!(connect = heap_alloc_zero( sizeof(connect_t) )))
 501     {
 502         release_object( &session->hdr );
 503         return NULL;
 504     }
 505     connect->hdr.type = WINHTTP_HANDLE_TYPE_CONNECT;
 506     connect->hdr.vtbl = &connect_vtbl;
 507     connect->hdr.refs = 1;
 508     connect->hdr.flags = session->hdr.flags;
 509     connect->hdr.callback = session->hdr.callback;
 510     connect->hdr.notify_mask = session->hdr.notify_mask;
 511     connect->hdr.context = session->hdr.context;
 512     list_init( &connect->hdr.children );
 513
 514     addref_object( &session->hdr );
 515     connect->session = session;
 516     list_add_head( &session->hdr.children, &connect->hdr.entry );
 517
 518     if (!(connect->hostname = strdupW( server ))) goto end;
 519     connect->hostport = port;
 520     if (!set_server_for_hostname( connect, server, port )) goto end;
 521
 522     if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
 523     connect->hdr.handle = hconnect;
 524
 525     send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
 526
 527 end:
 528     release_object( &connect->hdr );
 529     release_object( &session->hdr );
 530     TRACE("returning %p\n", hconnect);
 531     return hconnect;
 532 }
 533
 534 /***********************************************************************
 535  *          request_destroy (internal)
 536  */
 537 static void request_destroy( object_header_t *hdr )
 538 {
 539     request_t *request = (request_t *)hdr;
 540     unsigned int i;
 541
 542     TRACE("%p\n", request);
 543
 544     release_object( &request->connect->hdr );
 545
 546     heap_free( request->verb );
 547     heap_free( request->path );
 548     heap_free( request->version );
 549     heap_free( request->raw_headers );
 550     heap_free( request->status_text );
 551     for (i = 0; i < request->num_headers; i++)
 552     {
 553         heap_free( request->headers[i].field );
 554         heap_free( request->headers[i].value );
 555     }
 556     heap_free( request->headers );
 557     for (i = 0; i < request->num_accept_types; i++) heap_free( request->accept_types[i] );
 558     heap_free( request->accept_types );
 559     heap_free( request );
 560 }
 561
 562 static void str_to_buffer( WCHAR *buffer, const WCHAR *str, LPDWORD buflen )
 563 {
 564     int len = 0;
 565     if (str) len = strlenW( str );
 566     if (buffer && *buflen > len)
 567     {
 568         if (str) memcpy( buffer, str, len * sizeof(WCHAR) );
 569         buffer[len] = 0;
 570     }
 571     *buflen = len * sizeof(WCHAR);
 572 }
 573
 574 static WCHAR *blob_to_str( DWORD encoding, CERT_NAME_BLOB *blob )
 575 {
 576     WCHAR *ret;
 577     DWORD size, format = CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG;
 578
 579     size = CertNameToStrW( encoding, blob, format, NULL, 0 );
 580     if ((ret = LocalAlloc( 0, size * sizeof(WCHAR) )))
 581         CertNameToStrW( encoding, blob, format, ret, size );
 582
 583     return ret;
 584 }
 585
 586 static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 587 {
 588     request_t *request = (request_t *)hdr;
 589
 590     switch (option)
 591     {
 592     case WINHTTP_OPTION_SECURITY_FLAGS:
 593     {
 594         DWORD flags;
 595         int bits;
 596
 597         if (!buffer || *buflen < sizeof(flags))
 598         {
 599             *buflen = sizeof(flags);
 600             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 601             return FALSE;
 602         }
 603
 604         flags = 0;
 605         if (hdr->flags & WINHTTP_FLAG_SECURE) flags |= SECURITY_FLAG_SECURE;
 606         flags |= request->netconn.security_flags;
 607         bits = netconn_get_cipher_strength( &request->netconn );
 608         if (bits >= 128)
 609             flags |= SECURITY_FLAG_STRENGTH_STRONG;
 610         else if (bits >= 56)
 611             flags |= SECURITY_FLAG_STRENGTH_MEDIUM;
 612         else
 613             flags |= SECURITY_FLAG_STRENGTH_WEAK;
 614         *(DWORD *)buffer = flags;
 615         *buflen = sizeof(flags);
 616         return TRUE;
 617     }
 618     case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
 619     {
 620         const CERT_CONTEXT *cert;
 621
 622         if (!buffer || *buflen < sizeof(cert))
 623         {
 624             *buflen = sizeof(cert);
 625             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 626             return FALSE;
 627         }
 628
 629         if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
 630         *(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
 631         *buflen = sizeof(cert);
 632         return TRUE;
 633     }
 634     case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT:
 635     {
 636         const CERT_CONTEXT *cert;
 637         const CRYPT_OID_INFO *oidInfo;
 638         WINHTTP_CERTIFICATE_INFO *ci = buffer;
 639
 640         FIXME("partial stub\n");
 641
 642         if (!buffer || *buflen < sizeof(*ci))
 643         {
 644             *buflen = sizeof(*ci);
 645             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 646             return FALSE;
 647         }
 648         if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
 649
 650         ci->ftExpiry = cert->pCertInfo->NotAfter;
 651         ci->ftStart  = cert->pCertInfo->NotBefore;
 652         ci->lpszSubjectInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Subject );
 653         ci->lpszIssuerInfo  = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Issuer );
 654         ci->lpszProtocolName      = NULL;
 655         oidInfo = CryptFindOIDInfo( CRYPT_OID_INFO_OID_KEY,
 656                                     cert->pCertInfo->SignatureAlgorithm.pszObjId,
 657                                     0 );
 658         if (oidInfo)
 659             ci->lpszSignatureAlgName = (LPWSTR)oidInfo->pwszName;
 660         else
 661             ci->lpszSignatureAlgName  = NULL;
 662         ci->lpszEncryptionAlgName = NULL;
 663         ci->dwKeySize = netconn_get_cipher_strength( &request->netconn );
 664
 665         CertFreeCertificateContext( cert );
 666         *buflen = sizeof(*ci);
 667         return TRUE;
 668     }
 669     case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
 670     {
 671         if (!buffer || *buflen < sizeof(DWORD))
 672         {
 673             *buflen = sizeof(DWORD);
 674             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 675             return FALSE;
 676         }
 677
 678         *(DWORD *)buffer = netconn_get_cipher_strength( &request->netconn );
 679         *buflen = sizeof(DWORD);
 680         return TRUE;
 681     }
 682     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 683         *(DWORD *)buffer = request->resolve_timeout;
 684         *buflen = sizeof(DWORD);
 685         return TRUE;
 686     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 687         *(DWORD *)buffer = request->connect_timeout;
 688         *buflen = sizeof(DWORD);
 689         return TRUE;
 690     case WINHTTP_OPTION_SEND_TIMEOUT:
 691         *(DWORD *)buffer = request->send_timeout;
 692         *buflen = sizeof(DWORD);
 693         return TRUE;
 694     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 695         *(DWORD *)buffer = request->recv_timeout;
 696         *buflen = sizeof(DWORD);
 697         return TRUE;
 698
 699     case WINHTTP_OPTION_USERNAME:
 700         str_to_buffer( buffer, request->connect->username, buflen );
 701         return TRUE;
 702
 703     case WINHTTP_OPTION_PASSWORD:
 704         str_to_buffer( buffer, request->connect->password, buflen );
 705         return TRUE;
 706
 707     case WINHTTP_OPTION_PROXY_USERNAME:
 708         str_to_buffer( buffer, request->connect->session->proxy_username, buflen );
 709         return TRUE;
 710
 711     case WINHTTP_OPTION_PROXY_PASSWORD:
 712         str_to_buffer( buffer, request->connect->session->proxy_password, buflen );
 713         return TRUE;
 714
 715     default:
 716         FIXME("unimplemented option %u\n", option);
 717         set_last_error( ERROR_INVALID_PARAMETER );
 718         return FALSE;
 719     }
 720 }
 721
 722 static WCHAR *buffer_to_str( WCHAR *buffer, DWORD buflen )
 723 {
 724     WCHAR *ret;
 725     if ((ret = heap_alloc( (buflen + 1) * sizeof(WCHAR))))
 726     {
 727         memcpy( ret, buffer, buflen * sizeof(WCHAR) );
 728         ret[buflen] = 0;
 729         return ret;
 730     }
 731     set_last_error( ERROR_OUTOFMEMORY );
 732     return NULL;
 733 }
 734
 735 static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 736 {
 737     request_t *request = (request_t *)hdr;
 738
 739     switch (option)
 740     {
 741     case WINHTTP_OPTION_PROXY:
 742     {
 743         WINHTTP_PROXY_INFO *pi = buffer;
 744
 745         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
 746         return TRUE;
 747     }
 748     case WINHTTP_OPTION_DISABLE_FEATURE:
 749     {
 750         DWORD disable;
 751
 752         if (buflen != sizeof(DWORD))
 753         {
 754             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 755             return FALSE;
 756         }
 757
 758         disable = *(DWORD *)buffer;
 759         TRACE("0x%x\n", disable);
 760         hdr->disable_flags |= disable;
 761         return TRUE;
 762     }
 763     case WINHTTP_OPTION_AUTOLOGON_POLICY:
 764     {
 765         DWORD policy;
 766
 767         if (buflen != sizeof(DWORD))
 768         {
 769             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 770             return FALSE;
 771         }
 772
 773         policy = *(DWORD *)buffer;
 774         TRACE("0x%x\n", policy);
 775         hdr->logon_policy = policy;
 776         return TRUE;
 777     }
 778     case WINHTTP_OPTION_REDIRECT_POLICY:
 779     {
 780         DWORD policy;
 781
 782         if (buflen != sizeof(DWORD))
 783         {
 784             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 785             return FALSE;
 786         }
 787
 788         policy = *(DWORD *)buffer;
 789         TRACE("0x%x\n", policy);
 790         hdr->redirect_policy = policy;
 791         return TRUE;
 792     }
 793     case WINHTTP_OPTION_SECURITY_FLAGS:
 794     {
 795         DWORD flags;
 796
 797         if (buflen < sizeof(DWORD))
 798         {
 799             set_last_error( ERROR_INSUFFICIENT_BUFFER );
 800             return FALSE;
 801         }
 802         flags = *(DWORD *)buffer;
 803         TRACE("0x%x\n", flags);
 804         if (!(flags & (SECURITY_FLAG_IGNORE_CERT_CN_INVALID   |
 805                        SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
 806                        SECURITY_FLAG_IGNORE_UNKNOWN_CA        |
 807                        SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE)))
 808         {
 809             set_last_error( ERROR_INVALID_PARAMETER );
 810             return FALSE;
 811         }
 812         request->netconn.security_flags = flags;
 813         return TRUE;
 814     }
 815     case WINHTTP_OPTION_RESOLVE_TIMEOUT:
 816         request->resolve_timeout = *(DWORD *)buffer;
 817         return TRUE;
 818     case WINHTTP_OPTION_CONNECT_TIMEOUT:
 819         request->connect_timeout = *(DWORD *)buffer;
 820         return TRUE;
 821     case WINHTTP_OPTION_SEND_TIMEOUT:
 822         request->send_timeout = *(DWORD *)buffer;
 823         return TRUE;
 824     case WINHTTP_OPTION_RECEIVE_TIMEOUT:
 825         request->recv_timeout = *(DWORD *)buffer;
 826         return TRUE;
 827
 828     case WINHTTP_OPTION_USERNAME:
 829     {
 830         connect_t *connect = request->connect;
 831
 832         heap_free( connect->username );
 833         if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE;
 834         return TRUE;
 835     }
 836     case WINHTTP_OPTION_PASSWORD:
 837     {
 838         connect_t *connect = request->connect;
 839
 840         heap_free( connect->password );
 841         if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE;
 842         return TRUE;
 843     }
 844     case WINHTTP_OPTION_PROXY_USERNAME:
 845     {
 846         session_t *session = request->connect->session;
 847
 848         heap_free( session->proxy_username );
 849         if (!(session->proxy_username = buffer_to_str( buffer, buflen ))) return FALSE;
 850         return TRUE;
 851     }
 852     case WINHTTP_OPTION_PROXY_PASSWORD:
 853     {
 854         session_t *session = request->connect->session;
 855
 856         heap_free( session->proxy_password );
 857         if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE;
 858         return TRUE;
 859     }
 860     default:
 861         FIXME("unimplemented option %u\n", option);
 862         set_last_error( ERROR_INVALID_PARAMETER );
 863         return TRUE;
 864     }
 865 }
 866
 867 static const object_vtbl_t request_vtbl =
 868 {
 869     request_destroy,
 870     request_query_option,
 871     request_set_option
 872 };
 873
 874 static BOOL store_accept_types( request_t *request, const WCHAR **accept_types )
 875 {
 876     const WCHAR **types = accept_types;
 877     int i;
 878
 879     if (!types) return TRUE;
 880     while (*types)
 881     {
 882         request->num_accept_types++;
 883         types++;
 884     }
 885     if (!request->num_accept_types) return TRUE;
 886     if (!(request->accept_types = heap_alloc( request->num_accept_types * sizeof(WCHAR *))))
 887     {
 888         request->num_accept_types = 0;
 889         return FALSE;
 890     }
 891     types = accept_types;
 892     for (i = 0; i < request->num_accept_types; i++)
 893     {
 894         if (!(request->accept_types[i] = strdupW( *types )))
 895         {
 896             for (; i >= 0; i--) heap_free( request->accept_types[i] );
 897             heap_free( request->accept_types );
 898             request->accept_types = NULL;
 899             request->num_accept_types = 0;
 900             return FALSE;
 901         }
 902         types++;
 903     }
 904     return TRUE;
 905 }
 906
 907 /***********************************************************************
 908  *          WinHttpOpenRequest (winhttp.@)
 909  */
 910 HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version,
 911                                      LPCWSTR referrer, LPCWSTR *types, DWORD flags )
 912 {
 913     request_t *request;
 914     connect_t *connect;
 915     HINTERNET hrequest = NULL;
 916
 917     TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect, debugstr_w(verb), debugstr_w(object),
 918           debugstr_w(version), debugstr_w(referrer), types, flags);
 919
 920     if (!(connect = (connect_t *)grab_object( hconnect )))
 921     {
 922         set_last_error( ERROR_INVALID_HANDLE );
 923         return NULL;
 924     }
 925     if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
 926     {
 927         release_object( &connect->hdr );
 928         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 929         return NULL;
 930     }
 931     if (!(request = heap_alloc_zero( sizeof(request_t) )))
 932     {
 933         release_object( &connect->hdr );
 934         return NULL;
 935     }
 936     request->hdr.type = WINHTTP_HANDLE_TYPE_REQUEST;
 937     request->hdr.vtbl = &request_vtbl;
 938     request->hdr.refs = 1;
 939     request->hdr.flags = flags;
 940     request->hdr.callback = connect->hdr.callback;
 941     request->hdr.notify_mask = connect->hdr.notify_mask;
 942     request->hdr.context = connect->hdr.context;
 943     list_init( &request->hdr.children );
 944
 945     addref_object( &connect->hdr );
 946     request->connect = connect;
 947     list_add_head( &connect->hdr.children, &request->hdr.entry );
 948
 949     if (!netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE )) goto end;
 950     request->resolve_timeout = connect->session->resolve_timeout;
 951     request->connect_timeout = connect->session->connect_timeout;
 952     request->send_timeout = connect->session->send_timeout;
 953     request->recv_timeout = connect->session->recv_timeout;
 954
 955     if (!verb || !verb[0]) verb = getW;
 956     if (!(request->verb = strdupW( verb ))) goto end;
 957
 958     if (object)
 959     {
 960         WCHAR *path, *p;
 961         unsigned int len;
 962
 963         len = strlenW( object ) + 1;
 964         if (object[0] != '/') len++;
 965         if (!(p = path = heap_alloc( len * sizeof(WCHAR) ))) goto end;
 966
 967         if (object[0] != '/') *p++ = '/';
 968         strcpyW( p, object );
 969         request->path = path;
 970     }
 971     else if (!(request->path = strdupW( slashW ))) goto end;
 972
 973     if (!version || !version[0]) version = http1_1;
 974     if (!(request->version = strdupW( version ))) goto end;
 975     if (!(store_accept_types( request, types ))) goto end;
 976
 977     if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
 978     request->hdr.handle = hrequest;
 979
 980     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
 981
 982 end:
 983     release_object( &request->hdr );
 984     release_object( &connect->hdr );
 985     TRACE("returning %p\n", hrequest);
 986     return hrequest;
 987 }
 988
 989 /***********************************************************************
 990  *          WinHttpCloseHandle (winhttp.@)
 991  */
 992 BOOL WINAPI WinHttpCloseHandle( HINTERNET handle )
 993 {
 994     object_header_t *hdr;
 995
 996     TRACE("%p\n", handle);
 997
 998     if (!(hdr = grab_object( handle )))
 999     {
1000         set_last_error( ERROR_INVALID_HANDLE );
1001         return FALSE;
1002     }
1003     release_object( hdr );
1004     free_handle( handle );
1005     return TRUE;
1006 }
1007
1008 static BOOL query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
1009 {
1010     BOOL ret = FALSE;
1011
1012     if (!buflen)
1013     {
1014         set_last_error( ERROR_INVALID_PARAMETER );
1015         return FALSE;
1016     }
1017
1018     switch (option)
1019     {
1020     case WINHTTP_OPTION_CONTEXT_VALUE:
1021     {
1022         if (!buffer || *buflen < sizeof(DWORD_PTR))
1023         {
1024             *buflen = sizeof(DWORD_PTR);
1025             set_last_error( ERROR_INSUFFICIENT_BUFFER );
1026             return FALSE;
1027         }
1028
1029         *(DWORD_PTR *)buffer = hdr->context;
1030         *buflen = sizeof(DWORD_PTR);
1031         return TRUE;
1032     }
1033     default:
1034         if (hdr->vtbl->query_option) ret = hdr->vtbl->query_option( hdr, option, buffer, buflen );
1035         else
1036         {
1037             FIXME("unimplemented option %u\n", option);
1038             set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1039             return FALSE;
1040         }
1041         break;
1042     }
1043     return ret;
1044 }
1045
1046 /***********************************************************************
1047  *          WinHttpQueryOption (winhttp.@)
1048  */
1049 BOOL WINAPI WinHttpQueryOption( HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen )
1050 {
1051     BOOL ret = FALSE;
1052     object_header_t *hdr;
1053
1054     TRACE("%p, %u, %p, %p\n", handle, option, buffer, buflen);
1055
1056     if (!(hdr = grab_object( handle )))
1057     {
1058         set_last_error( ERROR_INVALID_HANDLE );
1059         return FALSE;
1060     }
1061
1062     ret = query_option( hdr, option, buffer, buflen );
1063
1064     release_object( hdr );
1065     return ret;
1066 }
1067
1068 static BOOL set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
1069 {
1070     BOOL ret = TRUE;
1071
1072     if (!buffer)
1073     {
1074         set_last_error( ERROR_INVALID_PARAMETER );
1075         return FALSE;
1076     }
1077
1078     switch (option)
1079     {
1080     case WINHTTP_OPTION_CONTEXT_VALUE:
1081     {
1082         if (buflen != sizeof(DWORD_PTR))
1083         {
1084             set_last_error( ERROR_INSUFFICIENT_BUFFER );
1085             return FALSE;
1086         }
1087
1088         hdr->context = *(DWORD_PTR *)buffer;
1089         return TRUE;
1090     }
1091     default:
1092         if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option, buffer, buflen );
1093         else
1094         {
1095             FIXME("unimplemented option %u\n", option);
1096             set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1097             return FALSE;
1098         }
1099         break;
1100     }
1101     return ret;
1102 }
1103
1104 /***********************************************************************
1105  *          WinHttpSetOption (winhttp.@)
1106  */
1107 BOOL WINAPI WinHttpSetOption( HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen )
1108 {
1109     BOOL ret = FALSE;
1110     object_header_t *hdr;
1111
1112     TRACE("%p, %u, %p, %u\n", handle, option, buffer, buflen);
1113
1114     if (!(hdr = grab_object( handle )))
1115     {
1116         set_last_error( ERROR_INVALID_HANDLE );
1117         return FALSE;
1118     }
1119
1120     ret = set_option( hdr, option, buffer, buflen );
1121
1122     release_object( hdr );
1123     return ret;
1124 }
1125
1126 static char *get_computer_name( COMPUTER_NAME_FORMAT format )
1127 {
1128     char *ret;
1129     DWORD size = 0;
1130
1131     GetComputerNameExA( format, NULL, &size );
1132     if (GetLastError() != ERROR_MORE_DATA) return NULL;
1133     if (!(ret = heap_alloc( size ))) return NULL;
1134     if (!GetComputerNameExA( format, ret, &size ))
1135     {
1136         heap_free( ret );
1137         return NULL;
1138     }
1139     return ret;
1140 }
1141
1142 static BOOL is_domain_suffix( const char *domain, const char *suffix )
1143 {
1144     int len_domain = strlen( domain ), len_suffix = strlen( suffix );
1145
1146     if (len_suffix > len_domain) return FALSE;
1147     if (!strcasecmp( domain + len_domain - len_suffix, suffix )) return TRUE;
1148     return FALSE;
1149 }
1150
1151 static void printf_addr( const WCHAR *fmt, WCHAR *buf, struct sockaddr_in *addr )
1152 {
1153     sprintfW( buf, fmt,
1154               (unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 24 & 0xff),
1155               (unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 16 & 0xff),
1156               (unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 8 & 0xff),
1157               (unsigned int)(ntohl( addr->sin_addr.s_addr ) & 0xff) );
1158 }
1159
1160 static WCHAR *build_wpad_url( const struct addrinfo *ai )
1161 {
1162     static const WCHAR fmtW[] =
1163         {'h','t','t','p',':','/','/','%','u','.','%','u','.','%','u','.','%','u',
1164          '/','w','p','a','d','.','d','a','t',0};
1165     WCHAR *ret;
1166
1167     while (ai && ai->ai_family != AF_INET) ai = ai->ai_next;
1168     if (!ai) return NULL;
1169
1170     if (!(ret = GlobalAlloc( 0, sizeof(fmtW) + 12 * sizeof(WCHAR) ))) return NULL;
1171     printf_addr( fmtW, ret, (struct sockaddr_in *)ai->ai_addr );
1172     return ret;
1173 }
1174
1175 /***********************************************************************
1176  *          WinHttpDetectAutoProxyConfigUrl (winhttp.@)
1177  */
1178 BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url )
1179 {
1180     BOOL ret = FALSE;
1181
1182     TRACE("0x%08x, %p\n", flags, url);
1183
1184     if (!flags || !url)
1185     {
1186         set_last_error( ERROR_INVALID_PARAMETER );
1187         return FALSE;
1188     }
1189     if (flags & WINHTTP_AUTO_DETECT_TYPE_DHCP) FIXME("discovery via DHCP not supported\n");
1190     if (flags & WINHTTP_AUTO_DETECT_TYPE_DNS_A)
1191     {
1192 #ifdef HAVE_GETADDRINFO
1193         char *fqdn, *domain, *p;
1194
1195         if (!(fqdn = get_computer_name( ComputerNamePhysicalDnsFullyQualified ))) return FALSE;
1196         if (!(domain = get_computer_name( ComputerNamePhysicalDnsDomain )))
1197         {
1198             heap_free( fqdn );
1199             return FALSE;
1200         }
1201         p = fqdn;
1202         while ((p = strchr( p, '.' )) && is_domain_suffix( p + 1, domain ))
1203         {
1204             struct addrinfo *ai;
1205             char *name;
1206             int res;
1207
1208             if (!(name = heap_alloc( sizeof("wpad") + strlen(p) )))
1209             {
1210                 heap_free( fqdn );
1211                 heap_free( domain );
1212                 return FALSE;
1213             }
1214             strcpy( name, "wpad" );
1215             strcat( name, p );
1216             res = getaddrinfo( name, NULL, NULL, &ai );
1217             heap_free( name );
1218             if (!res)
1219             {
1220                 *url = build_wpad_url( ai );
1221                 freeaddrinfo( ai );
1222                 if (*url)
1223                 {
1224                     TRACE("returning %s\n", debugstr_w(*url));
1225                     ret = TRUE;
1226                     break;
1227                 }
1228             }
1229             p++;
1230         }
1231         heap_free( domain );
1232         heap_free( fqdn );
1233 #else
1234     FIXME("getaddrinfo not found at build time\n");
1235 #endif
1236     }
1237     if (!ret) set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED );
1238     return ret;
1239 }
1240
1241 static const WCHAR Connections[] = {
1242     'S','o','f','t','w','a','r','e','\\',
1243     'M','i','c','r','o','s','o','f','t','\\',
1244     'W','i','n','d','o','w','s','\\',
1245     'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1246     'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
1247     'C','o','n','n','e','c','t','i','o','n','s',0 };
1248 static const WCHAR WinHttpSettings[] = {
1249     'W','i','n','H','t','t','p','S','e','t','t','i','n','g','s',0 };
1250 static const DWORD WINHTTP_SETTINGS_MAGIC = 0x18;
1251 static const DWORD WININET_SETTINGS_MAGIC = 0x46;
1252 static const DWORD PROXY_TYPE_DIRECT         = 1;
1253 static const DWORD PROXY_TYPE_PROXY          = 2;
1254 static const DWORD PROXY_USE_PAC_SCRIPT      = 4;
1255 static const DWORD PROXY_AUTODETECT_SETTINGS = 8;
1256
1257 struct connection_settings_header
1258 {
1259     DWORD magic;
1260     DWORD unknown; /* always zero? */
1261     DWORD flags;   /* one or more of PROXY_* */
1262 };
1263
1264 static inline void copy_char_to_wchar_sz(const BYTE *src, DWORD len, WCHAR *dst)
1265 {
1266     const BYTE *begin;
1267
1268     for (begin = src; src - begin < len; src++, dst++)
1269         *dst = *src;
1270     *dst = 0;
1271 }
1272
1273 /***********************************************************************
1274  *          WinHttpGetDefaultProxyConfiguration (winhttp.@)
1275  */
1276 BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
1277 {
1278     LONG l;
1279     HKEY key;
1280     BOOL got_from_reg = FALSE, direct = TRUE;
1281     char *envproxy;
1282
1283     TRACE("%p\n", info);
1284
1285     l = RegOpenKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, KEY_READ, &key );
1286     if (!l)
1287     {
1288         DWORD type, size = 0;
1289
1290         l = RegQueryValueExW( key, WinHttpSettings, NULL, &type, NULL, &size );
1291         if (!l && type == REG_BINARY &&
1292             size >= sizeof(struct connection_settings_header) + 2 * sizeof(DWORD))
1293         {
1294             BYTE *buf = heap_alloc( size );
1295
1296             if (buf)
1297             {
1298                 struct connection_settings_header *hdr =
1299                     (struct connection_settings_header *)buf;
1300                 DWORD *len = (DWORD *)(hdr + 1);
1301
1302                 l = RegQueryValueExW( key, WinHttpSettings, NULL, NULL, buf,
1303                     &size );
1304                 if (!l && hdr->magic == WINHTTP_SETTINGS_MAGIC &&
1305                     hdr->unknown == 0)
1306                 {
1307                     if (hdr->flags & PROXY_TYPE_PROXY)
1308                     {
1309                        BOOL sane = FALSE;
1310                        LPWSTR proxy = NULL;
1311                        LPWSTR proxy_bypass = NULL;
1312
1313                         /* Sanity-check length of proxy string */
1314                         if ((BYTE *)len - buf + *len <= size)
1315                         {
1316                             sane = TRUE;
1317                             proxy = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
1318                             if (proxy)
1319                                 copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy );
1320                             len = (DWORD *)((BYTE *)(len + 1) + *len);
1321                         }
1322                         if (sane)
1323                         {
1324                             /* Sanity-check length of proxy bypass string */
1325                             if ((BYTE *)len - buf + *len <= size)
1326                             {
1327                                 proxy_bypass = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
1328                                 if (proxy_bypass)
1329                                     copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy_bypass );
1330                             }
1331                             else
1332                             {
1333                                 sane = FALSE;
1334                                 GlobalFree( proxy );
1335                                 proxy = NULL;
1336                             }
1337                         }
1338                         info->lpszProxy = proxy;
1339                         info->lpszProxyBypass = proxy_bypass;
1340                         if (sane)
1341                         {
1342                             got_from_reg = TRUE;
1343                             direct = FALSE;
1344                             info->dwAccessType =
1345                                 WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1346                             TRACE("http proxy (from registry) = %s, bypass = %s\n",
1347                                 debugstr_w(info->lpszProxy),
1348                                 debugstr_w(info->lpszProxyBypass));
1349                         }
1350                     }
1351                 }
1352                 heap_free( buf );
1353             }
1354         }
1355         RegCloseKey( key );
1356     }
1357     if (!got_from_reg && (envproxy = getenv( "http_proxy" )))
1358     {
1359         char *colon, *http_proxy;
1360
1361         if ((colon = strchr( envproxy, ':' )))
1362         {
1363             if (*(colon + 1) == '/' && *(colon + 2) == '/')
1364             {
1365                 static const char http[] = "http://";
1366
1367                 /* It's a scheme, check that it's http */
1368                 if (!strncmp( envproxy, http, strlen( http ) ))
1369                     http_proxy = envproxy + strlen( http );
1370                 else
1371                 {
1372                     WARN("unsupported scheme in $http_proxy: %s\n", envproxy);
1373                     http_proxy = NULL;
1374                 }
1375             }
1376             else
1377                 http_proxy = envproxy;
1378         }
1379         else
1380             http_proxy = envproxy;
1381         if (http_proxy)
1382         {
1383             WCHAR *http_proxyW;
1384             int len;
1385
1386             len = MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, NULL, 0 );
1387             if ((http_proxyW = GlobalAlloc( 0, len * sizeof(WCHAR))))
1388             {
1389                 MultiByteToWideChar( CP_UNIXCP, 0, http_proxy, -1, http_proxyW, len );
1390                 direct = FALSE;
1391                 info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1392                 info->lpszProxy = http_proxyW;
1393                 info->lpszProxyBypass = NULL;
1394                 TRACE("http proxy (from environment) = %s\n",
1395                     debugstr_w(info->lpszProxy));
1396             }
1397         }
1398     }
1399     if (direct)
1400     {
1401         info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
1402         info->lpszProxy       = NULL;
1403         info->lpszProxyBypass = NULL;
1404     }
1405     return TRUE;
1406 }
1407
1408 /***********************************************************************
1409  *          WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
1410  */
1411 BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config )
1412 {
1413     static const WCHAR settingsW[] =
1414         {'D','e','f','a','u','l','t','C','o','n','n','e','c','t','i','o','n','S','e','t','t','i','n','g','s',0};
1415     HKEY hkey = NULL;
1416     struct connection_settings_header *hdr = NULL;
1417     DWORD type, offset, len, size = 0;
1418     BOOL ret = FALSE;
1419
1420     TRACE("%p\n", config);
1421
1422     if (!config)
1423     {
1424         set_last_error( ERROR_INVALID_PARAMETER );
1425         return FALSE;
1426     }
1427     memset( config, 0, sizeof(*config) );
1428     config->fAutoDetect = TRUE;
1429
1430     if (RegOpenKeyExW( HKEY_CURRENT_USER, Connections, 0, KEY_READ, &hkey ) ||
1431         RegQueryValueExW( hkey, settingsW, NULL, &type, NULL, &size ) ||
1432         type != REG_BINARY || size < sizeof(struct connection_settings_header))
1433     {
1434         ret = TRUE;
1435         goto done;
1436     }
1437     if (!(hdr = heap_alloc( size ))) goto done;
1438     if (RegQueryValueExW( hkey, settingsW, NULL, &type, (BYTE *)hdr, &size ) ||
1439         hdr->magic != WININET_SETTINGS_MAGIC)
1440     {
1441         ret = TRUE;
1442         goto done;
1443     }
1444
1445     config->fAutoDetect = (hdr->flags & PROXY_AUTODETECT_SETTINGS) != 0;
1446     offset = sizeof(*hdr);
1447     if (offset + sizeof(DWORD) > size) goto done;
1448     len = *(DWORD *)((char *)hdr + offset);
1449     offset += sizeof(DWORD);
1450     if (len && hdr->flags & PROXY_TYPE_PROXY)
1451     {
1452         if (!(config->lpszProxy = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
1453         copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszProxy );
1454     }
1455     offset += len;
1456     if (offset + sizeof(DWORD) > size) goto done;
1457     len = *(DWORD *)((char *)hdr + offset);
1458     offset += sizeof(DWORD);
1459     if (len && (hdr->flags & PROXY_TYPE_PROXY))
1460     {
1461         if (!(config->lpszProxyBypass = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
1462         copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszProxyBypass );
1463     }
1464     offset += len;
1465     if (offset + sizeof(DWORD) > size) goto done;
1466     len = *(DWORD *)((char *)hdr + offset);
1467     offset += sizeof(DWORD);
1468     if (len && (hdr->flags & PROXY_USE_PAC_SCRIPT))
1469     {
1470         if (!(config->lpszAutoConfigUrl = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
1471         copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszAutoConfigUrl );
1472     }
1473     ret = TRUE;
1474
1475 done:
1476     RegCloseKey( hkey );
1477     heap_free( hdr );
1478     if (!ret)
1479     {
1480         heap_free( config->lpszAutoConfigUrl );
1481         config->lpszAutoConfigUrl = NULL;
1482         heap_free( config->lpszProxy );
1483         config->lpszProxy = NULL;
1484         heap_free( config->lpszProxyBypass );
1485         config->lpszProxyBypass = NULL;
1486     }
1487     return ret;
1488 }
1489
1490 static HRESULT WINAPI dispex_QueryInterface(
1491     IDispatchEx *iface, REFIID riid, void **ppv )
1492 {
1493     *ppv = NULL;
1494
1495     if (IsEqualGUID( riid, &IID_IUnknown )  ||
1496         IsEqualGUID( riid, &IID_IDispatch ) ||
1497         IsEqualGUID( riid, &IID_IDispatchEx ))
1498         *ppv = iface;
1499     else
1500         return E_NOINTERFACE;
1501
1502     return S_OK;
1503 }
1504
1505 static ULONG WINAPI dispex_AddRef(
1506     IDispatchEx *iface )
1507 {
1508     return 2;
1509 }
1510
1511 static ULONG WINAPI dispex_Release(
1512     IDispatchEx *iface )
1513 {
1514     return 1;
1515 }
1516
1517 static HRESULT WINAPI dispex_GetTypeInfoCount(
1518     IDispatchEx *iface, UINT *info )
1519 {
1520     return E_NOTIMPL;
1521 }
1522
1523 static HRESULT WINAPI dispex_GetTypeInfo(
1524     IDispatchEx *iface, UINT info, LCID lcid, ITypeInfo **type_info )
1525 {
1526     return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI dispex_GetIDsOfNames(
1530     IDispatchEx *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *id )
1531 {
1532     return E_NOTIMPL;
1533 }
1534
1535 static HRESULT WINAPI dispex_Invoke(
1536     IDispatchEx *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
1537     DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep, UINT *err )
1538 {
1539     return E_NOTIMPL;
1540 }
1541
1542 static HRESULT WINAPI dispex_DeleteMemberByName(
1543     IDispatchEx *iface, BSTR name, DWORD flags )
1544 {
1545     return E_NOTIMPL;
1546 }
1547
1548 static HRESULT WINAPI dispex_DeleteMemberByDispID(
1549     IDispatchEx *iface, DISPID id )
1550 {
1551     return E_NOTIMPL;
1552 }
1553
1554 static HRESULT WINAPI dispex_GetMemberProperties(
1555     IDispatchEx *iface, DISPID id, DWORD flags_fetch, DWORD *flags )
1556 {
1557     return E_NOTIMPL;
1558 }
1559
1560 static HRESULT WINAPI dispex_GetMemberName(
1561     IDispatchEx *iface, DISPID id, BSTR *name )
1562 {
1563     return E_NOTIMPL;
1564 }
1565
1566 static HRESULT WINAPI dispex_GetNextDispID(
1567     IDispatchEx *iface, DWORD flags, DISPID id, DISPID *next )
1568 {
1569     return E_NOTIMPL;
1570 }
1571
1572 static HRESULT WINAPI dispex_GetNameSpaceParent(
1573     IDispatchEx *iface, IUnknown **unk )
1574 {
1575     return E_NOTIMPL;
1576 }
1577
1578 #define DISPID_GLOBAL_DNSRESOLVE  0x1000
1579
1580 static HRESULT WINAPI dispex_GetDispID(
1581     IDispatchEx *iface, BSTR name, DWORD flags, DISPID *id )
1582 {
1583     if (!strcmpW( name, dns_resolveW ))
1584     {
1585         *id = DISPID_GLOBAL_DNSRESOLVE;
1586         return S_OK;
1587     }
1588     return DISP_E_UNKNOWNNAME;
1589 }
1590
1591 static HRESULT dns_resolve( const WCHAR *hostname, VARIANT *result )
1592 {
1593 #ifdef HAVE_GETADDRINFO
1594         static const WCHAR fmtW[] = {'%','u','.','%','u','.','%','u','.','%','u',0};
1595         WCHAR addr[16];
1596         struct addrinfo *ai, *elem;
1597         char *hostnameA;
1598         int res;
1599
1600         if (hostname[0])
1601             hostnameA = strdupWA( hostname );
1602         else
1603             hostnameA = get_computer_name( ComputerNamePhysicalDnsFullyQualified );
1604
1605         if (!hostnameA) return E_OUTOFMEMORY;
1606         res = getaddrinfo( hostnameA, NULL, NULL, &ai );
1607         heap_free( hostnameA );
1608         if (res) return S_FALSE;
1609
1610         elem = ai;
1611         while (elem && elem->ai_family != AF_INET) elem = elem->ai_next;
1612         if (!elem)
1613         {
1614             freeaddrinfo( ai );
1615             return S_FALSE;
1616         }
1617         printf_addr( fmtW, addr, (struct sockaddr_in *)elem->ai_addr );
1618         freeaddrinfo( ai );
1619         V_VT( result ) = VT_BSTR;
1620         V_BSTR( result ) = SysAllocString( addr );
1621         return S_OK;
1622 #else
1623         FIXME("getaddrinfo not found at build time\n");
1624         return S_FALSE;
1625 #endif
1626 }
1627
1628 static HRESULT WINAPI dispex_InvokeEx(
1629     IDispatchEx *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
1630     VARIANT *result, EXCEPINFO *exep, IServiceProvider *caller )
1631 {
1632     if (id == DISPID_GLOBAL_DNSRESOLVE)
1633     {
1634         if (params->cArgs != 1) return DISP_E_BADPARAMCOUNT;
1635         if (V_VT(&params->rgvarg[0]) != VT_BSTR) return DISP_E_BADVARTYPE;
1636         return dns_resolve( V_BSTR(&params->rgvarg[0]), result );
1637     }
1638     return DISP_E_MEMBERNOTFOUND;
1639 }
1640
1641 static const IDispatchExVtbl dispex_vtbl =
1642 {
1643     dispex_QueryInterface,
1644     dispex_AddRef,
1645     dispex_Release,
1646     dispex_GetTypeInfoCount,
1647     dispex_GetTypeInfo,
1648     dispex_GetIDsOfNames,
1649     dispex_Invoke,
1650     dispex_GetDispID,
1651     dispex_InvokeEx,
1652     dispex_DeleteMemberByName,
1653     dispex_DeleteMemberByDispID,
1654     dispex_GetMemberProperties,
1655     dispex_GetMemberName,
1656     dispex_GetNextDispID,
1657     dispex_GetNameSpaceParent
1658 };
1659
1660 static IDispatchEx global_dispex = { &dispex_vtbl };
1661
1662 static HRESULT WINAPI site_QueryInterface(
1663     IActiveScriptSite *iface, REFIID riid, void **ppv )
1664 {
1665     *ppv = NULL;
1666
1667     if (IsEqualGUID( &IID_IUnknown, riid ))
1668         *ppv = iface;
1669     else if (IsEqualGUID( &IID_IActiveScriptSite, riid ))
1670         *ppv = iface;
1671     else
1672         return E_NOINTERFACE;
1673
1674     IUnknown_AddRef( (IUnknown *)*ppv );
1675     return S_OK;
1676 }
1677
1678 static ULONG WINAPI site_AddRef(
1679     IActiveScriptSite *iface )
1680 {
1681     return 2;
1682 }
1683
1684 static ULONG WINAPI site_Release(
1685     IActiveScriptSite *iface )
1686 {
1687     return 1;
1688 }
1689
1690 static HRESULT WINAPI site_GetLCID(
1691     IActiveScriptSite *iface, LCID *lcid )
1692 {
1693     return E_NOTIMPL;
1694 }
1695
1696 static HRESULT WINAPI site_GetItemInfo(
1697     IActiveScriptSite *iface, LPCOLESTR name, DWORD mask,
1698     IUnknown **item, ITypeInfo **type_info )
1699 {
1700     if (!strcmpW( name, global_funcsW ) && mask == SCRIPTINFO_IUNKNOWN)
1701     {
1702         *item = (IUnknown *)&global_dispex;
1703         return S_OK;
1704     }
1705     return E_NOTIMPL;
1706 }
1707
1708 static HRESULT WINAPI site_GetDocVersionString(
1709     IActiveScriptSite *iface, BSTR *version )
1710 {
1711     return E_NOTIMPL;
1712 }
1713
1714 static HRESULT WINAPI site_OnScriptTerminate(
1715     IActiveScriptSite *iface, const VARIANT *result, const EXCEPINFO *info )
1716 {
1717     return E_NOTIMPL;
1718 }
1719
1720 static HRESULT WINAPI site_OnStateChange(
1721     IActiveScriptSite *iface, SCRIPTSTATE state )
1722 {
1723     return E_NOTIMPL;
1724 }
1725
1726 static HRESULT WINAPI site_OnScriptError(
1727     IActiveScriptSite *iface, IActiveScriptError *error )
1728 {
1729     return E_NOTIMPL;
1730 }
1731
1732 static HRESULT WINAPI site_OnEnterScript(
1733     IActiveScriptSite *iface )
1734 {
1735     return E_NOTIMPL;
1736 }
1737
1738 static HRESULT WINAPI site_OnLeaveScript(
1739     IActiveScriptSite *iface )
1740 {
1741     return E_NOTIMPL;
1742 }
1743
1744 static const IActiveScriptSiteVtbl site_vtbl =
1745 {
1746     site_QueryInterface,
1747     site_AddRef,
1748     site_Release,
1749     site_GetLCID,
1750     site_GetItemInfo,
1751     site_GetDocVersionString,
1752     site_OnScriptTerminate,
1753     site_OnStateChange,
1754     site_OnScriptError,
1755     site_OnEnterScript,
1756     site_OnLeaveScript
1757 };
1758
1759 static IActiveScriptSite script_site = { &site_vtbl };
1760
1761 static BOOL parse_script_result( VARIANT result, WINHTTP_PROXY_INFO *info )
1762 {
1763     static const WCHAR proxyW[] = {'P','R','O','X','Y'};
1764     const WCHAR *p;
1765     WCHAR *q;
1766     int len;
1767
1768     info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
1769     info->lpszProxy       = NULL;
1770     info->lpszProxyBypass = NULL;
1771
1772     if (V_VT( &result ) != VT_BSTR) return TRUE;
1773     TRACE("%s\n", debugstr_w( V_BSTR( &result ) ));
1774
1775     p = V_BSTR( &result );
1776     while (*p == ' ') p++;
1777     len = strlenW( p );
1778     if (len >= 5 && !memicmpW( p, proxyW, sizeof(proxyW)/sizeof(WCHAR) ))
1779     {
1780         p += 5;
1781         while (*p == ' ') p++;
1782         if (!*p || *p == ';') return TRUE;
1783         if (!(info->lpszProxy = q = strdupW( p ))) return FALSE;
1784         info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1785         for (; *q; q++)
1786         {
1787             if (*q == ' ' || *q == ';')
1788             {
1789                 *q = 0;
1790                 break;
1791             }
1792         }
1793     }
1794     return TRUE;
1795 }
1796
1797 static BSTR include_pac_utils( BSTR script )
1798 {
1799     static const WCHAR pacjsW[] = {'p','a','c','.','j','s',0};
1800     HMODULE hmod = GetModuleHandleA( "winhttp.dll" );
1801     HRSRC rsrc;
1802     DWORD size;
1803     const char *data;
1804     BSTR ret;
1805     int len;
1806
1807     if (!(rsrc = FindResourceW( hmod, pacjsW, (LPCWSTR)40 ))) return NULL;
1808     size = SizeofResource( hmod, rsrc );
1809     data = LoadResource( hmod, rsrc );
1810
1811     len = MultiByteToWideChar( CP_ACP, 0, data, size, NULL, 0 );
1812     if (!(ret = SysAllocStringLen( NULL, len + SysStringLen( script ) + 1 ))) return NULL;
1813     MultiByteToWideChar( CP_ACP, 0, data, size, ret, len );
1814     ret[len] = 0;
1815     strcatW( ret, script );
1816     return ret;
1817 }
1818
1819 static BOOL run_script( const BSTR script, const WCHAR *url, WINHTTP_PROXY_INFO *info )
1820 {
1821     static const WCHAR jscriptW[] = {'J','S','c','r','i','p','t',0};
1822     static const WCHAR findproxyW[] = {'F','i','n','d','P','r','o','x','y','F','o','r','U','R','L',0};
1823     IActiveScriptParse *parser = NULL;
1824     IActiveScript *engine = NULL;
1825     IDispatch *dispatch = NULL;
1826     BOOL ret = FALSE;
1827     CLSID clsid;
1828     DISPID dispid;
1829     BSTR func = NULL, hostname = NULL, full_script = NULL;
1830     URL_COMPONENTSW uc;
1831     VARIANT args[2], result;
1832     DISPPARAMS params;
1833     HRESULT hr, init;
1834
1835     memset( &uc, 0, sizeof(uc) );
1836     uc.dwStructSize = sizeof(uc);
1837     if (!WinHttpCrackUrl( url, 0, 0, &uc )) return FALSE;
1838     if (!(hostname = SysAllocStringLen( NULL, uc.dwHostNameLength + 1 ))) return FALSE;
1839     memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
1840     hostname[uc.dwHostNameLength] = 0;
1841
1842     init = CoInitialize( NULL );
1843     hr = CLSIDFromProgID( jscriptW, &clsid );
1844     if (hr != S_OK) goto done;
1845
1846     hr = CoCreateInstance( &clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1847                            &IID_IActiveScript, (void **)&engine );
1848     if (hr != S_OK) goto done;
1849
1850     hr = IActiveScript_QueryInterface( engine, &IID_IActiveScriptParse, (void **)&parser );
1851     if (hr != S_OK) goto done;
1852
1853     hr = IActiveScriptParse64_InitNew( parser );
1854     if (hr != S_OK) goto done;
1855
1856     hr = IActiveScript_SetScriptSite( engine, &script_site );
1857     if (hr != S_OK) goto done;
1858
1859     hr = IActiveScript_AddNamedItem( engine, global_funcsW, SCRIPTITEM_GLOBALMEMBERS );
1860     if (hr != S_OK) goto done;
1861
1862     if (!(full_script = include_pac_utils( script ))) goto done;
1863
1864     hr = IActiveScriptParse64_ParseScriptText( parser, full_script, NULL, NULL, NULL, 0, 0, 0, NULL, NULL );
1865     if (hr != S_OK) goto done;
1866
1867     hr = IActiveScript_SetScriptState( engine, SCRIPTSTATE_STARTED );
1868     if (hr != S_OK) goto done;
1869
1870     hr = IActiveScript_GetScriptDispatch( engine, NULL, &dispatch );
1871     if (hr != S_OK) goto done;
1872
1873     if (!(func = SysAllocString( findproxyW ))) goto done;
1874     hr = IDispatch_GetIDsOfNames( dispatch, &IID_NULL, &func, 1, LOCALE_SYSTEM_DEFAULT, &dispid );
1875     if (hr != S_OK) goto done;
1876
1877     V_VT( &args[0] ) = VT_BSTR;
1878     V_BSTR( &args[0] ) = hostname;
1879     V_VT( &args[1] ) = VT_BSTR;
1880     V_BSTR( &args[1] ) = SysAllocString( url );
1881
1882     params.rgvarg = args;
1883     params.rgdispidNamedArgs = NULL;
1884     params.cArgs = 2;
1885     params.cNamedArgs = 0;
1886     hr = IDispatch_Invoke( dispatch, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
1887                            &params, &result, NULL, NULL );
1888     VariantClear( &args[1] );
1889     if (hr != S_OK)
1890     {
1891         WARN("script failed 0x%08x\n", hr);
1892         goto done;
1893     }
1894     ret = parse_script_result( result, info );
1895
1896 done:
1897     SysFreeString( full_script );
1898     SysFreeString( hostname );
1899     SysFreeString( func );
1900     if (dispatch) IDispatch_Release( dispatch );
1901     if (parser) IUnknown_Release( parser );
1902     if (engine) IActiveScript_Release( engine );
1903     if (SUCCEEDED( init )) CoUninitialize();
1904     if (!ret) set_last_error( ERROR_WINHTTP_BAD_AUTO_PROXY_SCRIPT );
1905     return ret;
1906 }
1907
1908 static BSTR download_script( HINTERNET ses, const WCHAR *url )
1909 {
1910     static const WCHAR typeW[] = {'*','/','*',0};
1911     static const WCHAR *acceptW[] = {typeW, NULL};
1912     HINTERNET con, req = NULL;
1913     WCHAR *hostname;
1914     URL_COMPONENTSW uc;
1915     DWORD size = 4096, offset, to_read, bytes_read, flags = 0;
1916     char *tmp, *buffer = NULL;
1917     BSTR script = NULL;
1918     int len;
1919
1920     memset( &uc, 0, sizeof(uc) );
1921     uc.dwStructSize = sizeof(uc);
1922     if (!WinHttpCrackUrl( url, 0, 0, &uc )) return NULL;
1923     if (!(hostname = heap_alloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) return NULL;
1924     memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
1925     hostname[uc.dwHostNameLength] = 0;
1926
1927     if (!(con = WinHttpConnect( ses, hostname, uc.nPort, 0 ))) goto done;
1928     if (uc.nScheme == INTERNET_SCHEME_HTTPS) flags |= WINHTTP_FLAG_SECURE;
1929     if (!(req = WinHttpOpenRequest( con, NULL, uc.lpszUrlPath, NULL, NULL, acceptW, flags ))) goto done;
1930     if (!WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 )) goto done;
1931     if (!(WinHttpReceiveResponse( req, 0 ))) goto done;
1932
1933     if (!(buffer = heap_alloc( size ))) goto done;
1934     to_read = size;
1935     offset = 0;
1936     for (;;)
1937     {
1938         if (!WinHttpReadData( req, buffer + offset, to_read, &bytes_read )) goto done;
1939         if (!bytes_read) break;
1940         to_read -= bytes_read;
1941         offset += bytes_read;
1942         if (!to_read)
1943         {
1944             to_read = size;
1945             size *= 2;
1946             if (!(tmp = heap_realloc( buffer, size ))) goto done;
1947             buffer = tmp;
1948         }
1949     }
1950     len = MultiByteToWideChar( CP_ACP, 0, buffer, offset, NULL, 0 );
1951     if (!(script = SysAllocStringLen( NULL, len ))) goto done;
1952     MultiByteToWideChar( CP_ACP, 0, buffer, offset, script, len );
1953     script[len] = 0;
1954
1955 done:
1956     WinHttpCloseHandle( req );
1957     WinHttpCloseHandle( con );
1958     heap_free( buffer );
1959     heap_free( hostname );
1960     if (!script) set_last_error( ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT );
1961     return script;
1962 }
1963
1964 /***********************************************************************
1965  *          WinHttpGetProxyForUrl (winhttp.@)
1966  */
1967 BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
1968                                    WINHTTP_PROXY_INFO *info )
1969 {
1970     WCHAR *detected_pac_url = NULL;
1971     const WCHAR *pac_url;
1972     session_t *session;
1973     BSTR script;
1974     BOOL ret = FALSE;
1975
1976     TRACE("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
1977
1978     if (!(session = (session_t *)grab_object( hsession )))
1979     {
1980         set_last_error( ERROR_INVALID_HANDLE );
1981         return FALSE;
1982     }
1983     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
1984     {
1985         release_object( &session->hdr );
1986         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1987         return FALSE;
1988     }
1989     if (!url || !options || !info ||
1990         !(options->dwFlags & (WINHTTP_AUTOPROXY_AUTO_DETECT|WINHTTP_AUTOPROXY_CONFIG_URL)) ||
1991         ((options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT) && !options->dwAutoDetectFlags) ||
1992         ((options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT) &&
1993          (options->dwFlags & WINHTTP_AUTOPROXY_CONFIG_URL)))
1994     {
1995         release_object( &session->hdr );
1996         set_last_error( ERROR_INVALID_PARAMETER );
1997         return FALSE;
1998     }
1999     if (options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT &&
2000         !WinHttpDetectAutoProxyConfigUrl( options->dwAutoDetectFlags, &detected_pac_url ))
2001     {
2002         set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR );
2003         goto done;
2004     }
2005     if (options->dwFlags & WINHTTP_AUTOPROXY_CONFIG_URL) pac_url = options->lpszAutoConfigUrl;
2006     else pac_url = detected_pac_url;
2007
2008     if (!(script = download_script( hsession, pac_url ))) goto done;
2009     ret = run_script( script, url, info );
2010     SysFreeString( script );
2011
2012 done:
2013     GlobalFree( detected_pac_url );
2014     release_object( &session->hdr );
2015     return ret;
2016 }
2017
2018 /***********************************************************************
2019  *          WinHttpSetDefaultProxyConfiguration (winhttp.@)
2020  */
2021 BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
2022 {
2023     LONG l;
2024     HKEY key;
2025     BOOL ret = FALSE;
2026     const WCHAR *src;
2027
2028     TRACE("%p\n", info);
2029
2030     if (!info)
2031     {
2032         set_last_error( ERROR_INVALID_PARAMETER );
2033         return FALSE;
2034     }
2035     switch (info->dwAccessType)
2036     {
2037     case WINHTTP_ACCESS_TYPE_NO_PROXY:
2038         break;
2039     case WINHTTP_ACCESS_TYPE_NAMED_PROXY:
2040         if (!info->lpszProxy)
2041         {
2042             set_last_error( ERROR_INVALID_PARAMETER );
2043             return FALSE;
2044         }
2045         /* Only ASCII characters are allowed */
2046         for (src = info->lpszProxy; *src; src++)
2047             if (*src > 0x7f)
2048             {
2049                 set_last_error( ERROR_INVALID_PARAMETER );
2050                 return FALSE;
2051             }
2052         if (info->lpszProxyBypass)
2053         {
2054             for (src = info->lpszProxyBypass; *src; src++)
2055                 if (*src > 0x7f)
2056                 {
2057                     set_last_error( ERROR_INVALID_PARAMETER );
2058                     return FALSE;
2059                 }
2060         }
2061         break;
2062     default:
2063         set_last_error( ERROR_INVALID_PARAMETER );
2064         return FALSE;
2065     }
2066
2067     l = RegCreateKeyExW( HKEY_LOCAL_MACHINE, Connections, 0, NULL, 0,
2068         KEY_WRITE, NULL, &key, NULL );
2069     if (!l)
2070     {
2071         DWORD size = sizeof(struct connection_settings_header) + 2 * sizeof(DWORD);
2072         BYTE *buf;
2073
2074         if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
2075         {
2076             size += strlenW( info->lpszProxy );
2077             if (info->lpszProxyBypass)
2078                 size += strlenW( info->lpszProxyBypass );
2079         }
2080         buf = heap_alloc( size );
2081         if (buf)
2082         {
2083             struct connection_settings_header *hdr =
2084                 (struct connection_settings_header *)buf;
2085             DWORD *len = (DWORD *)(hdr + 1);
2086
2087             hdr->magic = WINHTTP_SETTINGS_MAGIC;
2088             hdr->unknown = 0;
2089             if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
2090             {
2091                 BYTE *dst;
2092
2093                 hdr->flags = PROXY_TYPE_PROXY;
2094                 *len++ = strlenW( info->lpszProxy );
2095                 for (dst = (BYTE *)len, src = info->lpszProxy; *src;
2096                     src++, dst++)
2097                     *dst = *src;
2098                 len = (DWORD *)dst;
2099                 if (info->lpszProxyBypass)
2100                 {
2101                     *len++ = strlenW( info->lpszProxyBypass );
2102                     for (dst = (BYTE *)len, src = info->lpszProxyBypass; *src;
2103                         src++, dst++)
2104                         *dst = *src;
2105                 }
2106                 else
2107                     *len++ = 0;
2108             }
2109             else
2110             {
2111                 hdr->flags = PROXY_TYPE_DIRECT;
2112                 *len++ = 0;
2113                 *len++ = 0;
2114             }
2115             l = RegSetValueExW( key, WinHttpSettings, 0, REG_BINARY, buf, size );
2116             if (!l)
2117                 ret = TRUE;
2118             heap_free( buf );
2119         }
2120         RegCloseKey( key );
2121     }
2122     return ret;
2123 }
2124
2125 /***********************************************************************
2126  *          WinHttpSetStatusCallback (winhttp.@)
2127  */
2128 WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHTTP_STATUS_CALLBACK callback,
2129                                                          DWORD flags, DWORD_PTR reserved )
2130 {
2131     object_header_t *hdr;
2132     WINHTTP_STATUS_CALLBACK ret;
2133
2134     TRACE("%p, %p, 0x%08x, 0x%lx\n", handle, callback, flags, reserved);
2135
2136     if (!(hdr = grab_object( handle )))
2137     {
2138         set_last_error( ERROR_INVALID_HANDLE );
2139         return WINHTTP_INVALID_STATUS_CALLBACK;
2140     }
2141     ret = hdr->callback;
2142     hdr->callback = callback;
2143     hdr->notify_mask = flags;
2144
2145     release_object( hdr );
2146     return ret;
2147 }
2148
2149 /***********************************************************************
2150  *          WinHttpSetTimeouts (winhttp.@)
2151  */
2152 BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive )
2153 {
2154     BOOL ret = TRUE;
2155     object_header_t *hdr;
2156     request_t *request;
2157     session_t *session;
2158
2159     TRACE("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive);
2160
2161     if (resolve < -1 || connect < -1 || send < -1 || receive < -1)
2162     {
2163         set_last_error( ERROR_INVALID_PARAMETER );
2164         return FALSE;
2165     }
2166
2167     if (!(hdr = grab_object( handle )))
2168     {
2169         set_last_error( ERROR_INVALID_HANDLE );
2170         return FALSE;
2171     }
2172
2173     switch(hdr->type)
2174     {
2175         case WINHTTP_HANDLE_TYPE_REQUEST:
2176             request = (request_t *)hdr;
2177             request->connect_timeout = connect;
2178
2179             if (resolve < 0) resolve = 0;
2180             request->resolve_timeout = resolve;
2181
2182             if (send < 0) send = 0;
2183             request->send_timeout = send;
2184
2185             if (receive < 0) receive = 0;
2186             request->recv_timeout = receive;
2187
2188             if (netconn_connected( &request->netconn ))
2189             {
2190                 if (netconn_set_timeout( &request->netconn, TRUE, send )) ret = FALSE;
2191                 if (netconn_set_timeout( &request->netconn, FALSE, receive )) ret = FALSE;
2192             }
2193
2194             release_object( &request->hdr );
2195             break;
2196
2197         case WINHTTP_HANDLE_TYPE_SESSION:
2198             session = (session_t *)hdr;
2199             session->connect_timeout = connect;
2200
2201             if (resolve < 0) resolve = 0;
2202             session->resolve_timeout = resolve;
2203
2204             if (send < 0) send = 0;
2205             session->send_timeout = send;
2206
2207             if (receive < 0) receive = 0;
2208             session->recv_timeout = receive;
2209             break;
2210
2211         default:
2212             release_object( hdr );
2213             set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2214             return FALSE;
2215     }
2216     return ret;
2217 }
2218
2219 static const WCHAR wkday[7][4] =
2220     {{'S','u','n', 0}, {'M','o','n', 0}, {'T','u','e', 0}, {'W','e','d', 0},
2221      {'T','h','u', 0}, {'F','r','i', 0}, {'S','a','t', 0}};
2222 static const WCHAR month[12][4] =
2223     {{'J','a','n', 0}, {'F','e','b', 0}, {'M','a','r', 0}, {'A','p','r', 0},
2224      {'M','a','y', 0}, {'J','u','n', 0}, {'J','u','l', 0}, {'A','u','g', 0},
2225      {'S','e','p', 0}, {'O','c','t', 0}, {'N','o','v', 0}, {'D','e','c', 0}};
2226
2227 /***********************************************************************
2228  *           WinHttpTimeFromSystemTime (WININET.@)
2229  */
2230 BOOL WINAPI WinHttpTimeFromSystemTime( const SYSTEMTIME *time, LPWSTR string )
2231 {
2232     static const WCHAR format[] =
2233         {'%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
2234          '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0};
2235
2236     TRACE("%p, %p\n", time, string);
2237
2238     if (!time || !string) return FALSE;
2239
2240     sprintfW( string, format,
2241               wkday[time->wDayOfWeek],
2242               time->wDay,
2243               month[time->wMonth - 1],
2244               time->wYear,
2245               time->wHour,
2246               time->wMinute,
2247               time->wSecond );
2248
2249     return TRUE;
2250 }
2251
2252 /***********************************************************************
2253  *           WinHttpTimeToSystemTime (WININET.@)
2254  */
2255 BOOL WINAPI WinHttpTimeToSystemTime( LPCWSTR string, SYSTEMTIME *time )
2256 {
2257     unsigned int i;
2258     const WCHAR *s = string;
2259     WCHAR *end;
2260
2261     TRACE("%s, %p\n", debugstr_w(string), time);
2262
2263     if (!string || !time) return FALSE;
2264
2265     /* Windows does this too */
2266     GetSystemTime( time );
2267
2268     /*  Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
2269      *  a SYSTEMTIME structure.
2270      */
2271
2272     while (*s && !isalphaW( *s )) s++;
2273     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2274     time->wDayOfWeek = 7;
2275
2276     for (i = 0; i < 7; i++)
2277     {
2278         if (toupperW( wkday[i][0] ) == toupperW( s[0] ) &&
2279             toupperW( wkday[i][1] ) == toupperW( s[1] ) &&
2280             toupperW( wkday[i][2] ) == toupperW( s[2] ) )
2281         {
2282             time->wDayOfWeek = i;
2283             break;
2284         }
2285     }
2286
2287     if (time->wDayOfWeek > 6) return TRUE;
2288     while (*s && !isdigitW( *s )) s++;
2289     time->wDay = strtolW( s, &end, 10 );
2290     s = end;
2291
2292     while (*s && !isalphaW( *s )) s++;
2293     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2294     time->wMonth = 0;
2295
2296     for (i = 0; i < 12; i++)
2297     {
2298         if (toupperW( month[i][0]) == toupperW( s[0] ) &&
2299             toupperW( month[i][1]) == toupperW( s[1] ) &&
2300             toupperW( month[i][2]) == toupperW( s[2] ) )
2301         {
2302             time->wMonth = i + 1;
2303             break;
2304         }
2305     }
2306     if (time->wMonth == 0) return TRUE;
2307
2308     while (*s && !isdigitW( *s )) s++;
2309     if (*s == '\0') return TRUE;
2310     time->wYear = strtolW( s, &end, 10 );
2311     s = end;
2312
2313     while (*s && !isdigitW( *s )) s++;
2314     if (*s == '\0') return TRUE;
2315     time->wHour = strtolW( s, &end, 10 );
2316     s = end;
2317
2318     while (*s && !isdigitW( *s )) s++;
2319     if (*s == '\0') return TRUE;
2320     time->wMinute = strtolW( s, &end, 10 );
2321     s = end;
2322
2323     while (*s && !isdigitW( *s )) s++;
2324     if (*s == '\0') return TRUE;
2325     time->wSecond = strtolW( s, &end, 10 );
2326
2327     time->wMilliseconds = 0;
2328     return TRUE;
2329 }