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