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