reactos/dll/win32/winhttp/session.c

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