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