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