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