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