2 * Copyright 2008 Hans Leidekker for CodeWeavers
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.
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.
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
20 #include "wine/port.h"
21 #include "wine/debug.h"
32 #include "winhttp_private.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(winhttp
);
36 #define DEFAULT_RESOLVE_TIMEOUT 0
37 #define DEFAULT_CONNECT_TIMEOUT 20000
38 #define DEFAULT_SEND_TIMEOUT 30000
39 #define DEFAULT_RECEIVE_TIMEOUT 30000
41 void set_last_error( DWORD error
)
44 SetLastError( error
);
47 DWORD
get_last_error( void )
50 return GetLastError();
53 void send_callback( object_header_t
*hdr
, DWORD status
, LPVOID info
, DWORD buflen
)
55 TRACE("%p, 0x%08x, %p, %u\n", hdr
, status
, info
, buflen
);
57 if (hdr
->callback
&& (hdr
->notify_mask
& status
)) hdr
->callback( hdr
->handle
, hdr
->context
, status
, info
, buflen
);
60 /***********************************************************************
61 * WinHttpCheckPlatform (winhttp.@)
63 BOOL WINAPI
WinHttpCheckPlatform( void )
69 /***********************************************************************
70 * session_destroy (internal)
72 static void session_destroy( object_header_t
*hdr
)
74 session_t
*session
= (session_t
*)hdr
;
75 struct list
*item
, *next
;
78 TRACE("%p\n", session
);
80 LIST_FOR_EACH_SAFE( item
, next
, &session
->cookie_cache
)
82 domain
= LIST_ENTRY( item
, domain_t
, entry
);
83 delete_domain( domain
);
85 heap_free( session
->agent
);
86 heap_free( session
->proxy_server
);
87 heap_free( session
->proxy_bypass
);
88 heap_free( session
->proxy_username
);
89 heap_free( session
->proxy_password
);
93 static BOOL
session_query_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, LPDWORD buflen
)
95 session_t
*session
= (session_t
*)hdr
;
99 case WINHTTP_OPTION_REDIRECT_POLICY
:
101 if (!buffer
|| *buflen
< sizeof(DWORD
))
103 *buflen
= sizeof(DWORD
);
104 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
108 *(DWORD
*)buffer
= hdr
->redirect_policy
;
109 *buflen
= sizeof(DWORD
);
112 case WINHTTP_OPTION_RESOLVE_TIMEOUT
:
113 *(DWORD
*)buffer
= session
->resolve_timeout
;
114 *buflen
= sizeof(DWORD
);
116 case WINHTTP_OPTION_CONNECT_TIMEOUT
:
117 *(DWORD
*)buffer
= session
->connect_timeout
;
118 *buflen
= sizeof(DWORD
);
120 case WINHTTP_OPTION_SEND_TIMEOUT
:
121 *(DWORD
*)buffer
= session
->send_timeout
;
122 *buflen
= sizeof(DWORD
);
124 case WINHTTP_OPTION_RECEIVE_TIMEOUT
:
125 *(DWORD
*)buffer
= session
->recv_timeout
;
126 *buflen
= sizeof(DWORD
);
129 FIXME("unimplemented option %u\n", option
);
130 set_last_error( ERROR_INVALID_PARAMETER
);
135 static BOOL
session_set_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, DWORD buflen
)
137 session_t
*session
= (session_t
*)hdr
;
141 case WINHTTP_OPTION_PROXY
:
143 WINHTTP_PROXY_INFO
*pi
= buffer
;
145 FIXME("%u %s %s\n", pi
->dwAccessType
, debugstr_w(pi
->lpszProxy
), debugstr_w(pi
->lpszProxyBypass
));
148 case WINHTTP_OPTION_REDIRECT_POLICY
:
152 if (buflen
!= sizeof(policy
))
154 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
158 policy
= *(DWORD
*)buffer
;
159 TRACE("0x%x\n", policy
);
160 hdr
->redirect_policy
= policy
;
163 case WINHTTP_OPTION_DISABLE_FEATURE
:
164 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
166 case WINHTTP_OPTION_RESOLVE_TIMEOUT
:
167 session
->resolve_timeout
= *(DWORD
*)buffer
;
169 case WINHTTP_OPTION_CONNECT_TIMEOUT
:
170 session
->connect_timeout
= *(DWORD
*)buffer
;
172 case WINHTTP_OPTION_SEND_TIMEOUT
:
173 session
->send_timeout
= *(DWORD
*)buffer
;
175 case WINHTTP_OPTION_RECEIVE_TIMEOUT
:
176 session
->recv_timeout
= *(DWORD
*)buffer
;
179 FIXME("unimplemented option %u\n", option
);
180 set_last_error( ERROR_INVALID_PARAMETER
);
185 static const object_vtbl_t session_vtbl
=
188 session_query_option
,
192 /***********************************************************************
193 * WinHttpOpen (winhttp.@)
195 HINTERNET WINAPI
WinHttpOpen( LPCWSTR agent
, DWORD access
, LPCWSTR proxy
, LPCWSTR bypass
, DWORD flags
)
198 HINTERNET handle
= NULL
;
200 TRACE("%s, %u, %s, %s, 0x%08x\n", debugstr_w(agent
), access
, debugstr_w(proxy
), debugstr_w(bypass
), flags
);
202 if (!(session
= heap_alloc_zero( sizeof(session_t
) ))) return NULL
;
204 session
->hdr
.type
= WINHTTP_HANDLE_TYPE_SESSION
;
205 session
->hdr
.vtbl
= &session_vtbl
;
206 session
->hdr
.flags
= flags
;
207 session
->hdr
.refs
= 1;
208 session
->hdr
.redirect_policy
= WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP
;
209 session
->resolve_timeout
= DEFAULT_RESOLVE_TIMEOUT
;
210 session
->connect_timeout
= DEFAULT_CONNECT_TIMEOUT
;
211 session
->send_timeout
= DEFAULT_SEND_TIMEOUT
;
212 session
->recv_timeout
= DEFAULT_RECEIVE_TIMEOUT
;
213 list_init( &session
->cookie_cache
);
215 if (agent
&& !(session
->agent
= strdupW( agent
))) goto end
;
216 if (access
== WINHTTP_ACCESS_TYPE_DEFAULT_PROXY
)
218 WINHTTP_PROXY_INFO info
;
220 WinHttpGetDefaultProxyConfiguration( &info
);
221 session
->access
= info
.dwAccessType
;
222 if (info
.lpszProxy
&& !(session
->proxy_server
= strdupW( info
.lpszProxy
)))
224 GlobalFree( (LPWSTR
)info
.lpszProxy
);
225 GlobalFree( (LPWSTR
)info
.lpszProxyBypass
);
228 if (info
.lpszProxyBypass
&& !(session
->proxy_bypass
= strdupW( info
.lpszProxyBypass
)))
230 GlobalFree( (LPWSTR
)info
.lpszProxy
);
231 GlobalFree( (LPWSTR
)info
.lpszProxyBypass
);
235 else if (access
== WINHTTP_ACCESS_TYPE_NAMED_PROXY
)
237 session
->access
= access
;
238 if (proxy
&& !(session
->proxy_server
= strdupW( proxy
))) goto end
;
239 if (bypass
&& !(session
->proxy_bypass
= strdupW( bypass
))) goto end
;
242 if (!(handle
= alloc_handle( &session
->hdr
))) goto end
;
243 session
->hdr
.handle
= handle
;
246 release_object( &session
->hdr
);
247 TRACE("returning %p\n", handle
);
251 /***********************************************************************
252 * connect_destroy (internal)
254 static void connect_destroy( object_header_t
*hdr
)
256 connect_t
*connect
= (connect_t
*)hdr
;
258 TRACE("%p\n", connect
);
260 release_object( &connect
->session
->hdr
);
262 heap_free( connect
->hostname
);
263 heap_free( connect
->servername
);
264 heap_free( connect
->username
);
265 heap_free( connect
->password
);
266 heap_free( connect
);
269 static BOOL
connect_query_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, LPDWORD buflen
)
271 connect_t
*connect
= (connect_t
*)hdr
;
275 case WINHTTP_OPTION_PARENT_HANDLE
:
277 if (!buffer
|| *buflen
< sizeof(HINTERNET
))
279 *buflen
= sizeof(HINTERNET
);
280 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
284 *(HINTERNET
*)buffer
= ((object_header_t
*)connect
->session
)->handle
;
285 *buflen
= sizeof(HINTERNET
);
288 case WINHTTP_OPTION_RESOLVE_TIMEOUT
:
289 *(DWORD
*)buffer
= connect
->session
->resolve_timeout
;
290 *buflen
= sizeof(DWORD
);
292 case WINHTTP_OPTION_CONNECT_TIMEOUT
:
293 *(DWORD
*)buffer
= connect
->session
->connect_timeout
;
294 *buflen
= sizeof(DWORD
);
296 case WINHTTP_OPTION_SEND_TIMEOUT
:
297 *(DWORD
*)buffer
= connect
->session
->send_timeout
;
298 *buflen
= sizeof(DWORD
);
300 case WINHTTP_OPTION_RECEIVE_TIMEOUT
:
301 *(DWORD
*)buffer
= connect
->session
->recv_timeout
;
302 *buflen
= sizeof(DWORD
);
305 FIXME("unimplemented option %u\n", option
);
306 set_last_error( ERROR_INVALID_PARAMETER
);
311 static const object_vtbl_t connect_vtbl
=
314 connect_query_option
,
318 static BOOL
domain_matches(LPCWSTR server
, LPCWSTR domain
)
320 static const WCHAR localW
[] = { '<','l','o','c','a','l','>',0 };
323 if (!strcmpiW( domain
, localW
) && !strchrW( server
, '.' ))
325 else if (*domain
== '*')
327 if (domain
[1] == '.')
331 /* For a hostname to match a wildcard, the last domain must match
332 * the wildcard exactly. E.g. if the wildcard is *.a.b, and the
333 * hostname is www.foo.a.b, it matches, but a.b does not.
335 dot
= strchrW( server
, '.' );
338 int len
= strlenW( dot
+ 1 );
340 if (len
> strlenW( domain
+ 2 ))
344 /* The server's domain is longer than the wildcard, so it
345 * could be a subdomain. Compare the last portion of the
348 ptr
= dot
+ len
+ 1 - strlenW( domain
+ 2 );
349 if (!strcmpiW( ptr
, domain
+ 2 ))
351 /* This is only a match if the preceding character is
352 * a '.', i.e. that it is a matching domain. E.g.
353 * if domain is '*.b.c' and server is 'www.ab.c' they
356 ret
= *(ptr
- 1) == '.';
360 ret
= !strcmpiW( dot
+ 1, domain
+ 2 );
365 ret
= !strcmpiW( server
, domain
);
369 /* Matches INTERNET_MAX_HOST_NAME_LENGTH in wininet.h, also RFC 1035 */
370 #define MAX_HOST_NAME_LENGTH 256
372 static BOOL
should_bypass_proxy(session_t
*session
, LPCWSTR server
)
377 if (!session
->proxy_bypass
) return FALSE
;
378 ptr
= session
->proxy_bypass
;
382 ptr
= strchrW( ptr
, ';' );
384 ptr
= strchrW( tmp
, ' ' );
387 if (ptr
- tmp
< MAX_HOST_NAME_LENGTH
)
389 WCHAR domain
[MAX_HOST_NAME_LENGTH
];
391 memcpy( domain
, tmp
, (ptr
- tmp
) * sizeof(WCHAR
) );
392 domain
[ptr
- tmp
] = 0;
393 ret
= domain_matches( server
, domain
);
398 ret
= domain_matches( server
, tmp
);
399 } while (ptr
&& !ret
);
403 BOOL
set_server_for_hostname( connect_t
*connect
, LPCWSTR server
, INTERNET_PORT port
)
405 session_t
*session
= connect
->session
;
408 if (session
->proxy_server
&& !should_bypass_proxy(session
, server
))
412 if ((colon
= strchrW( session
->proxy_server
, ':' )))
414 if (!connect
->servername
|| strncmpiW( connect
->servername
,
415 session
->proxy_server
, colon
- session
->proxy_server
- 1 ))
417 heap_free( connect
->servername
);
418 if (!(connect
->servername
= heap_alloc(
419 (colon
- session
->proxy_server
+ 1) * sizeof(WCHAR
) )))
424 memcpy( connect
->servername
, session
->proxy_server
,
425 (colon
- session
->proxy_server
) * sizeof(WCHAR
) );
426 connect
->servername
[colon
- session
->proxy_server
] = 0;
428 connect
->serverport
= atoiW( colon
+ 1 );
430 connect
->serverport
= INTERNET_DEFAULT_PORT
;
435 if (!connect
->servername
|| strcmpiW( connect
->servername
,
436 session
->proxy_server
))
438 heap_free( connect
->servername
);
439 if (!(connect
->servername
= strdupW( session
->proxy_server
)))
444 connect
->serverport
= INTERNET_DEFAULT_PORT
;
450 heap_free( connect
->servername
);
451 if (!(connect
->servername
= strdupW( server
)))
456 connect
->serverport
= port
;
462 /***********************************************************************
463 * WinHttpConnect (winhttp.@)
465 HINTERNET WINAPI
WinHttpConnect( HINTERNET hsession
, LPCWSTR server
, INTERNET_PORT port
, DWORD reserved
)
469 HINTERNET hconnect
= NULL
;
471 TRACE("%p, %s, %u, %x\n", hsession
, debugstr_w(server
), port
, reserved
);
475 set_last_error( ERROR_INVALID_PARAMETER
);
478 if (!(session
= (session_t
*)grab_object( hsession
)))
480 set_last_error( ERROR_INVALID_HANDLE
);
483 if (session
->hdr
.type
!= WINHTTP_HANDLE_TYPE_SESSION
)
485 release_object( &session
->hdr
);
486 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
489 if (!(connect
= heap_alloc_zero( sizeof(connect_t
) )))
491 release_object( &session
->hdr
);
494 connect
->hdr
.type
= WINHTTP_HANDLE_TYPE_CONNECT
;
495 connect
->hdr
.vtbl
= &connect_vtbl
;
496 connect
->hdr
.refs
= 1;
497 connect
->hdr
.flags
= session
->hdr
.flags
;
498 connect
->hdr
.callback
= session
->hdr
.callback
;
499 connect
->hdr
.notify_mask
= session
->hdr
.notify_mask
;
500 connect
->hdr
.context
= session
->hdr
.context
;
502 addref_object( &session
->hdr
);
503 connect
->session
= session
;
504 list_add_head( &session
->hdr
.children
, &connect
->hdr
.entry
);
506 if (server
&& !(connect
->hostname
= strdupW( server
))) goto end
;
507 connect
->hostport
= port
;
509 if (!set_server_for_hostname( connect
, server
, port
))
512 if (!(hconnect
= alloc_handle( &connect
->hdr
))) goto end
;
513 connect
->hdr
.handle
= hconnect
;
515 send_callback( &session
->hdr
, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED
, &hconnect
, sizeof(hconnect
) );
518 release_object( &connect
->hdr
);
520 TRACE("returning %p\n", hconnect
);
524 /***********************************************************************
525 * request_destroy (internal)
527 static void request_destroy( object_header_t
*hdr
)
529 request_t
*request
= (request_t
*)hdr
;
532 TRACE("%p\n", request
);
534 release_object( &request
->connect
->hdr
);
536 heap_free( request
->verb
);
537 heap_free( request
->path
);
538 heap_free( request
->version
);
539 heap_free( request
->raw_headers
);
540 heap_free( request
->status_text
);
541 for (i
= 0; i
< request
->num_headers
; i
++)
543 heap_free( request
->headers
[i
].field
);
544 heap_free( request
->headers
[i
].value
);
546 heap_free( request
->headers
);
547 heap_free( request
);
550 static BOOL
request_query_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, LPDWORD buflen
)
552 request_t
*request
= (request_t
*)hdr
;
556 case WINHTTP_OPTION_SECURITY_FLAGS
:
560 if (!buffer
|| *buflen
< sizeof(flags
))
562 *buflen
= sizeof(flags
);
563 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
568 if (hdr
->flags
& WINHTTP_FLAG_SECURE
) flags
|= SECURITY_FLAG_SECURE
;
569 *(DWORD
*)buffer
= flags
;
570 *buflen
= sizeof(flags
);
573 case WINHTTP_OPTION_SERVER_CERT_CONTEXT
:
575 const CERT_CONTEXT
*cert
;
577 if (!buffer
|| *buflen
< sizeof(cert
))
579 *buflen
= sizeof(cert
);
580 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
584 if (!(cert
= netconn_get_certificate( &request
->netconn
))) return FALSE
;
585 *(CERT_CONTEXT
**)buffer
= (CERT_CONTEXT
*)cert
;
586 *buflen
= sizeof(cert
);
589 case WINHTTP_OPTION_SECURITY_KEY_BITNESS
:
591 if (!buffer
|| *buflen
< sizeof(DWORD
))
593 *buflen
= sizeof(DWORD
);
594 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
598 *(DWORD
*)buffer
= 128; /* FIXME */
599 *buflen
= sizeof(DWORD
);
602 case WINHTTP_OPTION_RESOLVE_TIMEOUT
:
603 *(DWORD
*)buffer
= request
->resolve_timeout
;
604 *buflen
= sizeof(DWORD
);
606 case WINHTTP_OPTION_CONNECT_TIMEOUT
:
607 *(DWORD
*)buffer
= request
->connect_timeout
;
608 *buflen
= sizeof(DWORD
);
610 case WINHTTP_OPTION_SEND_TIMEOUT
:
611 *(DWORD
*)buffer
= request
->send_timeout
;
612 *buflen
= sizeof(DWORD
);
614 case WINHTTP_OPTION_RECEIVE_TIMEOUT
:
615 *(DWORD
*)buffer
= request
->recv_timeout
;
616 *buflen
= sizeof(DWORD
);
619 FIXME("unimplemented option %u\n", option
);
620 set_last_error( ERROR_INVALID_PARAMETER
);
625 static BOOL
request_set_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, DWORD buflen
)
627 request_t
*request
= (request_t
*)hdr
;
631 case WINHTTP_OPTION_PROXY
:
633 WINHTTP_PROXY_INFO
*pi
= buffer
;
635 FIXME("%u %s %s\n", pi
->dwAccessType
, debugstr_w(pi
->lpszProxy
), debugstr_w(pi
->lpszProxyBypass
));
638 case WINHTTP_OPTION_DISABLE_FEATURE
:
642 if (buflen
!= sizeof(DWORD
))
644 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
648 disable
= *(DWORD
*)buffer
;
649 TRACE("0x%x\n", disable
);
650 hdr
->disable_flags
|= disable
;
653 case WINHTTP_OPTION_AUTOLOGON_POLICY
:
657 if (buflen
!= sizeof(DWORD
))
659 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
663 policy
= *(DWORD
*)buffer
;
664 TRACE("0x%x\n", policy
);
665 hdr
->logon_policy
= policy
;
668 case WINHTTP_OPTION_REDIRECT_POLICY
:
672 if (buflen
!= sizeof(DWORD
))
674 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
678 policy
= *(DWORD
*)buffer
;
679 TRACE("0x%x\n", policy
);
680 hdr
->redirect_policy
= policy
;
683 case WINHTTP_OPTION_SECURITY_FLAGS
:
684 FIXME("WINHTTP_OPTION_SECURITY_FLAGS unimplemented (%08x)\n",
687 case WINHTTP_OPTION_RESOLVE_TIMEOUT
:
688 request
->resolve_timeout
= *(DWORD
*)buffer
;
690 case WINHTTP_OPTION_CONNECT_TIMEOUT
:
691 request
->connect_timeout
= *(DWORD
*)buffer
;
693 case WINHTTP_OPTION_SEND_TIMEOUT
:
694 request
->send_timeout
= *(DWORD
*)buffer
;
696 case WINHTTP_OPTION_RECEIVE_TIMEOUT
:
697 request
->recv_timeout
= *(DWORD
*)buffer
;
700 FIXME("unimplemented option %u\n", option
);
701 set_last_error( ERROR_INVALID_PARAMETER
);
706 static const object_vtbl_t request_vtbl
=
709 request_query_option
,
713 /***********************************************************************
714 * WinHttpOpenRequest (winhttp.@)
716 HINTERNET WINAPI
WinHttpOpenRequest( HINTERNET hconnect
, LPCWSTR verb
, LPCWSTR object
, LPCWSTR version
,
717 LPCWSTR referrer
, LPCWSTR
*types
, DWORD flags
)
721 HINTERNET hrequest
= NULL
;
723 TRACE("%p, %s, %s, %s, %s, %p, 0x%08x\n", hconnect
, debugstr_w(verb
), debugstr_w(object
),
724 debugstr_w(version
), debugstr_w(referrer
), types
, flags
);
726 if (!(connect
= (connect_t
*)grab_object( hconnect
)))
728 set_last_error( ERROR_INVALID_HANDLE
);
731 if (connect
->hdr
.type
!= WINHTTP_HANDLE_TYPE_CONNECT
)
733 release_object( &connect
->hdr
);
734 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
737 if (!(request
= heap_alloc_zero( sizeof(request_t
) )))
739 release_object( &connect
->hdr
);
742 request
->hdr
.type
= WINHTTP_HANDLE_TYPE_REQUEST
;
743 request
->hdr
.vtbl
= &request_vtbl
;
744 request
->hdr
.refs
= 1;
745 request
->hdr
.flags
= flags
;
746 request
->hdr
.callback
= connect
->hdr
.callback
;
747 request
->hdr
.notify_mask
= connect
->hdr
.notify_mask
;
748 request
->hdr
.context
= connect
->hdr
.context
;
750 addref_object( &connect
->hdr
);
751 request
->connect
= connect
;
752 list_add_head( &connect
->hdr
.children
, &request
->hdr
.entry
);
754 if (!netconn_init( &request
->netconn
, request
->hdr
.flags
& WINHTTP_FLAG_SECURE
)) goto end
;
755 request
->resolve_timeout
= connect
->session
->resolve_timeout
;
756 request
->connect_timeout
= connect
->session
->connect_timeout
;
757 request
->send_timeout
= connect
->session
->send_timeout
;
758 request
->recv_timeout
= connect
->session
->recv_timeout
;
760 if (!verb
|| !verb
[0]) verb
= getW
;
761 if (!(request
->verb
= strdupW( verb
))) goto end
;
768 len
= strlenW( object
) + 1;
769 if (object
[0] != '/') len
++;
770 if (!(p
= path
= heap_alloc( len
* sizeof(WCHAR
) ))) goto end
;
772 if (object
[0] != '/') *p
++ = '/';
773 strcpyW( p
, object
);
774 request
->path
= path
;
776 else if (!(request
->path
= strdupW( slashW
))) goto end
;
778 if (!version
|| !version
[0]) version
= http1_1
;
779 if (!(request
->version
= strdupW( version
))) goto end
;
781 if (!(hrequest
= alloc_handle( &request
->hdr
))) goto end
;
782 request
->hdr
.handle
= hrequest
;
784 send_callback( &request
->hdr
, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED
, &hrequest
, sizeof(hrequest
) );
787 release_object( &request
->hdr
);
789 TRACE("returning %p\n", hrequest
);
793 /***********************************************************************
794 * WinHttpCloseHandle (winhttp.@)
796 BOOL WINAPI
WinHttpCloseHandle( HINTERNET handle
)
798 object_header_t
*hdr
;
800 TRACE("%p\n", handle
);
802 if (!(hdr
= grab_object( handle
)))
804 set_last_error( ERROR_INVALID_HANDLE
);
807 release_object( hdr
);
808 free_handle( handle
);
812 static BOOL
query_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, LPDWORD buflen
)
818 set_last_error( ERROR_INVALID_PARAMETER
);
824 case WINHTTP_OPTION_CONTEXT_VALUE
:
826 if (!buffer
|| *buflen
< sizeof(DWORD_PTR
))
828 *buflen
= sizeof(DWORD_PTR
);
829 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
833 *(DWORD_PTR
*)buffer
= hdr
->context
;
834 *buflen
= sizeof(DWORD_PTR
);
838 if (hdr
->vtbl
->query_option
) ret
= hdr
->vtbl
->query_option( hdr
, option
, buffer
, buflen
);
841 FIXME("unimplemented option %u\n", option
);
842 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
850 /***********************************************************************
851 * WinHttpQueryOption (winhttp.@)
853 BOOL WINAPI
WinHttpQueryOption( HINTERNET handle
, DWORD option
, LPVOID buffer
, LPDWORD buflen
)
856 object_header_t
*hdr
;
858 TRACE("%p, %u, %p, %p\n", handle
, option
, buffer
, buflen
);
860 if (!(hdr
= grab_object( handle
)))
862 set_last_error( ERROR_INVALID_HANDLE
);
866 ret
= query_option( hdr
, option
, buffer
, buflen
);
868 release_object( hdr
);
872 static BOOL
set_option( object_header_t
*hdr
, DWORD option
, LPVOID buffer
, DWORD buflen
)
878 set_last_error( ERROR_INVALID_PARAMETER
);
884 case WINHTTP_OPTION_CONTEXT_VALUE
:
886 if (buflen
!= sizeof(DWORD_PTR
))
888 set_last_error( ERROR_INSUFFICIENT_BUFFER
);
892 hdr
->context
= *(DWORD_PTR
*)buffer
;
896 if (hdr
->vtbl
->set_option
) ret
= hdr
->vtbl
->set_option( hdr
, option
, buffer
, buflen
);
899 FIXME("unimplemented option %u\n", option
);
900 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
908 /***********************************************************************
909 * WinHttpSetOption (winhttp.@)
911 BOOL WINAPI
WinHttpSetOption( HINTERNET handle
, DWORD option
, LPVOID buffer
, DWORD buflen
)
914 object_header_t
*hdr
;
916 TRACE("%p, %u, %p, %u\n", handle
, option
, buffer
, buflen
);
918 if (!(hdr
= grab_object( handle
)))
920 set_last_error( ERROR_INVALID_HANDLE
);
924 ret
= set_option( hdr
, option
, buffer
, buflen
);
926 release_object( hdr
);
930 /***********************************************************************
931 * WinHttpDetectAutoProxyConfigUrl (winhttp.@)
933 BOOL WINAPI
WinHttpDetectAutoProxyConfigUrl( DWORD flags
, LPWSTR
*url
)
935 FIXME("0x%08x, %p\n", flags
, url
);
937 set_last_error( ERROR_WINHTTP_AUTODETECTION_FAILED
);
941 static const WCHAR Connections
[] = {
942 'S','o','f','t','w','a','r','e','\\',
943 'M','i','c','r','o','s','o','f','t','\\',
944 'W','i','n','d','o','w','s','\\',
945 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
946 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s','\\',
947 'C','o','n','n','e','c','t','i','o','n','s',0 };
948 static const WCHAR WinHttpSettings
[] = {
949 'W','i','n','H','t','t','p','S','e','t','t','i','n','g','s',0 };
950 static const DWORD WINHTTPSETTINGS_MAGIC
= 0x18;
951 static const DWORD WINHTTP_PROXY_TYPE_DIRECT
= 1;
952 static const DWORD WINHTTP_PROXY_TYPE_PROXY
= 2;
954 struct winhttp_settings_header
957 DWORD unknown
; /* always zero? */
958 DWORD flags
; /* one of WINHTTP_PROXY_TYPE_* */
961 static inline void copy_char_to_wchar_sz(const BYTE
*src
, DWORD len
, WCHAR
*dst
)
965 for (begin
= src
; src
- begin
< len
; src
++, dst
++)
970 /***********************************************************************
971 * WinHttpGetDefaultProxyConfiguration (winhttp.@)
973 BOOL WINAPI
WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO
*info
)
977 BOOL got_from_reg
= FALSE
, direct
= TRUE
;
982 l
= RegOpenKeyExW( HKEY_LOCAL_MACHINE
, Connections
, 0, KEY_READ
, &key
);
985 DWORD type
, size
= 0;
987 l
= RegQueryValueExW( key
, WinHttpSettings
, NULL
, &type
, NULL
, &size
);
988 if (!l
&& type
== REG_BINARY
&&
989 size
>= sizeof(struct winhttp_settings_header
) + 2 * sizeof(DWORD
))
991 BYTE
*buf
= heap_alloc( size
);
995 struct winhttp_settings_header
*hdr
=
996 (struct winhttp_settings_header
*)buf
;
997 DWORD
*len
= (DWORD
*)(hdr
+ 1);
999 l
= RegQueryValueExW( key
, WinHttpSettings
, NULL
, NULL
, buf
,
1001 if (!l
&& hdr
->magic
== WINHTTPSETTINGS_MAGIC
&&
1004 if (hdr
->flags
& WINHTTP_PROXY_TYPE_PROXY
)
1007 LPWSTR proxy
= NULL
;
1008 LPWSTR proxy_bypass
= NULL
;
1010 /* Sanity-check length of proxy string */
1011 if ((BYTE
*)len
- buf
+ *len
<= size
)
1014 proxy
= GlobalAlloc( 0, (*len
+ 1) * sizeof(WCHAR
) );
1016 copy_char_to_wchar_sz( (BYTE
*)(len
+ 1), *len
, proxy
);
1017 len
= (DWORD
*)((BYTE
*)(len
+ 1) + *len
);
1021 /* Sanity-check length of proxy bypass string */
1022 if ((BYTE
*)len
- buf
+ *len
<= size
)
1024 proxy_bypass
= GlobalAlloc( 0, (*len
+ 1) * sizeof(WCHAR
) );
1026 copy_char_to_wchar_sz( (BYTE
*)(len
+ 1), *len
, proxy_bypass
);
1031 GlobalFree( proxy
);
1035 info
->lpszProxy
= proxy
;
1036 info
->lpszProxyBypass
= proxy_bypass
;
1039 got_from_reg
= TRUE
;
1041 info
->dwAccessType
=
1042 WINHTTP_ACCESS_TYPE_NAMED_PROXY
;
1043 TRACE("http proxy (from registry) = %s, bypass = %s\n",
1044 debugstr_w(info
->lpszProxy
),
1045 debugstr_w(info
->lpszProxyBypass
));
1054 if (!got_from_reg
&& (envproxy
= getenv( "http_proxy" )))
1056 char *colon
, *http_proxy
;
1058 if ((colon
= strchr( envproxy
, ':' )))
1060 if (*(colon
+ 1) == '/' && *(colon
+ 2) == '/')
1062 static const char http
[] = "http://";
1064 /* It's a scheme, check that it's http */
1065 if (!strncmp( envproxy
, http
, strlen( http
) ))
1066 http_proxy
= envproxy
+ strlen( http
);
1069 WARN("unsupported scheme in $http_proxy: %s\n", envproxy
);
1074 http_proxy
= envproxy
;
1077 http_proxy
= envproxy
;
1083 len
= MultiByteToWideChar( CP_UNIXCP
, 0, http_proxy
, -1, NULL
, 0 );
1084 if ((http_proxyW
= GlobalAlloc( 0, len
* sizeof(WCHAR
))))
1086 MultiByteToWideChar( CP_UNIXCP
, 0, http_proxy
, -1, http_proxyW
, len
);
1088 info
->dwAccessType
= WINHTTP_ACCESS_TYPE_NAMED_PROXY
;
1089 info
->lpszProxy
= http_proxyW
;
1090 info
->lpszProxyBypass
= NULL
;
1091 TRACE("http proxy (from environment) = %s\n",
1092 debugstr_w(info
->lpszProxy
));
1098 info
->dwAccessType
= WINHTTP_ACCESS_TYPE_NO_PROXY
;
1099 info
->lpszProxy
= NULL
;
1100 info
->lpszProxyBypass
= NULL
;
1105 /***********************************************************************
1106 * WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
1108 BOOL WINAPI
WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG
*config
)
1110 TRACE("%p\n", config
);
1114 set_last_error( ERROR_INVALID_PARAMETER
);
1118 /* FIXME: read from HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings */
1120 FIXME("returning no proxy used\n");
1121 config
->fAutoDetect
= FALSE
;
1122 config
->lpszAutoConfigUrl
= NULL
;
1123 config
->lpszProxy
= NULL
;
1124 config
->lpszProxyBypass
= NULL
;
1129 /***********************************************************************
1130 * WinHttpGetProxyForUrl (winhttp.@)
1132 BOOL WINAPI
WinHttpGetProxyForUrl( HINTERNET hsession
, LPCWSTR url
, WINHTTP_AUTOPROXY_OPTIONS
*options
,
1133 WINHTTP_PROXY_INFO
*info
)
1135 FIXME("%p, %s, %p, %p\n", hsession
, debugstr_w(url
), options
, info
);
1137 set_last_error( ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR
);
1141 /***********************************************************************
1142 * WinHttpSetDefaultProxyConfiguration (winhttp.@)
1144 BOOL WINAPI
WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO
*info
)
1151 TRACE("%p\n", info
);
1155 set_last_error( ERROR_INVALID_PARAMETER
);
1158 switch (info
->dwAccessType
)
1160 case WINHTTP_ACCESS_TYPE_NO_PROXY
:
1162 case WINHTTP_ACCESS_TYPE_NAMED_PROXY
:
1163 if (!info
->lpszProxy
)
1165 set_last_error( ERROR_INVALID_PARAMETER
);
1168 /* Only ASCII characters are allowed */
1169 for (src
= info
->lpszProxy
; *src
; src
++)
1172 set_last_error( ERROR_INVALID_PARAMETER
);
1175 if (info
->lpszProxyBypass
)
1177 for (src
= info
->lpszProxyBypass
; *src
; src
++)
1180 set_last_error( ERROR_INVALID_PARAMETER
);
1186 set_last_error( ERROR_INVALID_PARAMETER
);
1190 l
= RegCreateKeyExW( HKEY_LOCAL_MACHINE
, Connections
, 0, NULL
, 0,
1191 KEY_WRITE
, NULL
, &key
, NULL
);
1194 DWORD size
= sizeof(struct winhttp_settings_header
) + 2 * sizeof(DWORD
);
1197 if (info
->dwAccessType
== WINHTTP_ACCESS_TYPE_NAMED_PROXY
)
1199 size
+= strlenW( info
->lpszProxy
);
1200 if (info
->lpszProxyBypass
)
1201 size
+= strlenW( info
->lpszProxyBypass
);
1203 buf
= heap_alloc( size
);
1206 struct winhttp_settings_header
*hdr
=
1207 (struct winhttp_settings_header
*)buf
;
1208 DWORD
*len
= (DWORD
*)(hdr
+ 1);
1210 hdr
->magic
= WINHTTPSETTINGS_MAGIC
;
1212 if (info
->dwAccessType
== WINHTTP_ACCESS_TYPE_NAMED_PROXY
)
1216 hdr
->flags
= WINHTTP_PROXY_TYPE_PROXY
;
1217 *len
++ = strlenW( info
->lpszProxy
);
1218 for (dst
= (BYTE
*)len
, src
= info
->lpszProxy
; *src
;
1222 if (info
->lpszProxyBypass
)
1224 *len
++ = strlenW( info
->lpszProxyBypass
);
1225 for (dst
= (BYTE
*)len
, src
= info
->lpszProxyBypass
; *src
;
1234 hdr
->flags
= WINHTTP_PROXY_TYPE_DIRECT
;
1238 l
= RegSetValueExW( key
, WinHttpSettings
, 0, REG_BINARY
, buf
, size
);
1248 /***********************************************************************
1249 * WinHttpSetStatusCallback (winhttp.@)
1251 WINHTTP_STATUS_CALLBACK WINAPI
WinHttpSetStatusCallback( HINTERNET handle
, WINHTTP_STATUS_CALLBACK callback
,
1252 DWORD flags
, DWORD_PTR reserved
)
1254 object_header_t
*hdr
;
1255 WINHTTP_STATUS_CALLBACK ret
;
1257 TRACE("%p, %p, 0x%08x, 0x%lx\n", handle
, callback
, flags
, reserved
);
1259 if (!(hdr
= grab_object( handle
)))
1261 set_last_error( ERROR_INVALID_HANDLE
);
1262 return WINHTTP_INVALID_STATUS_CALLBACK
;
1264 ret
= hdr
->callback
;
1265 hdr
->callback
= callback
;
1266 hdr
->notify_mask
= flags
;
1268 release_object( hdr
);
1272 /***********************************************************************
1273 * WinHttpSetTimeouts (winhttp.@)
1275 BOOL WINAPI
WinHttpSetTimeouts( HINTERNET handle
, int resolve
, int connect
, int send
, int receive
)
1278 object_header_t
*hdr
;
1282 TRACE("%p, %d, %d, %d, %d\n", handle
, resolve
, connect
, send
, receive
);
1284 if (resolve
< -1 || connect
< -1 || send
< -1 || receive
< -1)
1286 set_last_error( ERROR_INVALID_PARAMETER
);
1290 if (!(hdr
= grab_object( handle
)))
1292 set_last_error( ERROR_INVALID_HANDLE
);
1298 case WINHTTP_HANDLE_TYPE_REQUEST
:
1299 request
= (request_t
*)hdr
;
1300 request
->connect_timeout
= connect
;
1302 if (resolve
< 0) resolve
= 0;
1303 request
->resolve_timeout
= resolve
;
1305 if (send
< 0) send
= 0;
1306 request
->send_timeout
= send
;
1308 if (receive
< 0) receive
= 0;
1309 request
->recv_timeout
= receive
;
1311 if (netconn_connected( &request
->netconn
))
1313 if (netconn_set_timeout( &request
->netconn
, TRUE
, send
)) ret
= FALSE
;
1314 if (netconn_set_timeout( &request
->netconn
, FALSE
, receive
)) ret
= FALSE
;
1317 release_object( &request
->hdr
);
1320 case WINHTTP_HANDLE_TYPE_SESSION
:
1321 session
= (session_t
*)hdr
;
1322 session
->connect_timeout
= connect
;
1324 if (resolve
< 0) resolve
= 0;
1325 session
->resolve_timeout
= resolve
;
1327 if (send
< 0) send
= 0;
1328 session
->send_timeout
= send
;
1330 if (receive
< 0) receive
= 0;
1331 session
->recv_timeout
= receive
;
1335 release_object( hdr
);
1336 set_last_error( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE
);
1342 static const WCHAR wkday
[7][4] =
1343 {{'S','u','n', 0}, {'M','o','n', 0}, {'T','u','e', 0}, {'W','e','d', 0},
1344 {'T','h','u', 0}, {'F','r','i', 0}, {'S','a','t', 0}};
1345 static const WCHAR month
[12][4] =
1346 {{'J','a','n', 0}, {'F','e','b', 0}, {'M','a','r', 0}, {'A','p','r', 0},
1347 {'M','a','y', 0}, {'J','u','n', 0}, {'J','u','l', 0}, {'A','u','g', 0},
1348 {'S','e','p', 0}, {'O','c','t', 0}, {'N','o','v', 0}, {'D','e','c', 0}};
1350 /***********************************************************************
1351 * WinHttpTimeFromSystemTime (WININET.@)
1353 BOOL WINAPI
WinHttpTimeFromSystemTime( const SYSTEMTIME
*time
, LPWSTR string
)
1355 static const WCHAR format
[] =
1356 {'%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
1357 '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0};
1359 TRACE("%p, %p\n", time
, string
);
1361 if (!time
|| !string
) return FALSE
;
1363 sprintfW( string
, format
,
1364 wkday
[time
->wDayOfWeek
],
1366 month
[time
->wMonth
- 1],
1375 /***********************************************************************
1376 * WinHttpTimeToSystemTime (WININET.@)
1378 BOOL WINAPI
WinHttpTimeToSystemTime( LPCWSTR string
, SYSTEMTIME
*time
)
1381 const WCHAR
*s
= string
;
1384 TRACE("%s, %p\n", debugstr_w(string
), time
);
1386 if (!string
|| !time
) return FALSE
;
1388 /* Windows does this too */
1389 GetSystemTime( time
);
1391 /* Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
1392 * a SYSTEMTIME structure.
1395 while (*s
&& !isalphaW( *s
)) s
++;
1396 if (s
[0] == '\0' || s
[1] == '\0' || s
[2] == '\0') return TRUE
;
1397 time
->wDayOfWeek
= 7;
1399 for (i
= 0; i
< 7; i
++)
1401 if (toupperW( wkday
[i
][0] ) == toupperW( s
[0] ) &&
1402 toupperW( wkday
[i
][1] ) == toupperW( s
[1] ) &&
1403 toupperW( wkday
[i
][2] ) == toupperW( s
[2] ) )
1405 time
->wDayOfWeek
= i
;
1410 if (time
->wDayOfWeek
> 6) return TRUE
;
1411 while (*s
&& !isdigitW( *s
)) s
++;
1412 time
->wDay
= strtolW( s
, &end
, 10 );
1415 while (*s
&& !isalphaW( *s
)) s
++;
1416 if (s
[0] == '\0' || s
[1] == '\0' || s
[2] == '\0') return TRUE
;
1419 for (i
= 0; i
< 12; i
++)
1421 if (toupperW( month
[i
][0]) == toupperW( s
[0] ) &&
1422 toupperW( month
[i
][1]) == toupperW( s
[1] ) &&
1423 toupperW( month
[i
][2]) == toupperW( s
[2] ) )
1425 time
->wMonth
= i
+ 1;
1429 if (time
->wMonth
== 0) return TRUE
;
1431 while (*s
&& !isdigitW( *s
)) s
++;
1432 if (*s
== '\0') return TRUE
;
1433 time
->wYear
= strtolW( s
, &end
, 10 );
1436 while (*s
&& !isdigitW( *s
)) s
++;
1437 if (*s
== '\0') return TRUE
;
1438 time
->wHour
= strtolW( s
, &end
, 10 );
1441 while (*s
&& !isdigitW( *s
)) s
++;
1442 if (*s
== '\0') return TRUE
;
1443 time
->wMinute
= strtolW( s
, &end
, 10 );
1446 while (*s
&& !isdigitW( *s
)) s
++;
1447 if (*s
== '\0') return TRUE
;
1448 time
->wSecond
= strtolW( s
, &end
, 10 );
1451 time
->wMilliseconds
= 0;