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