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
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winhttp.h"
  28 #include "wincrypt.h"
  29
  30 #include "winhttp_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
  33
  34 void set_last_error( DWORD error )
  35 {
  36     /* FIXME */
  37     SetLastError( error );
  38 }
  39
  40 DWORD get_last_error( void )
  41 {
  42     /* FIXME */
  43     return GetLastError();
  44 }
  45
  46 void send_callback( object_header_t *hdr, DWORD status, LPVOID info, DWORD buflen )
  47 {
  48     TRACE("%p, 0x%08x, %p, %u\n", hdr, status, info, buflen);
  49
  50     if (hdr->notify_mask & status) hdr->callback( hdr->handle, hdr->context, status, info, buflen );
  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
  69     TRACE("%p\n", session);
  70
  71     heap_free( session->agent );
  72     heap_free( session->proxy_server );
  73     heap_free( session->proxy_bypass );
  74     heap_free( session->proxy_username );
  75     heap_free( session->proxy_password );
  76     heap_free( session );
  77 }
  78
  79 static BOOL session_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
  80 {
  81     if (!buflen)
  82     {
  83         SetLastError(ERROR_INVALID_PARAMETER);
  84         return FALSE;
  85     }
  86
  87     switch (option)
  88     {
  89     case WINHTTP_OPTION_REDIRECT_POLICY:
  90     {
  91         if (!buffer || *buflen < sizeof(DWORD))
  92         {
  93             *buflen = sizeof(DWORD);
  94             SetLastError(ERROR_INSUFFICIENT_BUFFER);
  95             return FALSE;
  96         }
  97
  98         *(DWORD *)buffer = hdr->redirect_policy;
  99         *buflen = sizeof(DWORD);
 100         return TRUE;
 101     }
 102     default:
 103         FIXME("unimplemented option %u\n", option);
 104         SetLastError(ERROR_INVALID_PARAMETER);
 105         return FALSE;
 106     }
 107 }
 108
 109 static BOOL session_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 110 {
 111     if (!buffer)
 112     {
 113         SetLastError(ERROR_INVALID_PARAMETER);
 114         return FALSE;
 115     }
 116
 117     switch (option)
 118     {
 119     case WINHTTP_OPTION_PROXY:
 120     {
 121         WINHTTP_PROXY_INFO *pi = buffer;
 122
 123         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
 124         return TRUE;
 125     }
 126     case WINHTTP_OPTION_REDIRECT_POLICY:
 127     {
 128         DWORD policy;
 129
 130         if (buflen != sizeof(policy))
 131         {
 132             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 133             return FALSE;
 134         }
 135
 136         policy = *(DWORD *)buffer;
 137         TRACE("0x%x\n", policy);
 138         hdr->redirect_policy = policy;
 139         return TRUE;
 140     }
 141     case WINHTTP_OPTION_DISABLE_FEATURE:
 142         SetLastError(ERROR_WINHTTP_INCORRECT_HANDLE_TYPE);
 143         return FALSE;
 144     default:
 145         FIXME("unimplemented option %u\n", option);
 146         SetLastError(ERROR_INVALID_PARAMETER);
 147         return FALSE;
 148     }
 149 }
 150
 151 static const object_vtbl_t session_vtbl =
 152 {
 153     session_destroy,
 154     session_query_option,
 155     session_set_option
 156 };
 157
 158 /***********************************************************************
 159  *          WinHttpOpen (winhttp.@)
 160  */
 161 HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags )
 162 {
 163     session_t *session;
 164     HINTERNET handle = NULL;
 165
 166     TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags);
 167
 168     if (!(session = heap_alloc_zero( sizeof(session_t) ))) return NULL;
 169
 170     session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
 171     session->hdr.vtbl = &session_vtbl;
 172     session->hdr.flags = flags;
 173     session->hdr.refs = 1;
 174     session->access = access;
 175     session->hdr.redirect_policy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
 176
 177     if (agent && !(session->agent = strdupW( agent ))) goto end;
 178     if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
 179     if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end;
 180
 181     if (!(handle = alloc_handle( &session->hdr ))) goto end;
 182     session->hdr.handle = handle;
 183
 184 end:
 185     release_object( &session->hdr );
 186     TRACE("returning %p\n", handle);
 187     return handle;
 188 }
 189
 190 /***********************************************************************
 191  *          connect_destroy (internal)
 192  */
 193 static void connect_destroy( object_header_t *hdr )
 194 {
 195     connect_t *connect = (connect_t *)hdr;
 196
 197     TRACE("%p\n", connect);
 198
 199     release_object( &connect->session->hdr );
 200
 201     heap_free( connect->hostname );
 202     heap_free( connect->servername );
 203     heap_free( connect->username );
 204     heap_free( connect->password );
 205     heap_free( connect );
 206 }
 207
 208 static const object_vtbl_t connect_vtbl =
 209 {
 210     connect_destroy,
 211     NULL,
 212     NULL
 213 };
 214
 215 /***********************************************************************
 216  *          WinHttpConnect (winhttp.@)
 217  */
 218 HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved )
 219 {
 220     connect_t *connect;
 221     session_t *session;
 222     HINTERNET hconnect = NULL;
 223
 224     TRACE("%p, %s, %u, %x\n", hsession, debugstr_w(server), port, reserved);
 225
 226     if (!server)
 227     {
 228         set_last_error( ERROR_INVALID_PARAMETER );
 229         return NULL;
 230     }
 231     if (!(session = (session_t *)grab_object( hsession )))
 232     {
 233         set_last_error( ERROR_INVALID_HANDLE );
 234         return NULL;
 235     }
 236     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
 237     {
 238         release_object( &session->hdr );
 239         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 240         return NULL;
 241     }
 242     if (!(connect = heap_alloc_zero( sizeof(connect_t) )))
 243     {
 244         release_object( &session->hdr );
 245         return NULL;
 246     }
 247     connect->hdr.type = WINHTTP_HANDLE_TYPE_CONNECT;
 248     connect->hdr.vtbl = &connect_vtbl;
 249     connect->hdr.refs = 1;
 250     connect->hdr.flags = session->hdr.flags;
 251     connect->hdr.callback = session->hdr.callback;
 252     connect->hdr.notify_mask = session->hdr.notify_mask;
 253     connect->hdr.context = session->hdr.context;
 254
 255     addref_object( &session->hdr );
 256     connect->session = session;
 257     list_add_head( &session->hdr.children, &connect->hdr.entry );
 258
 259     if (server && !(connect->hostname = strdupW( server ))) goto end;
 260     connect->hostport = port ? port : (connect->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
 261
 262     if (server && !(connect->servername = strdupW( server ))) goto end;
 263     connect->serverport = port ? port : (connect->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
 264
 265     if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
 266     connect->hdr.handle = hconnect;
 267
 268     send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
 269
 270 end:
 271     release_object( &connect->hdr );
 272
 273     TRACE("returning %p\n", hconnect);
 274     return hconnect;
 275 }
 276
 277 /***********************************************************************
 278  *          request_destroy (internal)
 279  */
 280 static void request_destroy( object_header_t *hdr )
 281 {
 282     request_t *request = (request_t *)hdr;
 283     int i;
 284
 285     TRACE("%p\n", request);
 286
 287     release_object( &request->connect->hdr );
 288
 289     heap_free( request->verb );
 290     heap_free( request->path );
 291     heap_free( request->version );
 292     heap_free( request->raw_headers );
 293     heap_free( request->status_text );
 294     for (i = 0; i < request->num_headers; i++)
 295     {
 296         heap_free( request->headers[i].field );
 297         heap_free( request->headers[i].value );
 298     }
 299     heap_free( request->headers );
 300     heap_free( request );
 301 }
 302
 303 static BOOL request_query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 304 {
 305     if (!buflen)
 306     {
 307         SetLastError(ERROR_INVALID_PARAMETER);
 308         return FALSE;
 309     }
 310
 311     switch (option)
 312     {
 313     case WINHTTP_OPTION_SECURITY_FLAGS:
 314     {
 315         DWORD flags;
 316
 317         if (!buffer || *buflen < sizeof(flags))
 318         {
 319             *buflen = sizeof(flags);
 320             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 321             return FALSE;
 322         }
 323
 324         flags = 0;
 325         if (hdr->flags & WINHTTP_FLAG_SECURE) flags |= SECURITY_FLAG_SECURE;
 326         *(DWORD *)buffer = flags;
 327         *buflen = sizeof(flags);
 328         return TRUE;
 329     }
 330     case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
 331     {
 332         const CERT_CONTEXT *cert;
 333         request_t *request = (request_t *)hdr;
 334
 335         if (!buffer || *buflen < sizeof(cert))
 336         {
 337             *buflen = sizeof(cert);
 338             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 339             return FALSE;
 340         }
 341
 342         if (!(cert = netconn_get_certificate( &request->netconn ))) return FALSE;
 343         *(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
 344         *buflen = sizeof(cert);
 345         return TRUE;
 346     }
 347     case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
 348     {
 349         if (!buffer || *buflen < sizeof(DWORD))
 350         {
 351             *buflen = sizeof(DWORD);
 352             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 353             return FALSE;
 354         }
 355
 356         *(DWORD *)buffer = 128; /* FIXME */
 357         *buflen = sizeof(DWORD);
 358         return TRUE;
 359     }
 360     default:
 361         FIXME("unimplemented option %u\n", option);
 362         SetLastError(ERROR_INVALID_PARAMETER);
 363         return FALSE;
 364     }
 365 }
 366
 367 static BOOL request_set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 368 {
 369     if (!buffer)
 370     {
 371         SetLastError(ERROR_INVALID_PARAMETER);
 372         return FALSE;
 373     }
 374
 375     switch (option)
 376     {
 377     case WINHTTP_OPTION_PROXY:
 378     {
 379         WINHTTP_PROXY_INFO *pi = buffer;
 380
 381         FIXME("%u %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass));
 382         return TRUE;
 383     }
 384     case WINHTTP_OPTION_DISABLE_FEATURE:
 385     {
 386         DWORD disable = *(DWORD *)buffer;
 387
 388         if (buflen != sizeof(DWORD))
 389         {
 390             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 391             return FALSE;
 392         }
 393
 394         TRACE("0x%x\n", disable);
 395         hdr->disable_flags &= disable;
 396         return TRUE;
 397     }
 398     case WINHTTP_OPTION_AUTOLOGON_POLICY:
 399     {
 400         DWORD policy = *(DWORD *)buffer;
 401
 402         if (buflen != sizeof(DWORD))
 403         {
 404             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 405             return FALSE;
 406         }
 407
 408         TRACE("0x%x\n", policy);
 409         hdr->logon_policy = policy;
 410         return TRUE;
 411     }
 412     case WINHTTP_OPTION_REDIRECT_POLICY:
 413     {
 414         DWORD policy = *(DWORD *)buffer;
 415
 416         if (buflen != sizeof(DWORD))
 417         {
 418             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 419             return FALSE;
 420         }
 421
 422         TRACE("0x%x\n", policy);
 423         hdr->redirect_policy = policy;
 424         return TRUE;
 425     }
 426     default:
 427         FIXME("unimplemented option %u\n", option);
 428         SetLastError(ERROR_INVALID_PARAMETER);
 429         return TRUE;
 430     }
 431 }
 432
 433 static const object_vtbl_t request_vtbl =
 434 {
 435     request_destroy,
 436     request_query_option,
 437     request_set_option
 438 };
 439
 440 /***********************************************************************
 441  *          WinHttpOpenRequest (winhttp.@)
 442  */
 443 HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version,
 444                                      LPCWSTR referrer, LPCWSTR *types, DWORD flags )
 445 {
 446     request_t *request;
 447     connect_t *connect;
 448     HINTERNET hrequest = NULL;
 449
 450     TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect, debugstr_w(verb), debugstr_w(object),
 451           debugstr_w(version), debugstr_w(referrer), types, flags);
 452
 453     if (!(connect = (connect_t *)grab_object( hconnect )))
 454     {
 455         set_last_error( ERROR_INVALID_HANDLE );
 456         return NULL;
 457     }
 458     if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
 459     {
 460         release_object( &connect->hdr );
 461         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 462         return NULL;
 463     }
 464     if (!(request = heap_alloc_zero( sizeof(request_t) )))
 465     {
 466         release_object( &connect->hdr );
 467         return NULL;
 468     }
 469     request->hdr.type = WINHTTP_HANDLE_TYPE_REQUEST;
 470     request->hdr.vtbl = &request_vtbl;
 471     request->hdr.refs = 1;
 472     request->hdr.flags = flags;
 473     request->hdr.callback = connect->hdr.callback;
 474     request->hdr.notify_mask = connect->hdr.notify_mask;
 475     request->hdr.context = connect->hdr.context;
 476
 477     addref_object( &connect->hdr );
 478     request->connect = connect;
 479     list_add_head( &connect->hdr.children, &request->hdr.entry );
 480
 481     if (!netconn_init( &request->netconn, request->hdr.flags & WINHTTP_FLAG_SECURE )) goto end;
 482
 483     if (!verb || !verb[0]) verb = getW;
 484     if (!object || !object[0]) object = slashW;
 485     if (!version || !version[0]) version = http1_1;
 486
 487     if (!(request->verb = strdupW( verb ))) goto end;
 488     if (!(request->path = strdupW( object ))) goto end;
 489     if (!(request->version = strdupW( version ))) goto end;
 490
 491     if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
 492     request->hdr.handle = hrequest;
 493
 494     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
 495
 496 end:
 497     release_object( &request->hdr );
 498
 499     TRACE("returning %p\n", hrequest);
 500     return hrequest;
 501 }
 502
 503 /***********************************************************************
 504  *          WinHttpCloseHandle (winhttp.@)
 505  */
 506 BOOL WINAPI WinHttpCloseHandle( HINTERNET handle )
 507 {
 508     object_header_t *hdr;
 509
 510     TRACE("%p\n", handle);
 511
 512     if (!(hdr = grab_object( handle )))
 513     {
 514         set_last_error( ERROR_INVALID_HANDLE );
 515         return FALSE;
 516     }
 517     release_object( hdr );
 518     free_handle( handle );
 519     return TRUE;
 520 }
 521
 522 static BOOL query_option( object_header_t *hdr, DWORD option, LPVOID buffer, LPDWORD buflen )
 523 {
 524     BOOL ret = FALSE;
 525
 526     switch (option)
 527     {
 528     case WINHTTP_OPTION_CONTEXT_VALUE:
 529     {
 530         *(DWORD_PTR *)buffer = hdr->context;
 531         *buflen = sizeof(DWORD_PTR);
 532         return TRUE;
 533     }
 534     default:
 535         if (hdr->vtbl->query_option) ret = hdr->vtbl->query_option( hdr, option, buffer, buflen );
 536         else
 537         {
 538             FIXME("unimplemented option %u\n", option);
 539             SetLastError(ERROR_WINHTTP_INCORRECT_HANDLE_TYPE);
 540             return FALSE;
 541         }
 542         break;
 543     }
 544     return ret;
 545 }
 546
 547 /***********************************************************************
 548  *          WinHttpQueryOption (winhttp.@)
 549  */
 550 BOOL WINAPI WinHttpQueryOption( HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen )
 551 {
 552     BOOL ret = FALSE;
 553     object_header_t *hdr;
 554
 555     TRACE("%p, %u, %p, %p\n", handle, option, buffer, buflen);
 556
 557     if (!(hdr = grab_object( handle )))
 558     {
 559         set_last_error( ERROR_INVALID_HANDLE );
 560         return FALSE;
 561     }
 562
 563     ret = query_option( hdr, option, buffer, buflen );
 564
 565     release_object( hdr );
 566     return ret;
 567 }
 568
 569 static BOOL set_option( object_header_t *hdr, DWORD option, LPVOID buffer, DWORD buflen )
 570 {
 571     BOOL ret = TRUE;
 572
 573     switch (option)
 574     {
 575     case WINHTTP_OPTION_CONTEXT_VALUE:
 576     {
 577         hdr->context = *(DWORD_PTR *)buffer;
 578         return TRUE;
 579     }
 580     default:
 581         if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option, buffer, buflen );
 582         else
 583         {
 584             FIXME("unimplemented option %u\n", option);
 585             SetLastError(ERROR_WINHTTP_INCORRECT_HANDLE_TYPE);
 586             return FALSE;
 587         }
 588         break;
 589     }
 590     return ret;
 591 }
 592
 593 /***********************************************************************
 594  *          WinHttpSetOption (winhttp.@)
 595  */
 596 BOOL WINAPI WinHttpSetOption( HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen )
 597 {
 598     BOOL ret = FALSE;
 599     object_header_t *hdr;
 600
 601     TRACE("%p, %u, %p, %u\n", handle, option, buffer, buflen);
 602
 603     if (!(hdr = grab_object( handle )))
 604     {
 605         set_last_error( ERROR_INVALID_HANDLE );
 606         return FALSE;
 607     }
 608
 609     ret = set_option( hdr, option, buffer, buflen );
 610
 611     release_object( hdr );
 612     return ret;
 613 }
 614
 615 /***********************************************************************
 616  *          WinHttpDetectAutoProxyConfigUrl (winhttp.@)
 617  */
 618 BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url )
 619 {
 620     FIXME("0x%08x, %p\n", flags, url);
 621
 622     set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED );
 623     return FALSE;
 624 }
 625
 626 /***********************************************************************
 627  *          WinHttpGetDefaultProxyConfiguration (winhttp.@)
 628  */
 629 BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
 630 {
 631     FIXME("%p\n", info);
 632
 633     info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
 634     info->lpszProxy       = NULL;
 635     info->lpszProxyBypass = NULL;
 636
 637     return TRUE;
 638 }
 639
 640 /***********************************************************************
 641  *          WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
 642  */
 643 BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config )
 644 {
 645     TRACE("%p\n", config);
 646
 647     if (!config)
 648     {
 649         set_last_error( ERROR_INVALID_PARAMETER );
 650         return FALSE;
 651     }
 652
 653     /* FIXME: read from HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings */
 654
 655     FIXME("returning no proxy used\n");
 656     config->fAutoDetect       = FALSE;
 657     config->lpszAutoConfigUrl = NULL;
 658     config->lpszProxy         = NULL;
 659     config->lpszProxyBypass   = NULL;
 660
 661     return TRUE;
 662 }
 663
 664 /***********************************************************************
 665  *          WinHttpGetProxyForUrl (winhttp.@)
 666  */
 667 BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
 668                                    WINHTTP_PROXY_INFO *info )
 669 {
 670     FIXME("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
 671
 672     set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR );
 673     return FALSE;
 674 }
 675
 676 /***********************************************************************
 677  *          WinHttpSetDefaultProxyConfiguration (winhttp.@)
 678  */
 679 BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
 680 {
 681     FIXME("%p [%u, %s, %s]\n", info, info->dwAccessType, debugstr_w(info->lpszProxy),
 682           debugstr_w(info->lpszProxyBypass));
 683     return TRUE;
 684 }
 685
 686 /***********************************************************************
 687  *          WinHttpSetStatusCallback (winhttp.@)
 688  */
 689 WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHTTP_STATUS_CALLBACK callback,
 690                                                          DWORD flags, DWORD_PTR reserved )
 691 {
 692     object_header_t *hdr;
 693     WINHTTP_STATUS_CALLBACK ret;
 694
 695     TRACE("%p, %p, 0x%08x, 0x%lx\n", handle, callback, flags, reserved);
 696
 697     if (!(hdr = grab_object( handle )))
 698     {
 699         set_last_error( ERROR_INVALID_HANDLE );
 700         return WINHTTP_INVALID_STATUS_CALLBACK;
 701     }
 702     ret = hdr->callback;
 703     hdr->callback = callback;
 704     hdr->notify_mask = flags;
 705
 706     release_object( hdr );
 707     return ret;
 708 }
 709
 710 /***********************************************************************
 711  *          WinHttpSetTimeouts (winhttp.@)
 712  */
 713 BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive )
 714 {
 715     FIXME("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive);
 716     return TRUE;
 717 }
 718
 719 static const WCHAR wkday[7][4] =
 720     {{'S','u','n', 0}, {'M','o','n', 0}, {'T','u','e', 0}, {'W','e','d', 0},
 721      {'T','h','u', 0}, {'F','r','i', 0}, {'S','a','t', 0}};
 722 static const WCHAR month[12][4] =
 723     {{'J','a','n', 0}, {'F','e','b', 0}, {'M','a','r', 0}, {'A','p','r', 0},
 724      {'M','a','y', 0}, {'J','u','n', 0}, {'J','u','l', 0}, {'A','u','g', 0},
 725      {'S','e','p', 0}, {'O','c','t', 0}, {'N','o','v', 0}, {'D','e','c', 0}};
 726
 727 /***********************************************************************
 728  *           WinHttpTimeFromSystemTime (WININET.@)
 729  */
 730 BOOL WINAPI WinHttpTimeFromSystemTime( const SYSTEMTIME *time, LPWSTR string )
 731 {
 732     static const WCHAR format[] =
 733         {'%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
 734          '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0};
 735
 736     TRACE("%p, %p\n", time, string);
 737
 738     if (!time || !string) return FALSE;
 739
 740     sprintfW( string, format,
 741               wkday[time->wDayOfWeek],
 742               time->wDay,
 743               month[time->wMonth - 1],
 744               time->wYear,
 745               time->wHour,
 746               time->wMinute,
 747               time->wSecond );
 748
 749     return TRUE;
 750 }
 751
 752 /***********************************************************************
 753  *           WinHttpTimeToSystemTime (WININET.@)
 754  */
 755 BOOL WINAPI WinHttpTimeToSystemTime( LPCWSTR string, SYSTEMTIME *time )
 756 {
 757     unsigned int i;
 758     const WCHAR *s = string;
 759     WCHAR *end;
 760
 761     TRACE("%s, %p\n", debugstr_w(string), time);
 762
 763     if (!string || !time) return FALSE;
 764
 765     /* Windows does this too */
 766     GetSystemTime( time );
 767
 768     /*  Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
 769      *  a SYSTEMTIME structure.
 770      */
 771
 772     while (*s && !isalphaW( *s )) s++;
 773     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
 774     time->wDayOfWeek = 7;
 775
 776     for (i = 0; i < 7; i++)
 777     {
 778         if (toupperW( wkday[i][0] ) == toupperW( s[0] ) &&
 779             toupperW( wkday[i][1] ) == toupperW( s[1] ) &&
 780             toupperW( wkday[i][2] ) == toupperW( s[2] ) )
 781         {
 782             time->wDayOfWeek = i;
 783             break;
 784         }
 785     }
 786
 787     if (time->wDayOfWeek > 6) return TRUE;
 788     while (*s && !isdigitW( *s )) s++;
 789     time->wDay = strtolW( s, &end, 10 );
 790     s = end;
 791
 792     while (*s && !isalphaW( *s )) s++;
 793     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
 794     time->wMonth = 0;
 795
 796     for (i = 0; i < 12; i++)
 797     {
 798         if (toupperW( month[i][0]) == toupperW( s[0] ) &&
 799             toupperW( month[i][1]) == toupperW( s[1] ) &&
 800             toupperW( month[i][2]) == toupperW( s[2] ) )
 801         {
 802             time->wMonth = i + 1;
 803             break;
 804         }
 805     }
 806     if (time->wMonth == 0) return TRUE;
 807
 808     while (*s && !isdigitW( *s )) s++;
 809     if (*s == '\0') return TRUE;
 810     time->wYear = strtolW( s, &end, 10 );
 811     s = end;
 812
 813     while (*s && !isdigitW( *s )) s++;
 814     if (*s == '\0') return TRUE;
 815     time->wHour = strtolW( s, &end, 10 );
 816     s = end;
 817
 818     while (*s && !isdigitW( *s )) s++;
 819     if (*s == '\0') return TRUE;
 820     time->wMinute = strtolW( s, &end, 10 );
 821     s = end;
 822
 823     while (*s && !isdigitW( *s )) s++;
 824     if (*s == '\0') return TRUE;
 825     time->wSecond = strtolW( s, &end, 10 );
 826     s = end;
 827
 828     time->wMilliseconds = 0;
 829     return TRUE;
 830 }