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