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