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 "winnls.h"
  28 #include "winhttp.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 void send_callback( object_header_t *hdr, DWORD status, LPVOID info, DWORD buflen )
  41 {
  42     TRACE("%p, %u, %p, %u\n", hdr, status, info, buflen);
  43
  44     if (hdr->notify_mask & status) hdr->callback( hdr->handle, hdr->context, status, info, buflen );
  45 }
  46
  47 /***********************************************************************
  48  *          WinHttpCheckPlatform (winhttp.@)
  49  */
  50 BOOL WINAPI WinHttpCheckPlatform( void )
  51 {
  52     TRACE("\n");
  53     return TRUE;
  54 }
  55
  56 /***********************************************************************
  57  *          session_destroy (internal)
  58  */
  59 static void session_destroy( object_header_t *hdr )
  60 {
  61     session_t *session = (session_t *)hdr;
  62
  63     TRACE("%p\n", session);
  64
  65     heap_free( session->agent );
  66     heap_free( session->proxy_server );
  67     heap_free( session->proxy_bypass );
  68     heap_free( session->proxy_username );
  69     heap_free( session->proxy_password );
  70     heap_free( session );
  71 }
  72
  73 static const object_vtbl_t session_vtbl =
  74 {
  75     session_destroy,
  76     NULL,
  77     NULL
  78 };
  79
  80 /***********************************************************************
  81  *          WinHttpOpen (winhttp.@)
  82  */
  83 HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags )
  84 {
  85     session_t *session;
  86     HINTERNET handle = NULL;
  87
  88     TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags);
  89
  90     if (!(session = heap_alloc_zero( sizeof(session_t) ))) return NULL;
  91
  92     session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
  93     session->hdr.vtbl = &session_vtbl;
  94     session->hdr.flags = flags;
  95     session->hdr.refs = 1;
  96     session->access = access;
  97
  98     if (agent && !(session->agent = strdupW( agent ))) goto end;
  99     if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
 100     if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end;
 101
 102     if (!(handle = alloc_handle( &session->hdr ))) goto end;
 103     session->hdr.handle = handle;
 104
 105 end:
 106     release_object( &session->hdr );
 107     TRACE("returning %p\n", handle);
 108     return handle;
 109 }
 110
 111 /***********************************************************************
 112  *          connect_destroy (internal)
 113  */
 114 static void connect_destroy( object_header_t *hdr )
 115 {
 116     connect_t *connect = (connect_t *)hdr;
 117
 118     TRACE("%p\n", connect);
 119
 120     release_object( &connect->session->hdr );
 121
 122     heap_free( connect->hostname );
 123     heap_free( connect->servername );
 124     heap_free( connect->username );
 125     heap_free( connect->password );
 126     heap_free( connect );
 127 }
 128
 129 static const object_vtbl_t connect_vtbl =
 130 {
 131     connect_destroy,
 132     NULL,
 133     NULL
 134 };
 135
 136 /***********************************************************************
 137  *          WinHttpConnect (winhttp.@)
 138  */
 139 HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved )
 140 {
 141     connect_t *connect;
 142     session_t *session;
 143     HINTERNET hconnect = NULL;
 144
 145     TRACE("%p, %s, %u, %x\n", hsession, debugstr_w(server), port, reserved);
 146
 147     if (!server)
 148     {
 149         set_last_error( ERROR_INVALID_PARAMETER );
 150         return NULL;
 151     }
 152     if (!(session = (session_t *)grab_object( hsession )))
 153     {
 154         set_last_error( ERROR_INVALID_HANDLE );
 155         return NULL;
 156     }
 157     if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
 158     {
 159         release_object( &session->hdr );
 160         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 161         return NULL;
 162     }
 163     if (!(connect = heap_alloc_zero( sizeof(connect_t) )))
 164     {
 165         release_object( &session->hdr );
 166         return NULL;
 167     }
 168     connect->hdr.type = WINHTTP_HANDLE_TYPE_CONNECT;
 169     connect->hdr.vtbl = &connect_vtbl;
 170     connect->hdr.refs = 1;
 171     connect->hdr.flags = session->hdr.flags;
 172     connect->hdr.callback = session->hdr.callback;
 173     connect->hdr.notify_mask = session->hdr.notify_mask;
 174
 175     addref_object( &session->hdr );
 176     connect->session = session;
 177     list_add_head( &session->hdr.children, &connect->hdr.entry );
 178
 179     if (server && !(connect->hostname = strdupW( server ))) goto end;
 180     connect->hostport = port ? port : (connect->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
 181
 182     if (server && !(connect->servername = strdupW( server ))) goto end;
 183     connect->serverport = port ? port : (connect->hdr.flags & WINHTTP_FLAG_SECURE ? 443 : 80);
 184
 185     if (!(hconnect = alloc_handle( &connect->hdr ))) goto end;
 186     connect->hdr.handle = hconnect;
 187
 188     send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
 189
 190 end:
 191     release_object( &connect->hdr );
 192
 193     TRACE("returning %p\n", hconnect);
 194     return hconnect;
 195 }
 196
 197 /***********************************************************************
 198  *          request_destroy (internal)
 199  */
 200 static void request_destroy( object_header_t *hdr )
 201 {
 202     request_t *request = (request_t *)hdr;
 203     int i;
 204
 205     TRACE("%p\n", request);
 206
 207     release_object( &request->connect->hdr );
 208
 209     heap_free( request->verb );
 210     heap_free( request->path );
 211     heap_free( request->version );
 212     heap_free( request->raw_headers );
 213     heap_free( request->status_text );
 214     for (i = 0; i < request->num_headers; i++)
 215     {
 216         heap_free( request->headers[i].field );
 217         heap_free( request->headers[i].value );
 218     }
 219     heap_free( request->headers );
 220     heap_free( request );
 221 }
 222
 223 static const object_vtbl_t request_vtbl =
 224 {
 225     request_destroy,
 226     NULL,
 227     NULL
 228 };
 229
 230 /***********************************************************************
 231  *          WinHttpOpenRequest (winhttp.@)
 232  */
 233 HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version,
 234                                      LPCWSTR referrer, LPCWSTR *types, DWORD flags )
 235 {
 236     static const WCHAR get[] = {'G','E','T',0};
 237     static const WCHAR slash[] = {'/',0};
 238     static const WCHAR http1_1[] = {'H','T','T','P','/','1','.','1',0};
 239
 240     request_t *request;
 241     connect_t *connect;
 242     HINTERNET hrequest = NULL;
 243
 244     TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect, debugstr_w(verb), debugstr_w(object),
 245           debugstr_w(version), debugstr_w(referrer), types, flags);
 246
 247     if (!(connect = (connect_t *)grab_object( hconnect )))
 248     {
 249         set_last_error( ERROR_INVALID_HANDLE );
 250         return NULL;
 251     }
 252     if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
 253     {
 254         release_object( &connect->hdr );
 255         set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
 256         return NULL;
 257     }
 258     if (!(request = heap_alloc_zero( sizeof(request_t) )))
 259     {
 260         release_object( &connect->hdr );
 261         return NULL;
 262     }
 263     request->hdr.type = WINHTTP_HANDLE_TYPE_REQUEST;
 264     request->hdr.vtbl = &request_vtbl;
 265     request->hdr.refs = 1;
 266     request->hdr.flags = flags;
 267     request->hdr.callback = connect->hdr.callback;
 268     request->hdr.notify_mask = connect->hdr.notify_mask;
 269
 270     addref_object( &connect->hdr );
 271     request->connect = connect;
 272     list_add_head( &connect->hdr.children, &request->hdr.entry );
 273
 274     if (!netconn_init( &request->netconn )) goto end;
 275
 276     if (!verb) verb = get;
 277     if (!object) object = slash;
 278     if (!version) version = http1_1;
 279
 280     if (!(request->verb = strdupW( verb ))) goto end;
 281     if (!(request->path = strdupW( object ))) goto end;
 282     if (!(request->version = strdupW( version ))) goto end;
 283
 284     if (!(hrequest = alloc_handle( &request->hdr ))) goto end;
 285     request->hdr.handle = hrequest;
 286
 287     send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
 288
 289 end:
 290     release_object( &request->hdr );
 291
 292     TRACE("returning %p\n", hrequest);
 293     return hrequest;
 294 }
 295
 296 /***********************************************************************
 297  *          WinHttpCloseHandle (winhttp.@)
 298  */
 299 BOOL WINAPI WinHttpCloseHandle( HINTERNET handle )
 300 {
 301     object_header_t *hdr;
 302
 303     TRACE("%p\n", handle);
 304
 305     if (!(hdr = grab_object( handle )))
 306     {
 307         set_last_error( ERROR_INVALID_HANDLE );
 308         return FALSE;
 309     }
 310     release_object( hdr );
 311     free_handle( handle );
 312     return TRUE;
 313 }
 314
 315 /***********************************************************************
 316  *          WinHttpDetectAutoProxyConfigUrl (winhttp.@)
 317  */
 318 BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, LPWSTR *url )
 319 {
 320     FIXME("0x%08x, %p\n", flags, url);
 321
 322     set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED );
 323     return FALSE;
 324 }
 325
 326 /***********************************************************************
 327  *          WinHttpGetDefaultProxyConfiguration (winhttp.@)
 328  */
 329 BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
 330 {
 331     FIXME("%p\n", info);
 332
 333     info->dwAccessType    = WINHTTP_ACCESS_TYPE_NO_PROXY;
 334     info->lpszProxy       = NULL;
 335     info->lpszProxyBypass = NULL;
 336
 337     return TRUE;
 338 }
 339
 340 /***********************************************************************
 341  *          WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
 342  */
 343 BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config )
 344 {
 345     TRACE("%p\n", config);
 346
 347     if (!config)
 348     {
 349         set_last_error( ERROR_INVALID_PARAMETER );
 350         return FALSE;
 351     }
 352
 353     /* FIXME: read from HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings */
 354
 355     FIXME("returning no proxy used\n");
 356     config->fAutoDetect       = FALSE;
 357     config->lpszAutoConfigUrl = NULL;
 358     config->lpszProxy         = NULL;
 359     config->lpszProxyBypass   = NULL;
 360
 361     return TRUE;
 362 }
 363
 364 /***********************************************************************
 365  *          WinHttpGetProxyForUrl (winhttp.@)
 366  */
 367 BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
 368                                    WINHTTP_PROXY_INFO *info )
 369 {
 370     FIXME("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
 371
 372     set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR );
 373     return FALSE;
 374 }
 375
 376 /***********************************************************************
 377  *          WinHttpSetDefaultProxyConfiguration (winhttp.@)
 378  */
 379 BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
 380 {
 381     FIXME("%p [%u, %s, %s]\n", info, info->dwAccessType, debugstr_w(info->lpszProxy),
 382           debugstr_w(info->lpszProxyBypass));
 383     return TRUE;
 384 }
 385
 386 /***********************************************************************
 387  *          WinHttpSetStatusCallback (winhttp.@)
 388  */
 389 WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHTTP_STATUS_CALLBACK callback,
 390                                                          DWORD flags, DWORD_PTR reserved )
 391 {
 392     object_header_t *hdr;
 393     WINHTTP_STATUS_CALLBACK ret;
 394
 395     TRACE("%p, %p, 0x%08x, 0x%lx\n", handle, callback, flags, reserved);
 396
 397     if (!(hdr = grab_object( handle )))
 398     {
 399         set_last_error( ERROR_INVALID_HANDLE );
 400         return WINHTTP_INVALID_STATUS_CALLBACK;
 401     }
 402     ret = hdr->callback;
 403     hdr->callback = callback;
 404     hdr->notify_mask = flags;
 405
 406     release_object( hdr );
 407     return ret;
 408 }
 409
 410 /***********************************************************************
 411  *          WinHttpSetTimeouts (winhttp.@)
 412  */
 413 BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive )
 414 {
 415     FIXME("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive);
 416     return TRUE;
 417 }
 418
 419 static const WCHAR wkday[7][4] =
 420     {{'S','u','n', 0}, {'M','o','n', 0}, {'T','u','e', 0}, {'W','e','d', 0},
 421      {'T','h','u', 0}, {'F','r','i', 0}, {'S','a','t', 0}};
 422 static const WCHAR month[12][4] =
 423     {{'J','a','n', 0}, {'F','e','b', 0}, {'M','a','r', 0}, {'A','p','r', 0},
 424      {'M','a','y', 0}, {'J','u','n', 0}, {'J','u','l', 0}, {'A','u','g', 0},
 425      {'S','e','p', 0}, {'O','c','t', 0}, {'N','o','v', 0}, {'D','e','c', 0}};
 426
 427 /***********************************************************************
 428  *           WinHttpTimeFromSystemTime (WININET.@)
 429  */
 430 BOOL WINAPI WinHttpTimeFromSystemTime( const SYSTEMTIME *time, LPWSTR string )
 431 {
 432     static const WCHAR format[] =
 433         {'%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
 434          '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0};
 435
 436     TRACE("%p, %p\n", time, string);
 437
 438     if (!time || !string) return FALSE;
 439
 440     sprintfW( string, format,
 441               wkday[time->wDayOfWeek],
 442               time->wDay,
 443               month[time->wMonth - 1],
 444               time->wYear,
 445               time->wHour,
 446               time->wMinute,
 447               time->wSecond );
 448
 449     return TRUE;
 450 }
 451
 452 /***********************************************************************
 453  *           WinHttpTimeToSystemTime (WININET.@)
 454  */
 455 BOOL WINAPI WinHttpTimeToSystemTime( LPCWSTR string, SYSTEMTIME *time )
 456 {
 457     unsigned int i;
 458     const WCHAR *s = string;
 459     WCHAR *end;
 460
 461     TRACE("%s, %p\n", debugstr_w(string), time);
 462
 463     if (!string || !time) return FALSE;
 464
 465     /* Windows does this too */
 466     GetSystemTime( time );
 467
 468     /*  Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
 469      *  a SYSTEMTIME structure.
 470      */
 471
 472     while (*s && !isalphaW( *s )) s++;
 473     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
 474     time->wDayOfWeek = 7;
 475
 476     for (i = 0; i < 7; i++)
 477     {
 478         if (toupperW( wkday[i][0] ) == toupperW( s[0] ) &&
 479             toupperW( wkday[i][1] ) == toupperW( s[1] ) &&
 480             toupperW( wkday[i][2] ) == toupperW( s[2] ) )
 481         {
 482             time->wDayOfWeek = i;
 483             break;
 484         }
 485     }
 486
 487     if (time->wDayOfWeek > 6) return TRUE;
 488     while (*s && !isdigitW( *s )) s++;
 489     time->wDay = strtolW( s, &end, 10 );
 490     s = end;
 491
 492     while (*s && !isalphaW( *s )) s++;
 493     if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
 494     time->wMonth = 0;
 495
 496     for (i = 0; i < 12; i++)
 497     {
 498         if (toupperW( month[i][0]) == toupperW( s[0] ) &&
 499             toupperW( month[i][1]) == toupperW( s[1] ) &&
 500             toupperW( month[i][2]) == toupperW( s[2] ) )
 501         {
 502             time->wMonth = i + 1;
 503             break;
 504         }
 505     }
 506     if (time->wMonth == 0) return TRUE;
 507
 508     while (*s && !isdigitW( *s )) s++;
 509     if (*s == '\0') return TRUE;
 510     time->wYear = strtolW( s, &end, 10 );
 511     s = end;
 512
 513     while (*s && !isdigitW( *s )) s++;
 514     if (*s == '\0') return TRUE;
 515     time->wHour = strtolW( s, &end, 10 );
 516     s = end;
 517
 518     while (*s && !isdigitW( *s )) s++;
 519     if (*s == '\0') return TRUE;
 520     time->wMinute = strtolW( s, &end, 10 );
 521     s = end;
 522
 523     while (*s && !isdigitW( *s )) s++;
 524     if (*s == '\0') return TRUE;
 525     time->wSecond = strtolW( s, &end, 10 );
 526     s = end;
 527
 528     time->wMilliseconds = 0;
 529     return TRUE;
 530 }