dll/win32/winhttp/session.c

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