?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wusa: Support wow64 architecture identifier.
[wine.git] / dlls / winhttp / session.c
blob3b00d2448d16557605a49d6bf2ac15450f59147a
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 <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winsock2.h"
24 #include "ws2ipdef.h"
25 #include "ws2tcpip.h"
26 #include "winhttp.h"
27 #include "winreg.h"
28 #include "winternl.h"
29 #include "iphlpapi.h"
30 #include "dhcpcsdk.h"
31 #define COBJMACROS
32 #include "ole2.h"
33 #include "dispex.h"
34 #include "activscp.h"
35
36 #include "wine/debug.h"
37 #include "winhttp_private.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
40
41 #define DEFAULT_RESOLVE_TIMEOUT 0
42 #define DEFAULT_CONNECT_TIMEOUT 20000
43 #define DEFAULT_SEND_TIMEOUT 30000
44 #define DEFAULT_RECEIVE_TIMEOUT 30000
45 #define DEFAULT_RECEIVE_RESPONSE_TIMEOUT ~0u
46
47 void send_callback( struct object_header *hdr, DWORD status, void *info, DWORD buflen )
48 {
49 if (hdr->callback && (hdr->notify_mask & status))
50 {
51 TRACE( "%p, %#lx, %p, %lu, %lu\n", hdr, status, info, buflen, hdr->recursion_count );
52 InterlockedIncrement( &hdr->recursion_count );
53 hdr->callback( hdr->handle, hdr->context, status, info, buflen );
54 InterlockedDecrement( &hdr->recursion_count );
55 TRACE("returning from %#lx callback\n", status);
56 }
57 }
58
59 /***********************************************************************
60 * WinHttpCheckPlatform (winhttp.@)
61 */
62 BOOL WINAPI WinHttpCheckPlatform( void )
63 {
64 TRACE("\n");
65 return TRUE;
66 }
67
68 static void session_destroy( struct object_header *hdr )
69 {
70 struct session *session = (struct session *)hdr;
71
72 TRACE("%p\n", session);
73
74 if (session->unload_event) SetEvent( session->unload_event );
75 destroy_cookies( session );
76
77 session->cs.DebugInfo->Spare[0] = 0;
78 DeleteCriticalSection( &session->cs );
79 free( session->agent );
80 free( session->proxy_server );
81 free( session->proxy_bypass );
82 free( session->proxy_username );
83 free( session->proxy_password );
84 free( session );
85 }
86
87 static BOOL validate_buffer( void *buffer, DWORD *buflen, DWORD required )
88 {
89 if (!buffer || *buflen < required)
90 {
91 *buflen = required;
92 SetLastError( ERROR_INSUFFICIENT_BUFFER );
93 return FALSE;
94 }
95 return TRUE;
96 }
97
98 static BOOL session_query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
99 {
100 struct session *session = (struct session *)hdr;
101
102 switch (option)
103 {
104 case WINHTTP_OPTION_REDIRECT_POLICY:
105 {
106 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
107
108 *(DWORD *)buffer = hdr->redirect_policy;
109 *buflen = sizeof(DWORD);
110 return TRUE;
111 }
112 case WINHTTP_OPTION_RESOLVE_TIMEOUT:
113 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
114
115 *(DWORD *)buffer = session->resolve_timeout;
116 *buflen = sizeof(DWORD);
117 return TRUE;
118
119 case WINHTTP_OPTION_CONNECT_TIMEOUT:
120 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
121
122 *(DWORD *)buffer = session->connect_timeout;
123 *buflen = sizeof(DWORD);
124 return TRUE;
125
126 case WINHTTP_OPTION_SEND_TIMEOUT:
127 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
128
129 *(DWORD *)buffer = session->send_timeout;
130 *buflen = sizeof(DWORD);
131 return TRUE;
132
133 case WINHTTP_OPTION_RECEIVE_TIMEOUT:
134 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
135
136 *(DWORD *)buffer = session->receive_timeout;
137 *buflen = sizeof(DWORD);
138 return TRUE;
139
140 case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
141 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
142
143 *(DWORD *)buffer = session->receive_response_timeout;
144 *buflen = sizeof(DWORD);
145 return TRUE;
146
147 default:
148 FIXME( "unimplemented option %lu\n", option );
149 SetLastError( ERROR_INVALID_PARAMETER );
150 return FALSE;
151 }
152 }
153
154 static BOOL session_set_option( struct object_header *hdr, DWORD option, void *buffer, DWORD buflen )
155 {
156 struct session *session = (struct session *)hdr;
157
158 switch (option)
159 {
160 case WINHTTP_OPTION_PROXY:
161 {
162 WINHTTP_PROXY_INFO *pi = buffer;
163
164 FIXME( "%lu %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass) );
165 return TRUE;
166 }
167 case WINHTTP_OPTION_REDIRECT_POLICY:
168 {
169 DWORD policy;
170
171 if (buflen != sizeof(policy))
172 {
173 SetLastError( ERROR_INSUFFICIENT_BUFFER );
174 return FALSE;
175 }
176
177 policy = *(DWORD *)buffer;
178 TRACE( "%#lx\n", policy );
179 hdr->redirect_policy = policy;
180 return TRUE;
181 }
182 case WINHTTP_OPTION_SECURE_PROTOCOLS:
183 {
184 if (buflen != sizeof(session->secure_protocols))
185 {
186 SetLastError( ERROR_INSUFFICIENT_BUFFER );
187 return FALSE;
188 }
189 EnterCriticalSection( &session->cs );
190 session->secure_protocols = *(DWORD *)buffer;
191 LeaveCriticalSection( &session->cs );
192 TRACE( "%#lx\n", session->secure_protocols );
193 return TRUE;
194 }
195 case WINHTTP_OPTION_DISABLE_FEATURE:
196 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
197 return FALSE;
198
199 case WINHTTP_OPTION_RESOLVE_TIMEOUT:
200 session->resolve_timeout = *(DWORD *)buffer;
201 return TRUE;
202
203 case WINHTTP_OPTION_CONNECT_TIMEOUT:
204 session->connect_timeout = *(DWORD *)buffer;
205 return TRUE;
206
207 case WINHTTP_OPTION_SEND_TIMEOUT:
208 session->send_timeout = *(DWORD *)buffer;
209 return TRUE;
210
211 case WINHTTP_OPTION_RECEIVE_TIMEOUT:
212 session->receive_timeout = *(DWORD *)buffer;
213 return TRUE;
214
215 case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
216 session->receive_response_timeout = *(DWORD *)buffer;
217 return TRUE;
218
219 case WINHTTP_OPTION_CONFIGURE_PASSPORT_AUTH:
220 session->passport_flags = *(DWORD *)buffer;
221 return TRUE;
222
223 case WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT:
224 TRACE("WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT: %p\n", *(HANDLE *)buffer);
225 session->unload_event = *(HANDLE *)buffer;
226 return TRUE;
227
228 case WINHTTP_OPTION_MAX_CONNS_PER_SERVER:
229 FIXME( "WINHTTP_OPTION_MAX_CONNS_PER_SERVER: %lu\n", *(DWORD *)buffer );
230 return TRUE;
231
232 case WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER:
233 FIXME( "WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER: %lu\n", *(DWORD *)buffer );
234 return TRUE;
235
236 default:
237 FIXME( "unimplemented option %lu\n", option );
238 SetLastError( ERROR_WINHTTP_INVALID_OPTION );
239 return FALSE;
240 }
241 }
242
243 static const struct object_vtbl session_vtbl =
244 {
245 session_destroy,
246 session_query_option,
247 session_set_option
248 };
249
250 /***********************************************************************
251 * WinHttpOpen (winhttp.@)
252 */
253 HINTERNET WINAPI WinHttpOpen( LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags )
254 {
255 struct session *session;
256 HINTERNET handle = NULL;
257
258 TRACE( "%s, %lu, %s, %s, %#lx\n", debugstr_w(agent), access, debugstr_w(proxy), debugstr_w(bypass), flags );
259
260 if (!(session = calloc( 1, sizeof(*session) ))) return NULL;
261
262 session->hdr.type = WINHTTP_HANDLE_TYPE_SESSION;
263 session->hdr.vtbl = &session_vtbl;
264 session->hdr.flags = flags;
265 session->hdr.refs = 1;
266 session->hdr.redirect_policy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
267 session->resolve_timeout = DEFAULT_RESOLVE_TIMEOUT;
268 session->connect_timeout = DEFAULT_CONNECT_TIMEOUT;
269 session->send_timeout = DEFAULT_SEND_TIMEOUT;
270 session->receive_timeout = DEFAULT_RECEIVE_TIMEOUT;
271 session->receive_response_timeout = DEFAULT_RECEIVE_RESPONSE_TIMEOUT;
272 list_init( &session->cookie_cache );
273 InitializeCriticalSection( &session->cs );
274 session->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": session.cs");
275
276 if (agent && !(session->agent = strdupW( agent ))) goto end;
277 if (access == WINHTTP_ACCESS_TYPE_DEFAULT_PROXY)
278 {
279 WINHTTP_PROXY_INFO info;
280
281 WinHttpGetDefaultProxyConfiguration( &info );
282 session->access = info.dwAccessType;
283 if (info.lpszProxy && !(session->proxy_server = strdupW( info.lpszProxy )))
284 {
285 GlobalFree( info.lpszProxy );
286 GlobalFree( info.lpszProxyBypass );
287 goto end;
288 }
289 if (info.lpszProxyBypass && !(session->proxy_bypass = strdupW( info.lpszProxyBypass )))
290 {
291 GlobalFree( info.lpszProxy );
292 GlobalFree( info.lpszProxyBypass );
293 goto end;
294 }
295 }
296 else if (access == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
297 {
298 session->access = access;
299 if (proxy && !(session->proxy_server = strdupW( proxy ))) goto end;
300 if (bypass && !(session->proxy_bypass = strdupW( bypass ))) goto end;
301 }
302
303 handle = alloc_handle( &session->hdr );
304
305 end:
306 release_object( &session->hdr );
307 TRACE("returning %p\n", handle);
308 if (handle) SetLastError( ERROR_SUCCESS );
309 return handle;
310 }
311
312 static void connect_destroy( struct object_header *hdr )
313 {
314 struct connect *connect = (struct connect *)hdr;
315
316 TRACE("%p\n", connect);
317
318 release_object( &connect->session->hdr );
319
320 free( connect->hostname );
321 free( connect->servername );
322 free( connect->username );
323 free( connect->password );
324 free( connect );
325 }
326
327 static BOOL connect_query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
328 {
329 struct connect *connect = (struct connect *)hdr;
330
331 switch (option)
332 {
333 case WINHTTP_OPTION_PARENT_HANDLE:
334 {
335 if (!validate_buffer( buffer, buflen, sizeof(HINTERNET) )) return FALSE;
336
337 *(HINTERNET *)buffer = ((struct object_header *)connect->session)->handle;
338 *buflen = sizeof(HINTERNET);
339 return TRUE;
340 }
341 case WINHTTP_OPTION_RESOLVE_TIMEOUT:
342 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
343
344 *(DWORD *)buffer = connect->session->resolve_timeout;
345 *buflen = sizeof(DWORD);
346 return TRUE;
347
348 case WINHTTP_OPTION_CONNECT_TIMEOUT:
349 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
350
351 *(DWORD *)buffer = connect->session->connect_timeout;
352 *buflen = sizeof(DWORD);
353 return TRUE;
354
355 case WINHTTP_OPTION_SEND_TIMEOUT:
356 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
357
358 *(DWORD *)buffer = connect->session->send_timeout;
359 *buflen = sizeof(DWORD);
360 return TRUE;
361
362 case WINHTTP_OPTION_RECEIVE_TIMEOUT:
363 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
364
365 *(DWORD *)buffer = connect->session->receive_timeout;
366 *buflen = sizeof(DWORD);
367 return TRUE;
368
369 case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
370 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
371
372 *(DWORD *)buffer = connect->session->receive_response_timeout;
373 *buflen = sizeof(DWORD);
374 return TRUE;
375
376 default:
377 FIXME( "unimplemented option %lu\n", option );
378 SetLastError( ERROR_INVALID_PARAMETER );
379 return FALSE;
380 }
381 }
382
383 static const struct object_vtbl connect_vtbl =
384 {
385 connect_destroy,
386 connect_query_option,
387 NULL
388 };
389
390 static BOOL domain_matches(LPCWSTR server, LPCWSTR domain)
391 {
392 BOOL ret = FALSE;
393
394 if (!wcsicmp( domain, L"<local>" ) && !wcschr( server, '.' ))
395 ret = TRUE;
396 else if (*domain == '*')
397 {
398 if (domain[1] == '.')
399 {
400 LPCWSTR dot;
401
402 /* For a hostname to match a wildcard, the last domain must match
403 * the wildcard exactly. E.g. if the wildcard is *.a.b, and the
404 * hostname is www.foo.a.b, it matches, but a.b does not.
405 */
406 dot = wcschr( server, '.' );
407 if (dot)
408 {
409 int len = lstrlenW( dot + 1 );
410
411 if (len > lstrlenW( domain + 2 ))
412 {
413 LPCWSTR ptr;
414
415 /* The server's domain is longer than the wildcard, so it
416 * could be a subdomain. Compare the last portion of the
417 * server's domain.
418 */
419 ptr = dot + len + 1 - lstrlenW( domain + 2 );
420 if (!wcsicmp( ptr, domain + 2 ))
421 {
422 /* This is only a match if the preceding character is
423 * a '.', i.e. that it is a matching domain. E.g.
424 * if domain is '*.b.c' and server is 'www.ab.c' they
425 * do not match.
426 */
427 ret = *(ptr - 1) == '.';
428 }
429 }
430 else
431 ret = !wcsicmp( dot + 1, domain + 2 );
432 }
433 }
434 }
435 else
436 ret = !wcsicmp( server, domain );
437 return ret;
438 }
439
440 /* Matches INTERNET_MAX_HOST_NAME_LENGTH in wininet.h, also RFC 1035 */
441 #define MAX_HOST_NAME_LENGTH 256
442
443 static BOOL should_bypass_proxy(struct session *session, LPCWSTR server)
444 {
445 LPCWSTR ptr;
446 BOOL ret = FALSE;
447
448 if (!session->proxy_bypass) return FALSE;
449 ptr = session->proxy_bypass;
450 do {
451 LPCWSTR tmp = ptr;
452
453 ptr = wcschr( ptr, ';' );
454 if (!ptr)
455 ptr = wcschr( tmp, ' ' );
456 if (ptr)
457 {
458 if (ptr - tmp < MAX_HOST_NAME_LENGTH)
459 {
460 WCHAR domain[MAX_HOST_NAME_LENGTH];
461
462 memcpy( domain, tmp, (ptr - tmp) * sizeof(WCHAR) );
463 domain[ptr - tmp] = 0;
464 ret = domain_matches( server, domain );
465 }
466 ptr += 1;
467 }
468 else if (*tmp)
469 ret = domain_matches( server, tmp );
470 } while (ptr && !ret);
471 return ret;
472 }
473
474 BOOL set_server_for_hostname( struct connect *connect, const WCHAR *server, INTERNET_PORT port )
475 {
476 struct session *session = connect->session;
477 BOOL ret = TRUE;
478
479 if (session->proxy_server && !should_bypass_proxy(session, server))
480 {
481 LPCWSTR colon;
482
483 if ((colon = wcschr( session->proxy_server, ':' )))
484 {
485 if (!connect->servername || wcsnicmp( connect->servername,
486 session->proxy_server, colon - session->proxy_server - 1 ))
487 {
488 free( connect->servername );
489 connect->resolved = FALSE;
490 if (!(connect->servername = malloc( (colon - session->proxy_server + 1) * sizeof(WCHAR) )))
491 {
492 ret = FALSE;
493 goto end;
494 }
495 memcpy( connect->servername, session->proxy_server, (colon - session->proxy_server) * sizeof(WCHAR) );
496 connect->servername[colon - session->proxy_server] = 0;
497 if (*(colon + 1))
498 connect->serverport = wcstol( colon + 1, NULL, 10 );
499 else
500 connect->serverport = INTERNET_DEFAULT_PORT;
501 }
502 }
503 else
504 {
505 if (!connect->servername || wcsicmp( connect->servername, session->proxy_server ))
506 {
507 free( connect->servername );
508 connect->resolved = FALSE;
509 if (!(connect->servername = strdupW( session->proxy_server )))
510 {
511 ret = FALSE;
512 goto end;
513 }
514 connect->serverport = INTERNET_DEFAULT_PORT;
515 }
516 }
517 }
518 else if (server)
519 {
520 free( connect->servername );
521 connect->resolved = FALSE;
522 if (!(connect->servername = strdupW( server )))
523 {
524 ret = FALSE;
525 goto end;
526 }
527 connect->serverport = port;
528 }
529 end:
530 return ret;
531 }
532
533 /***********************************************************************
534 * WinHttpConnect (winhttp.@)
535 */
536 HINTERNET WINAPI WinHttpConnect( HINTERNET hsession, const WCHAR *server, INTERNET_PORT port, DWORD reserved )
537 {
538 struct connect *connect;
539 struct session *session;
540 HINTERNET hconnect = NULL;
541
542 TRACE( "%p, %s, %u, %#lx\n", hsession, debugstr_w(server), port, reserved );
543
544 if (!server)
545 {
546 SetLastError( ERROR_INVALID_PARAMETER );
547 return NULL;
548 }
549 if (!(session = (struct session *)grab_object( hsession )))
550 {
551 SetLastError( ERROR_INVALID_HANDLE );
552 return NULL;
553 }
554 if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
555 {
556 release_object( &session->hdr );
557 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
558 return NULL;
559 }
560 if (!(connect = calloc( 1, sizeof(*connect) )))
561 {
562 release_object( &session->hdr );
563 return NULL;
564 }
565 connect->hdr.type = WINHTTP_HANDLE_TYPE_CONNECT;
566 connect->hdr.vtbl = &connect_vtbl;
567 connect->hdr.refs = 1;
568 connect->hdr.flags = session->hdr.flags;
569 connect->hdr.callback = session->hdr.callback;
570 connect->hdr.notify_mask = session->hdr.notify_mask;
571 connect->hdr.context = session->hdr.context;
572 connect->hdr.redirect_policy = session->hdr.redirect_policy;
573
574 addref_object( &session->hdr );
575 connect->session = session;
576
577 if (!(connect->hostname = strdupW( server ))) goto end;
578 connect->hostport = port;
579 if (!set_server_for_hostname( connect, server, port )) goto end;
580
581 if ((hconnect = alloc_handle( &connect->hdr )))
582 {
583 send_callback( &session->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hconnect, sizeof(hconnect) );
584 }
585
586 end:
587 release_object( &connect->hdr );
588 release_object( &session->hdr );
589 TRACE("returning %p\n", hconnect);
590 if (hconnect) SetLastError( ERROR_SUCCESS );
591 return hconnect;
592 }
593
594 static void request_destroy( struct object_header *hdr )
595 {
596 struct request *request = (struct request *)hdr;
597 unsigned int i, j;
598
599 TRACE("%p\n", request);
600
601 stop_queue( &request->queue );
602 release_object( &request->connect->hdr );
603
604 if (request->cred_handle_initialized) FreeCredentialsHandle( &request->cred_handle );
605 CertFreeCertificateContext( request->server_cert );
606 CertFreeCertificateContext( request->client_cert );
607
608 destroy_authinfo( request->authinfo );
609 destroy_authinfo( request->proxy_authinfo );
610
611 free( request->verb );
612 free( request->path );
613 free( request->version );
614 free( request->raw_headers );
615 free( request->status_text );
616 for (i = 0; i < request->num_headers; i++)
617 {
618 free( request->headers[i].field );
619 free( request->headers[i].value );
620 }
621 free( request->headers );
622 for (i = 0; i < TARGET_MAX; i++)
623 {
624 for (j = 0; j < SCHEME_MAX; j++)
625 {
626 free( request->creds[i][j].username );
627 free( request->creds[i][j].password );
628 }
629 }
630
631 free( request );
632 }
633
634 static void str_to_buffer( WCHAR *buffer, const WCHAR *str, LPDWORD buflen )
635 {
636 int len = 0;
637 if (str) len = lstrlenW( str );
638 if (buffer && *buflen > len)
639 {
640 if (str) memcpy( buffer, str, len * sizeof(WCHAR) );
641 buffer[len] = 0;
642 }
643 *buflen = len * sizeof(WCHAR);
644 }
645
646 static WCHAR *blob_to_str( DWORD encoding, CERT_NAME_BLOB *blob )
647 {
648 WCHAR *ret;
649 DWORD size, format = CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG;
650
651 size = CertNameToStrW( encoding, blob, format, NULL, 0 );
652 if ((ret = LocalAlloc( 0, size * sizeof(WCHAR) )))
653 CertNameToStrW( encoding, blob, format, ret, size );
654
655 return ret;
656 }
657
658 static BOOL copy_sockaddr( const struct sockaddr *addr, SOCKADDR_STORAGE *addr_storage )
659 {
660 switch (addr->sa_family)
661 {
662 case AF_INET:
663 {
664 struct sockaddr_in *addr_in = (struct sockaddr_in *)addr_storage;
665
666 memcpy( addr_in, addr, sizeof(*addr_in) );
667 memset( addr_in + 1, 0, sizeof(*addr_storage) - sizeof(*addr_in) );
668 return TRUE;
669 }
670 case AF_INET6:
671 {
672 struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr_storage;
673
674 memcpy( addr_in6, addr, sizeof(*addr_in6) );
675 memset( addr_in6 + 1, 0, sizeof(*addr_storage) - sizeof(*addr_in6) );
676 return TRUE;
677 }
678 default:
679 ERR("unhandled family %u\n", addr->sa_family);
680 return FALSE;
681 }
682 }
683
684 static BOOL request_query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
685 {
686 struct request *request = (struct request *)hdr;
687
688 switch (option)
689 {
690 case WINHTTP_OPTION_SECURITY_FLAGS:
691 {
692 DWORD flags;
693 int bits;
694
695 if (!validate_buffer( buffer, buflen, sizeof(flags) )) return FALSE;
696
697 flags = request->security_flags;
698 if (request->netconn)
699 {
700 bits = netconn_get_cipher_strength( request->netconn );
701 if (bits >= 128)
702 flags |= SECURITY_FLAG_STRENGTH_STRONG;
703 else if (bits >= 56)
704 flags |= SECURITY_FLAG_STRENGTH_MEDIUM;
705 else
706 flags |= SECURITY_FLAG_STRENGTH_WEAK;
707 }
708 *(DWORD *)buffer = flags;
709 *buflen = sizeof(flags);
710 return TRUE;
711 }
712 case WINHTTP_OPTION_SERVER_CERT_CONTEXT:
713 {
714 const CERT_CONTEXT *cert;
715
716 if (!validate_buffer( buffer, buflen, sizeof(cert) )) return FALSE;
717
718 if (!(cert = CertDuplicateCertificateContext( request->server_cert ))) return FALSE;
719 *(CERT_CONTEXT **)buffer = (CERT_CONTEXT *)cert;
720 *buflen = sizeof(cert);
721 return TRUE;
722 }
723 case WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT:
724 {
725 const CERT_CONTEXT *cert = request->server_cert;
726 const CRYPT_OID_INFO *oidInfo;
727 WINHTTP_CERTIFICATE_INFO *ci = buffer;
728
729 FIXME("partial stub\n");
730
731 if (!validate_buffer( buffer, buflen, sizeof(*ci) ) || !cert) return FALSE;
732
733 ci->ftExpiry = cert->pCertInfo->NotAfter;
734 ci->ftStart = cert->pCertInfo->NotBefore;
735 ci->lpszSubjectInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Subject );
736 ci->lpszIssuerInfo = blob_to_str( cert->dwCertEncodingType, &cert->pCertInfo->Issuer );
737 ci->lpszProtocolName = NULL;
738 oidInfo = CryptFindOIDInfo( CRYPT_OID_INFO_OID_KEY, cert->pCertInfo->SignatureAlgorithm.pszObjId, 0 );
739 if (oidInfo)
740 ci->lpszSignatureAlgName = (LPWSTR)oidInfo->pwszName;
741 else
742 ci->lpszSignatureAlgName = NULL;
743 ci->lpszEncryptionAlgName = NULL;
744 ci->dwKeySize = request->netconn ? netconn_get_cipher_strength( request->netconn ) : 0;
745
746 *buflen = sizeof(*ci);
747 return TRUE;
748 }
749 case WINHTTP_OPTION_SECURITY_KEY_BITNESS:
750 {
751 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
752
753 *(DWORD *)buffer = request->netconn ? netconn_get_cipher_strength( request->netconn ) : 0;
754 *buflen = sizeof(DWORD);
755 return TRUE;
756 }
757 case WINHTTP_OPTION_CONNECTION_INFO:
758 {
759 WINHTTP_CONNECTION_INFO *info = buffer;
760 struct sockaddr local;
761 socklen_t len = sizeof(local);
762 const struct sockaddr *remote = (const struct sockaddr *)&request->connect->sockaddr;
763
764 if (!validate_buffer( buffer, buflen, sizeof(*info) )) return FALSE;
765
766 if (!request->netconn)
767 {
768 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_STATE );
769 return FALSE;
770 }
771 if (getsockname( request->netconn->socket, &local, &len )) return FALSE;
772 if (!copy_sockaddr( &local, &info->LocalAddress )) return FALSE;
773 if (!copy_sockaddr( remote, &info->RemoteAddress )) return FALSE;
774 info->cbSize = sizeof(*info);
775 return TRUE;
776 }
777 case WINHTTP_OPTION_RESOLVE_TIMEOUT:
778 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
779
780 *(DWORD *)buffer = request->resolve_timeout;
781 *buflen = sizeof(DWORD);
782 return TRUE;
783
784 case WINHTTP_OPTION_CONNECT_TIMEOUT:
785 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
786
787 *(DWORD *)buffer = request->connect_timeout;
788 *buflen = sizeof(DWORD);
789 return TRUE;
790
791 case WINHTTP_OPTION_SEND_TIMEOUT:
792 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
793
794 *(DWORD *)buffer = request->send_timeout;
795 *buflen = sizeof(DWORD);
796 return TRUE;
797
798 case WINHTTP_OPTION_RECEIVE_TIMEOUT:
799 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
800
801 *(DWORD *)buffer = request->receive_timeout;
802 *buflen = sizeof(DWORD);
803 return TRUE;
804
805 case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
806 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
807
808 *(DWORD *)buffer = request->receive_response_timeout;
809 *buflen = sizeof(DWORD);
810 return TRUE;
811
812 case WINHTTP_OPTION_USERNAME:
813 str_to_buffer( buffer, request->connect->username, buflen );
814 return TRUE;
815
816 case WINHTTP_OPTION_PASSWORD:
817 str_to_buffer( buffer, request->connect->password, buflen );
818 return TRUE;
819
820 case WINHTTP_OPTION_PROXY_USERNAME:
821 str_to_buffer( buffer, request->connect->session->proxy_username, buflen );
822 return TRUE;
823
824 case WINHTTP_OPTION_PROXY_PASSWORD:
825 str_to_buffer( buffer, request->connect->session->proxy_password, buflen );
826 return TRUE;
827
828 case WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS:
829 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
830
831 *(DWORD *)buffer = request->max_redirects;
832 *buflen = sizeof(DWORD);
833 return TRUE;
834
835 case WINHTTP_OPTION_HTTP_PROTOCOL_USED:
836 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
837
838 FIXME("WINHTTP_OPTION_HTTP_PROTOCOL_USED\n");
839 *(DWORD *)buffer = 0;
840 *buflen = sizeof(DWORD);
841 return TRUE;
842
843 default:
844 FIXME( "unimplemented option %lu\n", option );
845 SetLastError( ERROR_INVALID_PARAMETER );
846 return FALSE;
847 }
848 }
849
850 static WCHAR *buffer_to_str( WCHAR *buffer, DWORD buflen )
851 {
852 WCHAR *ret;
853 if ((ret = malloc( (buflen + 1) * sizeof(WCHAR))))
854 {
855 memcpy( ret, buffer, buflen * sizeof(WCHAR) );
856 ret[buflen] = 0;
857 return ret;
858 }
859 SetLastError( ERROR_OUTOFMEMORY );
860 return NULL;
861 }
862
863 static BOOL request_set_option( struct object_header *hdr, DWORD option, void *buffer, DWORD buflen )
864 {
865 struct request *request = (struct request *)hdr;
866
867 switch (option)
868 {
869 case WINHTTP_OPTION_PROXY:
870 {
871 WINHTTP_PROXY_INFO *pi = buffer;
872
873 FIXME( "%lu %s %s\n", pi->dwAccessType, debugstr_w(pi->lpszProxy), debugstr_w(pi->lpszProxyBypass) );
874 return TRUE;
875 }
876 case WINHTTP_OPTION_DISABLE_FEATURE:
877 {
878 DWORD disable;
879
880 if (buflen != sizeof(DWORD))
881 {
882 SetLastError( ERROR_INSUFFICIENT_BUFFER );
883 return FALSE;
884 }
885
886 disable = *(DWORD *)buffer;
887 TRACE( "%#lx\n", disable );
888 hdr->disable_flags |= disable;
889 return TRUE;
890 }
891 case WINHTTP_OPTION_AUTOLOGON_POLICY:
892 {
893 DWORD policy;
894
895 if (buflen != sizeof(DWORD))
896 {
897 SetLastError( ERROR_INSUFFICIENT_BUFFER );
898 return FALSE;
899 }
900
901 policy = *(DWORD *)buffer;
902 TRACE( "%#lx\n", policy );
903 hdr->logon_policy = policy;
904 return TRUE;
905 }
906 case WINHTTP_OPTION_REDIRECT_POLICY:
907 {
908 DWORD policy;
909
910 if (buflen != sizeof(DWORD))
911 {
912 SetLastError( ERROR_INSUFFICIENT_BUFFER );
913 return FALSE;
914 }
915
916 policy = *(DWORD *)buffer;
917 TRACE( "%#lx\n", policy );
918 hdr->redirect_policy = policy;
919 return TRUE;
920 }
921 case WINHTTP_OPTION_SECURITY_FLAGS:
922 {
923 DWORD flags;
924 static const DWORD accepted = SECURITY_FLAG_IGNORE_CERT_CN_INVALID |
925 SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
926 SECURITY_FLAG_IGNORE_UNKNOWN_CA |
927 SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE;
928
929 if (buflen < sizeof(DWORD))
930 {
931 SetLastError( ERROR_INSUFFICIENT_BUFFER );
932 return FALSE;
933 }
934 flags = *(DWORD *)buffer;
935 TRACE( "%#lx\n", flags );
936 if (flags && (flags & ~accepted))
937 {
938 SetLastError( ERROR_INVALID_PARAMETER );
939 return FALSE;
940 }
941 request->security_flags = flags;
942 return TRUE;
943 }
944 case WINHTTP_OPTION_RESOLVE_TIMEOUT:
945 request->resolve_timeout = *(DWORD *)buffer;
946 return TRUE;
947
948 case WINHTTP_OPTION_CONNECT_TIMEOUT:
949 request->connect_timeout = *(DWORD *)buffer;
950 return TRUE;
951
952 case WINHTTP_OPTION_SEND_TIMEOUT:
953 request->send_timeout = *(DWORD *)buffer;
954 return TRUE;
955
956 case WINHTTP_OPTION_RECEIVE_TIMEOUT:
957 request->receive_timeout = *(DWORD *)buffer;
958 return TRUE;
959
960 case WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT:
961 request->receive_response_timeout = *(DWORD *)buffer;
962 return TRUE;
963
964 case WINHTTP_OPTION_USERNAME:
965 {
966 struct connect *connect = request->connect;
967
968 free( connect->username );
969 if (!(connect->username = buffer_to_str( buffer, buflen ))) return FALSE;
970 return TRUE;
971 }
972 case WINHTTP_OPTION_PASSWORD:
973 {
974 struct connect *connect = request->connect;
975
976 free( connect->password );
977 if (!(connect->password = buffer_to_str( buffer, buflen ))) return FALSE;
978 return TRUE;
979 }
980 case WINHTTP_OPTION_PROXY_USERNAME:
981 {
982 struct session *session = request->connect->session;
983
984 free( session->proxy_username );
985 if (!(session->proxy_username = buffer_to_str( buffer, buflen ))) return FALSE;
986 return TRUE;
987 }
988 case WINHTTP_OPTION_PROXY_PASSWORD:
989 {
990 struct session *session = request->connect->session;
991
992 free( session->proxy_password );
993 if (!(session->proxy_password = buffer_to_str( buffer, buflen ))) return FALSE;
994 return TRUE;
995 }
996 case WINHTTP_OPTION_CLIENT_CERT_CONTEXT:
997 {
998 const CERT_CONTEXT *cert;
999
1000 if (!(hdr->flags & WINHTTP_FLAG_SECURE))
1001 {
1002 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_STATE );
1003 return FALSE;
1004 }
1005 if (!buffer)
1006 {
1007 CertFreeCertificateContext( request->client_cert );
1008 request->client_cert = NULL;
1009 }
1010 else if (buflen >= sizeof(*cert))
1011 {
1012 if (!(cert = CertDuplicateCertificateContext( buffer ))) return FALSE;
1013 CertFreeCertificateContext( request->client_cert );
1014 request->client_cert = cert;
1015 }
1016 else
1017 {
1018 SetLastError( ERROR_INVALID_PARAMETER );
1019 return FALSE;
1020 }
1021
1022 if (request->cred_handle_initialized)
1023 {
1024 FreeCredentialsHandle( &request->cred_handle );
1025 request->cred_handle_initialized = FALSE;
1026 }
1027
1028 return TRUE;
1029 }
1030 case WINHTTP_OPTION_ENABLE_FEATURE:
1031 if(buflen == sizeof( DWORD ) && *(DWORD *)buffer == WINHTTP_ENABLE_SSL_REVOCATION)
1032 {
1033 request->check_revocation = TRUE;
1034 SetLastError( NO_ERROR );
1035 return TRUE;
1036 }
1037 else
1038 {
1039 SetLastError( ERROR_INVALID_PARAMETER );
1040 return FALSE;
1041 }
1042
1043 case WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET:
1044 request->flags |= REQUEST_FLAG_WEBSOCKET_UPGRADE;
1045 return TRUE;
1046
1047 case WINHTTP_OPTION_CONNECT_RETRIES:
1048 FIXME("WINHTTP_OPTION_CONNECT_RETRIES\n");
1049 return TRUE;
1050
1051 case WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS:
1052 if (buflen == sizeof(DWORD))
1053 {
1054 request->max_redirects = *(DWORD *)buffer;
1055 SetLastError(NO_ERROR);
1056 return TRUE;
1057 }
1058
1059 SetLastError(ERROR_INVALID_PARAMETER);
1060 return FALSE;
1061
1062 case WINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZE:
1063 FIXME("WINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZE\n");
1064 return TRUE;
1065
1066 case WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE:
1067 FIXME("WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE\n");
1068 return TRUE;
1069
1070 case WINHTTP_OPTION_ENABLE_HTTP_PROTOCOL:
1071 if (buflen == sizeof(DWORD))
1072 {
1073 FIXME( "WINHTTP_OPTION_ENABLE_HTTP_PROTOCOL %#lx\n", *(DWORD *)buffer );
1074 return TRUE;
1075 }
1076 SetLastError(ERROR_INVALID_PARAMETER);
1077 return FALSE;
1078
1079 default:
1080 FIXME( "unimplemented option %lu\n", option );
1081 SetLastError( ERROR_WINHTTP_INVALID_OPTION );
1082 return FALSE;
1083 }
1084 }
1085
1086 static const struct object_vtbl request_vtbl =
1087 {
1088 request_destroy,
1089 request_query_option,
1090 request_set_option
1091 };
1092
1093 static BOOL add_accept_types_header( struct request *request, const WCHAR **types )
1094 {
1095 static const DWORD flags = WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA;
1096
1097 if (!types) return TRUE;
1098 while (*types)
1099 {
1100 if (process_header( request, L"Accept", *types, flags, TRUE )) return FALSE;
1101 types++;
1102 }
1103 return TRUE;
1104 }
1105
1106 static WCHAR *get_request_path( const WCHAR *object )
1107 {
1108 int len = object ? lstrlenW(object) : 0;
1109 WCHAR *p, *ret;
1110
1111 if (!object || object[0] != '/') len++;
1112 if (!(p = ret = malloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
1113 if (!object || object[0] != '/') *p++ = '/';
1114 if (object) lstrcpyW( p, object );
1115 ret[len] = 0;
1116 return ret;
1117 }
1118
1119 /***********************************************************************
1120 * WinHttpOpenRequest (winhttp.@)
1121 */
1122 HINTERNET WINAPI WinHttpOpenRequest( HINTERNET hconnect, const WCHAR *verb, const WCHAR *object, const WCHAR *version,
1123 const WCHAR *referrer, const WCHAR **types, DWORD flags )
1124 {
1125 struct request *request;
1126 struct connect *connect;
1127 HINTERNET hrequest = NULL;
1128
1129 TRACE( "%p, %s, %s, %s, %s, %p, %#lx\n", hconnect, debugstr_w(verb), debugstr_w(object),
1130 debugstr_w(version), debugstr_w(referrer), types, flags );
1131
1132 if (types && TRACE_ON(winhttp))
1133 {
1134 const WCHAR **iter;
1135 TRACE("accept types:\n");
1136 for (iter = types; *iter; iter++) TRACE(" %s\n", debugstr_w(*iter));
1137 }
1138
1139 if (!(connect = (struct connect *)grab_object( hconnect )))
1140 {
1141 SetLastError( ERROR_INVALID_HANDLE );
1142 return NULL;
1143 }
1144 if (connect->hdr.type != WINHTTP_HANDLE_TYPE_CONNECT)
1145 {
1146 release_object( &connect->hdr );
1147 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1148 return NULL;
1149 }
1150 if (!(request = calloc( 1, sizeof(*request) )))
1151 {
1152 release_object( &connect->hdr );
1153 return NULL;
1154 }
1155 request->hdr.type = WINHTTP_HANDLE_TYPE_REQUEST;
1156 request->hdr.vtbl = &request_vtbl;
1157 request->hdr.refs = 1;
1158 request->hdr.flags = flags;
1159 request->hdr.callback = connect->hdr.callback;
1160 request->hdr.notify_mask = connect->hdr.notify_mask;
1161 request->hdr.context = connect->hdr.context;
1162 request->hdr.redirect_policy = connect->hdr.redirect_policy;
1163 init_queue( &request->queue );
1164
1165 addref_object( &connect->hdr );
1166 request->connect = connect;
1167
1168 request->resolve_timeout = connect->session->resolve_timeout;
1169 request->connect_timeout = connect->session->connect_timeout;
1170 request->send_timeout = connect->session->send_timeout;
1171 request->receive_timeout = connect->session->receive_timeout;
1172 request->receive_response_timeout = connect->session->receive_response_timeout;
1173 request->max_redirects = 10;
1174
1175 if (!verb || !verb[0]) verb = L"GET";
1176 if (!(request->verb = strdupW( verb ))) goto end;
1177 if (!(request->path = get_request_path( object ))) goto end;
1178
1179 if (!version || !version[0]) version = L"HTTP/1.1";
1180 if (!(request->version = strdupW( version ))) goto end;
1181 if (!(add_accept_types_header( request, types ))) goto end;
1182
1183 if ((hrequest = alloc_handle( &request->hdr )))
1184 {
1185 send_callback( &request->hdr, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED, &hrequest, sizeof(hrequest) );
1186 }
1187
1188 end:
1189 release_object( &request->hdr );
1190 release_object( &connect->hdr );
1191 TRACE("returning %p\n", hrequest);
1192 if (hrequest) SetLastError( ERROR_SUCCESS );
1193 return hrequest;
1194 }
1195
1196 /***********************************************************************
1197 * WinHttpCloseHandle (winhttp.@)
1198 */
1199 BOOL WINAPI WinHttpCloseHandle( HINTERNET handle )
1200 {
1201 struct object_header *hdr;
1202
1203 TRACE("%p\n", handle);
1204
1205 if (!(hdr = grab_object( handle )))
1206 {
1207 SetLastError( ERROR_INVALID_HANDLE );
1208 return FALSE;
1209 }
1210 release_object( hdr );
1211 free_handle( handle );
1212 SetLastError( ERROR_SUCCESS );
1213 return TRUE;
1214 }
1215
1216 static BOOL query_option( struct object_header *hdr, DWORD option, void *buffer, DWORD *buflen )
1217 {
1218 BOOL ret = FALSE;
1219
1220 if (!buflen)
1221 {
1222 SetLastError( ERROR_INVALID_PARAMETER );
1223 return FALSE;
1224 }
1225
1226 switch (option)
1227 {
1228 case WINHTTP_OPTION_WORKER_THREAD_COUNT:
1229 {
1230 FIXME( "WINHTTP_OPTION_WORKER_THREAD_COUNT semi-stub.\n" );
1231 if (!validate_buffer( buffer, buflen, sizeof(DWORD) )) return FALSE;
1232
1233 *(DWORD *)buffer = 0;
1234 *buflen = sizeof(DWORD);
1235 return TRUE;
1236 }
1237 case WINHTTP_OPTION_CONTEXT_VALUE:
1238 {
1239 if (!validate_buffer( buffer, buflen, sizeof(DWORD_PTR) )) return FALSE;
1240
1241 *(DWORD_PTR *)buffer = hdr->context;
1242 *buflen = sizeof(DWORD_PTR);
1243 return TRUE;
1244 }
1245 default:
1246 if (hdr->vtbl->query_option) ret = hdr->vtbl->query_option( hdr, option, buffer, buflen );
1247 else
1248 {
1249 FIXME( "unimplemented option %lu\n", option );
1250 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1251 return FALSE;
1252 }
1253 break;
1254 }
1255 return ret;
1256 }
1257
1258 /***********************************************************************
1259 * WinHttpQueryOption (winhttp.@)
1260 */
1261 BOOL WINAPI WinHttpQueryOption( HINTERNET handle, DWORD option, void *buffer, DWORD *buflen )
1262 {
1263 BOOL ret = FALSE;
1264 struct object_header *hdr;
1265
1266 TRACE( "%p, %lu, %p, %p\n", handle, option, buffer, buflen );
1267
1268 if (!(hdr = grab_object( handle )))
1269 {
1270 SetLastError( ERROR_INVALID_HANDLE );
1271 return FALSE;
1272 }
1273
1274 ret = query_option( hdr, option, buffer, buflen );
1275
1276 release_object( hdr );
1277 if (ret) SetLastError( ERROR_SUCCESS );
1278 return ret;
1279 }
1280
1281 static BOOL set_option( struct object_header *hdr, DWORD option, void *buffer, DWORD buflen )
1282 {
1283 BOOL ret = TRUE;
1284
1285 if (!buffer && buflen)
1286 {
1287 SetLastError( ERROR_INVALID_PARAMETER );
1288 return FALSE;
1289 }
1290
1291 switch (option)
1292 {
1293 case WINHTTP_OPTION_CONTEXT_VALUE:
1294 {
1295 if (buflen != sizeof(DWORD_PTR))
1296 {
1297 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1298 return FALSE;
1299 }
1300
1301 hdr->context = *(DWORD_PTR *)buffer;
1302 return TRUE;
1303 }
1304 default:
1305 if (hdr->vtbl->set_option) ret = hdr->vtbl->set_option( hdr, option, buffer, buflen );
1306 else
1307 {
1308 FIXME( "unimplemented option %lu\n", option );
1309 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1310 return FALSE;
1311 }
1312 break;
1313 }
1314 return ret;
1315 }
1316
1317 /***********************************************************************
1318 * WinHttpSetOption (winhttp.@)
1319 */
1320 BOOL WINAPI WinHttpSetOption( HINTERNET handle, DWORD option, void *buffer, DWORD buflen )
1321 {
1322 BOOL ret = FALSE;
1323 struct object_header *hdr;
1324
1325 TRACE( "%p, %lu, %p, %lu\n", handle, option, buffer, buflen );
1326
1327 if (!(hdr = grab_object( handle )))
1328 {
1329 SetLastError( ERROR_INVALID_HANDLE );
1330 return FALSE;
1331 }
1332
1333 ret = set_option( hdr, option, buffer, buflen );
1334
1335 release_object( hdr );
1336 if (ret) SetLastError( ERROR_SUCCESS );
1337 return ret;
1338 }
1339
1340 static IP_ADAPTER_ADDRESSES *get_adapters(void)
1341 {
1342 ULONG err, size = 1024, flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
1343 GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
1344 IP_ADAPTER_ADDRESSES *tmp, *ret;
1345
1346 if (!(ret = malloc( size ))) return NULL;
1347 err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
1348 while (err == ERROR_BUFFER_OVERFLOW)
1349 {
1350 if (!(tmp = realloc( ret, size ))) break;
1351 ret = tmp;
1352 err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
1353 }
1354 if (err == ERROR_SUCCESS) return ret;
1355 free( ret );
1356 return NULL;
1357 }
1358
1359 static WCHAR *detect_autoproxyconfig_url_dhcp(void)
1360 {
1361 IP_ADAPTER_ADDRESSES *adapters, *ptr;
1362 DHCPCAPI_PARAMS_ARRAY send_params, recv_params;
1363 DHCPCAPI_PARAMS param;
1364 WCHAR name[MAX_ADAPTER_NAME_LENGTH + 1], *ret = NULL;
1365 DWORD err, size;
1366 BYTE *tmp, *buf = NULL;
1367
1368 if (!(adapters = get_adapters())) return NULL;
1369
1370 memset( &send_params, 0, sizeof(send_params) );
1371 memset( &param, 0, sizeof(param) );
1372 param.OptionId = OPTION_MSFT_IE_PROXY;
1373 recv_params.nParams = 1;
1374 recv_params.Params = &param;
1375
1376 for (ptr = adapters; ptr; ptr = ptr->Next)
1377 {
1378 MultiByteToWideChar( CP_ACP, 0, ptr->AdapterName, -1, name, ARRAY_SIZE(name) );
1379 TRACE( "adapter '%s' type %lu dhcpv4 enabled %d\n", wine_dbgstr_w(name), ptr->IfType, ptr->Dhcpv4Enabled );
1380
1381 if (ptr->IfType == IF_TYPE_SOFTWARE_LOOPBACK) continue;
1382 /* FIXME: also skip adapters where DHCP is disabled */
1383
1384 size = 256;
1385 if (!(buf = malloc( size ))) goto done;
1386 err = DhcpRequestParams( DHCPCAPI_REQUEST_SYNCHRONOUS, NULL, name, NULL, send_params, recv_params,
1387 buf, &size, NULL );
1388 while (err == ERROR_MORE_DATA)
1389 {
1390 if (!(tmp = realloc( buf, size ))) goto done;
1391 buf = tmp;
1392 err = DhcpRequestParams( DHCPCAPI_REQUEST_SYNCHRONOUS, NULL, name, NULL, send_params, recv_params,
1393 buf, &size, NULL );
1394 }
1395 if (err == ERROR_SUCCESS && param.nBytesData)
1396 {
1397 int len = MultiByteToWideChar( CP_ACP, 0, (const char *)param.Data, param.nBytesData, NULL, 0 );
1398 if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
1399 {
1400 MultiByteToWideChar( CP_ACP, 0, (const char *)param.Data, param.nBytesData, ret, len );
1401 ret[len] = 0;
1402 }
1403 TRACE("returning %s\n", debugstr_w(ret));
1404 break;
1405 }
1406 }
1407
1408 done:
1409 free( buf );
1410 free( adapters );
1411 return ret;
1412 }
1413
1414 static char *get_computer_name( COMPUTER_NAME_FORMAT format )
1415 {
1416 char *ret;
1417 DWORD size = 0;
1418
1419 GetComputerNameExA( format, NULL, &size );
1420 if (GetLastError() != ERROR_MORE_DATA) return NULL;
1421 if (!(ret = malloc( size ))) return NULL;
1422 if (!GetComputerNameExA( format, ret, &size ))
1423 {
1424 free( ret );
1425 return NULL;
1426 }
1427 return ret;
1428 }
1429
1430 static BOOL is_domain_suffix( const char *domain, const char *suffix )
1431 {
1432 int len_domain = strlen( domain ), len_suffix = strlen( suffix );
1433
1434 if (len_suffix > len_domain) return FALSE;
1435 if (!stricmp( domain + len_domain - len_suffix, suffix )) return TRUE;
1436 return FALSE;
1437 }
1438
1439 static int reverse_lookup( const struct addrinfo *ai, char *hostname, size_t len )
1440 {
1441 return getnameinfo( ai->ai_addr, ai->ai_addrlen, hostname, len, NULL, 0, 0 );
1442 }
1443
1444 static WCHAR *build_wpad_url( const char *hostname, const struct addrinfo *ai )
1445 {
1446 char name[NI_MAXHOST];
1447 WCHAR *ret, *p;
1448 int len;
1449
1450 while (ai && ai->ai_family != AF_INET && ai->ai_family != AF_INET6) ai = ai->ai_next;
1451 if (!ai) return NULL;
1452
1453 if (!reverse_lookup( ai, name, sizeof(name) )) hostname = name;
1454
1455 len = lstrlenW( L"http://" ) + strlen( hostname ) + lstrlenW( L"/wpad.dat" );
1456 if (!(ret = p = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) return NULL;
1457 lstrcpyW( p, L"http://" );
1458 p += lstrlenW( L"http://" );
1459 while (*hostname) { *p++ = *hostname++; }
1460 lstrcpyW( p, L"/wpad.dat" );
1461 return ret;
1462 }
1463
1464 static WCHAR *detect_autoproxyconfig_url_dns(void)
1465 {
1466 char *fqdn, *domain, *p;
1467 WCHAR *ret = NULL;
1468
1469 if (!(fqdn = get_computer_name( ComputerNamePhysicalDnsFullyQualified ))) return NULL;
1470 if (!(domain = get_computer_name( ComputerNamePhysicalDnsDomain )))
1471 {
1472 free( fqdn );
1473 return NULL;
1474 }
1475 p = fqdn;
1476 while ((p = strchr( p, '.' )) && is_domain_suffix( p + 1, domain ))
1477 {
1478 char *name;
1479 struct addrinfo *ai, hints;
1480 int res;
1481
1482 if (!(name = malloc( sizeof("wpad") + strlen(p) )))
1483 {
1484 free( fqdn );
1485 free( domain );
1486 return NULL;
1487 }
1488 strcpy( name, "wpad" );
1489 strcat( name, p );
1490 memset( &hints, 0, sizeof(hints) );
1491 hints.ai_flags = AI_ALL | AI_DNS_ONLY;
1492 hints.ai_family = AF_UNSPEC;
1493 res = getaddrinfo( name, NULL, &hints, &ai );
1494 if (!res)
1495 {
1496 ret = build_wpad_url( name, ai );
1497 freeaddrinfo( ai );
1498 if (ret)
1499 {
1500 TRACE("returning %s\n", debugstr_w(ret));
1501 free( name );
1502 break;
1503 }
1504 }
1505 free( name );
1506 p++;
1507 }
1508 free( domain );
1509 free( fqdn );
1510 return ret;
1511 }
1512
1513 /***********************************************************************
1514 * WinHttpDetectAutoProxyConfigUrl (winhttp.@)
1515 */
1516 BOOL WINAPI WinHttpDetectAutoProxyConfigUrl( DWORD flags, WCHAR **url )
1517 {
1518 TRACE( "%#lx, %p\n", flags, url );
1519
1520 if (!flags || !url)
1521 {
1522 SetLastError( ERROR_INVALID_PARAMETER );
1523 return FALSE;
1524 }
1525 *url = NULL;
1526 if (flags & WINHTTP_AUTO_DETECT_TYPE_DHCP)
1527 {
1528 *url = detect_autoproxyconfig_url_dhcp();
1529 }
1530 if (flags & WINHTTP_AUTO_DETECT_TYPE_DNS_A)
1531 {
1532 if (!*url) *url = detect_autoproxyconfig_url_dns();
1533 }
1534 if (!*url)
1535 {
1536 SetLastError( ERROR_WINHTTP_AUTODETECTION_FAILED );
1537 return FALSE;
1538 }
1539 SetLastError( ERROR_SUCCESS );
1540 return TRUE;
1541 }
1542
1543 static const WCHAR path_connections[] =
1544 L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Connections";
1545
1546 static const DWORD WINHTTP_SETTINGS_MAGIC = 0x18;
1547 static const DWORD WININET_SETTINGS_MAGIC = 0x46;
1548 static const DWORD PROXY_TYPE_DIRECT = 1;
1549 static const DWORD PROXY_TYPE_PROXY = 2;
1550 static const DWORD PROXY_USE_PAC_SCRIPT = 4;
1551 static const DWORD PROXY_AUTODETECT_SETTINGS = 8;
1552
1553 struct connection_settings_header
1554 {
1555 DWORD magic;
1556 DWORD unknown; /* always zero? */
1557 DWORD flags; /* one or more of PROXY_* */
1558 };
1559
1560 static inline void copy_char_to_wchar_sz(const BYTE *src, DWORD len, WCHAR *dst)
1561 {
1562 const BYTE *begin;
1563
1564 for (begin = src; src - begin < len; src++, dst++)
1565 *dst = *src;
1566 *dst = 0;
1567 }
1568
1569 /***********************************************************************
1570 * WinHttpGetDefaultProxyConfiguration (winhttp.@)
1571 */
1572 BOOL WINAPI WinHttpGetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
1573 {
1574 LONG l;
1575 HKEY key;
1576 BOOL got_from_reg = FALSE, direct = TRUE;
1577 WCHAR *envproxy;
1578
1579 TRACE("%p\n", info);
1580
1581 l = RegOpenKeyExW( HKEY_LOCAL_MACHINE, path_connections, 0, KEY_READ, &key );
1582 if (!l)
1583 {
1584 DWORD type, size = 0;
1585
1586 l = RegQueryValueExW( key, L"WinHttpSettings", NULL, &type, NULL, &size );
1587 if (!l && type == REG_BINARY &&
1588 size >= sizeof(struct connection_settings_header) + 2 * sizeof(DWORD))
1589 {
1590 BYTE *buf = malloc( size );
1591
1592 if (buf)
1593 {
1594 struct connection_settings_header *hdr =
1595 (struct connection_settings_header *)buf;
1596 DWORD *len = (DWORD *)(hdr + 1);
1597
1598 l = RegQueryValueExW( key, L"WinHttpSettings", NULL, NULL, buf,
1599 &size );
1600 if (!l && hdr->magic == WINHTTP_SETTINGS_MAGIC &&
1601 hdr->unknown == 0)
1602 {
1603 if (hdr->flags & PROXY_TYPE_PROXY)
1604 {
1605 BOOL sane = FALSE;
1606 LPWSTR proxy = NULL;
1607 LPWSTR proxy_bypass = NULL;
1608
1609 /* Sanity-check length of proxy string */
1610 if ((BYTE *)len - buf + *len <= size)
1611 {
1612 sane = TRUE;
1613 proxy = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
1614 if (proxy)
1615 copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy );
1616 len = (DWORD *)((BYTE *)(len + 1) + *len);
1617 }
1618 if (sane)
1619 {
1620 /* Sanity-check length of proxy bypass string */
1621 if ((BYTE *)len - buf + *len <= size)
1622 {
1623 proxy_bypass = GlobalAlloc( 0, (*len + 1) * sizeof(WCHAR) );
1624 if (proxy_bypass)
1625 copy_char_to_wchar_sz( (BYTE *)(len + 1), *len, proxy_bypass );
1626 }
1627 else
1628 {
1629 sane = FALSE;
1630 GlobalFree( proxy );
1631 proxy = NULL;
1632 }
1633 }
1634 info->lpszProxy = proxy;
1635 info->lpszProxyBypass = proxy_bypass;
1636 if (sane)
1637 {
1638 got_from_reg = TRUE;
1639 direct = FALSE;
1640 info->dwAccessType =
1641 WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1642 TRACE("http proxy (from registry) = %s, bypass = %s\n",
1643 debugstr_w(info->lpszProxy),
1644 debugstr_w(info->lpszProxyBypass));
1645 }
1646 }
1647 }
1648 free( buf );
1649 }
1650 }
1651 RegCloseKey( key );
1652 }
1653 if (!got_from_reg && (envproxy = _wgetenv( L"http_proxy" )))
1654 {
1655 WCHAR *colon, *http_proxy = NULL;
1656
1657 if (!(colon = wcschr( envproxy, ':' ))) http_proxy = envproxy;
1658 else
1659 {
1660 if (*(colon + 1) == '/' && *(colon + 2) == '/')
1661 {
1662 /* It's a scheme, check that it's http */
1663 if (!wcsncmp( envproxy, L"http://", 7 )) http_proxy = envproxy + 7;
1664 else WARN("unsupported scheme in $http_proxy: %s\n", debugstr_w(envproxy));
1665 }
1666 else http_proxy = envproxy;
1667 }
1668
1669 if (http_proxy && http_proxy[0])
1670 {
1671 direct = FALSE;
1672 info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1673 info->lpszProxy = GlobalAlloc( 0, (lstrlenW(http_proxy) + 1) * sizeof(WCHAR) );
1674 wcscpy( info->lpszProxy, http_proxy );
1675 info->lpszProxyBypass = NULL;
1676 TRACE("http proxy (from environment) = %s\n", debugstr_w(info->lpszProxy));
1677 }
1678 }
1679 if (direct)
1680 {
1681 info->dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
1682 info->lpszProxy = NULL;
1683 info->lpszProxyBypass = NULL;
1684 }
1685 SetLastError( ERROR_SUCCESS );
1686 return TRUE;
1687 }
1688
1689 /***********************************************************************
1690 * WinHttpGetIEProxyConfigForCurrentUser (winhttp.@)
1691 */
1692 BOOL WINAPI WinHttpGetIEProxyConfigForCurrentUser( WINHTTP_CURRENT_USER_IE_PROXY_CONFIG *config )
1693 {
1694 HKEY hkey = NULL;
1695 struct connection_settings_header *hdr = NULL;
1696 DWORD type, offset, len, size = 0;
1697 BOOL ret = FALSE;
1698
1699 TRACE("%p\n", config);
1700
1701 if (!config)
1702 {
1703 SetLastError( ERROR_INVALID_PARAMETER );
1704 return FALSE;
1705 }
1706 memset( config, 0, sizeof(*config) );
1707 config->fAutoDetect = TRUE;
1708
1709 if (RegOpenKeyExW( HKEY_CURRENT_USER, path_connections, 0, KEY_READ, &hkey ) ||
1710 RegQueryValueExW( hkey, L"DefaultConnectionSettings", NULL, &type, NULL, &size ) ||
1711 type != REG_BINARY || size < sizeof(struct connection_settings_header))
1712 {
1713 ret = TRUE;
1714 goto done;
1715 }
1716 if (!(hdr = malloc( size ))) goto done;
1717 if (RegQueryValueExW( hkey, L"DefaultConnectionSettings", NULL, &type, (BYTE *)hdr, &size ) ||
1718 hdr->magic != WININET_SETTINGS_MAGIC)
1719 {
1720 ret = TRUE;
1721 goto done;
1722 }
1723
1724 config->fAutoDetect = (hdr->flags & PROXY_AUTODETECT_SETTINGS) != 0;
1725 offset = sizeof(*hdr);
1726 if (offset + sizeof(DWORD) > size) goto done;
1727 len = *(DWORD *)((char *)hdr + offset);
1728 offset += sizeof(DWORD);
1729 if (len && hdr->flags & PROXY_TYPE_PROXY)
1730 {
1731 if (!(config->lpszProxy = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
1732 copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszProxy );
1733 }
1734 offset += len;
1735 if (offset + sizeof(DWORD) > size) goto done;
1736 len = *(DWORD *)((char *)hdr + offset);
1737 offset += sizeof(DWORD);
1738 if (len && (hdr->flags & PROXY_TYPE_PROXY))
1739 {
1740 if (!(config->lpszProxyBypass = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
1741 copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszProxyBypass );
1742 }
1743 offset += len;
1744 if (offset + sizeof(DWORD) > size) goto done;
1745 len = *(DWORD *)((char *)hdr + offset);
1746 offset += sizeof(DWORD);
1747 if (len && (hdr->flags & PROXY_USE_PAC_SCRIPT))
1748 {
1749 if (!(config->lpszAutoConfigUrl = GlobalAlloc( 0, (len + 1) * sizeof(WCHAR) ))) goto done;
1750 copy_char_to_wchar_sz( (const BYTE *)hdr + offset , len, config->lpszAutoConfigUrl );
1751 }
1752 ret = TRUE;
1753
1754 done:
1755 RegCloseKey( hkey );
1756 free( hdr );
1757 if (!ret)
1758 {
1759 GlobalFree( config->lpszAutoConfigUrl );
1760 config->lpszAutoConfigUrl = NULL;
1761 GlobalFree( config->lpszProxy );
1762 config->lpszProxy = NULL;
1763 GlobalFree( config->lpszProxyBypass );
1764 config->lpszProxyBypass = NULL;
1765 }
1766 else SetLastError( ERROR_SUCCESS );
1767 return ret;
1768 }
1769
1770 static BOOL parse_script_result( const char *result, WINHTTP_PROXY_INFO *info )
1771 {
1772 const char *p;
1773 WCHAR *q;
1774 int len;
1775
1776 info->dwAccessType = WINHTTP_ACCESS_TYPE_NO_PROXY;
1777 info->lpszProxy = NULL;
1778 info->lpszProxyBypass = NULL;
1779
1780 TRACE("%s\n", debugstr_a( result ));
1781
1782 p = result;
1783 while (*p == ' ') p++;
1784 len = strlen( p );
1785 if (len >= 5 && !_strnicmp( p, "PROXY", sizeof("PROXY") - 1 ))
1786 {
1787 p += 5;
1788 while (*p == ' ') p++;
1789 if (!*p || *p == ';') return TRUE;
1790 if (!(info->lpszProxy = q = strdupAW( p ))) return FALSE;
1791 info->dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
1792 for (; *q; q++)
1793 {
1794 if (*q == ' ' || *q == ';')
1795 {
1796 *q = 0;
1797 break;
1798 }
1799 }
1800 }
1801 return TRUE;
1802 }
1803
1804 static char *download_script( const WCHAR *url, DWORD *out_size )
1805 {
1806 static const WCHAR *acceptW[] = {L"*/*", NULL};
1807 HINTERNET ses, con = NULL, req = NULL;
1808 WCHAR *hostname;
1809 URL_COMPONENTSW uc;
1810 DWORD status, size = sizeof(status), offset, to_read, bytes_read, flags = 0;
1811 char *tmp, *buffer = NULL;
1812
1813 *out_size = 0;
1814
1815 memset( &uc, 0, sizeof(uc) );
1816 uc.dwStructSize = sizeof(uc);
1817 uc.dwHostNameLength = -1;
1818 uc.dwUrlPathLength = -1;
1819 if (!WinHttpCrackUrl( url, 0, 0, &uc )) return NULL;
1820 if (!(hostname = malloc( (uc.dwHostNameLength + 1) * sizeof(WCHAR) ))) return NULL;
1821 memcpy( hostname, uc.lpszHostName, uc.dwHostNameLength * sizeof(WCHAR) );
1822 hostname[uc.dwHostNameLength] = 0;
1823
1824 if (!(ses = WinHttpOpen( NULL, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0 ))) goto done;
1825 if (!(con = WinHttpConnect( ses, hostname, uc.nPort, 0 ))) goto done;
1826 if (uc.nScheme == INTERNET_SCHEME_HTTPS) flags |= WINHTTP_FLAG_SECURE;
1827 if (!(req = WinHttpOpenRequest( con, NULL, uc.lpszUrlPath, NULL, NULL, acceptW, flags ))) goto done;
1828 if (!WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 )) goto done;
1829
1830 if (!WinHttpReceiveResponse( req, 0 )) goto done;
1831 if (!WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER, NULL, &status,
1832 &size, NULL ) || status != HTTP_STATUS_OK) goto done;
1833
1834 size = 4096;
1835 if (!(buffer = malloc( size ))) goto done;
1836 to_read = size;
1837 offset = 0;
1838 for (;;)
1839 {
1840 if (!WinHttpReadData( req, buffer + offset, to_read, &bytes_read )) goto done;
1841 if (!bytes_read) break;
1842 to_read -= bytes_read;
1843 offset += bytes_read;
1844 *out_size += bytes_read;
1845 if (!to_read)
1846 {
1847 to_read = size;
1848 size *= 2;
1849 if (!(tmp = realloc( buffer, size ))) goto done;
1850 buffer = tmp;
1851 }
1852 }
1853
1854 done:
1855 WinHttpCloseHandle( req );
1856 WinHttpCloseHandle( con );
1857 WinHttpCloseHandle( ses );
1858 free( hostname );
1859 if (!buffer) SetLastError( ERROR_WINHTTP_UNABLE_TO_DOWNLOAD_SCRIPT );
1860 return buffer;
1861 }
1862
1863 struct AUTO_PROXY_SCRIPT_BUFFER
1864 {
1865 DWORD dwStructSize;
1866 LPSTR lpszScriptBuffer;
1867 DWORD dwScriptBufferSize;
1868 };
1869
1870 BOOL WINAPI InternetDeInitializeAutoProxyDll(LPSTR, DWORD);
1871 BOOL WINAPI InternetGetProxyInfo(LPCSTR, DWORD, LPSTR, DWORD, LPSTR *, LPDWORD);
1872 BOOL WINAPI InternetInitializeAutoProxyDll(DWORD, LPSTR, LPSTR, void *, struct AUTO_PROXY_SCRIPT_BUFFER *);
1873
1874 static BOOL run_script( char *script, DWORD size, const WCHAR *url, WINHTTP_PROXY_INFO *info )
1875 {
1876 BOOL ret;
1877 char *result, *urlA;
1878 DWORD len_result;
1879 struct AUTO_PROXY_SCRIPT_BUFFER buffer;
1880 URL_COMPONENTSW uc;
1881
1882 buffer.dwStructSize = sizeof(buffer);
1883 buffer.lpszScriptBuffer = script;
1884 buffer.dwScriptBufferSize = size;
1885
1886 if (!(urlA = strdupWA( url ))) return FALSE;
1887 if (!(ret = InternetInitializeAutoProxyDll( 0, NULL, NULL, NULL, &buffer )))
1888 {
1889 free( urlA );
1890 return FALSE;
1891 }
1892
1893 memset( &uc, 0, sizeof(uc) );
1894 uc.dwStructSize = sizeof(uc);
1895 uc.dwHostNameLength = -1;
1896
1897 if ((ret = WinHttpCrackUrl( url, 0, 0, &uc )))
1898 {
1899 char *hostnameA = strdupWA_sized( uc.lpszHostName, uc.dwHostNameLength );
1900
1901 if ((ret = InternetGetProxyInfo( urlA, strlen(urlA),
1902 hostnameA, strlen(hostnameA), &result, &len_result )))
1903 {
1904 ret = parse_script_result( result, info );
1905 free( result );
1906 }
1907
1908 free( hostnameA );
1909 }
1910 free( urlA );
1911 InternetDeInitializeAutoProxyDll( NULL, 0 );
1912 return ret;
1913 }
1914
1915 /***********************************************************************
1916 * WinHttpGetProxyForUrl (winhttp.@)
1917 */
1918 BOOL WINAPI WinHttpGetProxyForUrl( HINTERNET hsession, LPCWSTR url, WINHTTP_AUTOPROXY_OPTIONS *options,
1919 WINHTTP_PROXY_INFO *info )
1920 {
1921 WCHAR *detected_pac_url = NULL;
1922 const WCHAR *pac_url;
1923 struct session *session;
1924 char *script;
1925 DWORD size;
1926 BOOL ret = FALSE;
1927
1928 TRACE("%p, %s, %p, %p\n", hsession, debugstr_w(url), options, info);
1929
1930 if (!(session = (struct session *)grab_object( hsession )))
1931 {
1932 SetLastError( ERROR_INVALID_HANDLE );
1933 return FALSE;
1934 }
1935 if (session->hdr.type != WINHTTP_HANDLE_TYPE_SESSION)
1936 {
1937 release_object( &session->hdr );
1938 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
1939 return FALSE;
1940 }
1941 if (!url || !options || !info ||
1942 !(options->dwFlags & (WINHTTP_AUTOPROXY_AUTO_DETECT|WINHTTP_AUTOPROXY_CONFIG_URL)) ||
1943 ((options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT) && !options->dwAutoDetectFlags) ||
1944 ((options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT) &&
1945 (options->dwFlags & WINHTTP_AUTOPROXY_CONFIG_URL)))
1946 {
1947 release_object( &session->hdr );
1948 SetLastError( ERROR_INVALID_PARAMETER );
1949 return FALSE;
1950 }
1951 if (options->dwFlags & WINHTTP_AUTOPROXY_AUTO_DETECT &&
1952 !WinHttpDetectAutoProxyConfigUrl( options->dwAutoDetectFlags, &detected_pac_url ))
1953 goto done;
1954
1955 if (options->dwFlags & WINHTTP_AUTOPROXY_CONFIG_URL) pac_url = options->lpszAutoConfigUrl;
1956 else pac_url = detected_pac_url;
1957
1958 if ((script = download_script( pac_url, &size )))
1959 {
1960 ret = run_script( script, size, url, info );
1961 free( script );
1962 }
1963
1964 done:
1965 GlobalFree( detected_pac_url );
1966 release_object( &session->hdr );
1967 if (ret) SetLastError( ERROR_SUCCESS );
1968 return ret;
1969 }
1970
1971 /***********************************************************************
1972 * WinHttpSetDefaultProxyConfiguration (winhttp.@)
1973 */
1974 BOOL WINAPI WinHttpSetDefaultProxyConfiguration( WINHTTP_PROXY_INFO *info )
1975 {
1976 LONG l;
1977 HKEY key;
1978 BOOL ret = FALSE;
1979 const WCHAR *src;
1980
1981 TRACE("%p\n", info);
1982
1983 if (!info)
1984 {
1985 SetLastError( ERROR_INVALID_PARAMETER );
1986 return FALSE;
1987 }
1988 switch (info->dwAccessType)
1989 {
1990 case WINHTTP_ACCESS_TYPE_NO_PROXY:
1991 break;
1992 case WINHTTP_ACCESS_TYPE_NAMED_PROXY:
1993 if (!info->lpszProxy)
1994 {
1995 SetLastError( ERROR_INVALID_PARAMETER );
1996 return FALSE;
1997 }
1998 /* Only ASCII characters are allowed */
1999 for (src = info->lpszProxy; *src; src++)
2000 if (*src > 0x7f)
2001 {
2002 SetLastError( ERROR_INVALID_PARAMETER );
2003 return FALSE;
2004 }
2005 if (info->lpszProxyBypass)
2006 {
2007 for (src = info->lpszProxyBypass; *src; src++)
2008 if (*src > 0x7f)
2009 {
2010 SetLastError( ERROR_INVALID_PARAMETER );
2011 return FALSE;
2012 }
2013 }
2014 break;
2015 default:
2016 SetLastError( ERROR_INVALID_PARAMETER );
2017 return FALSE;
2018 }
2019
2020 l = RegCreateKeyExW( HKEY_LOCAL_MACHINE, path_connections, 0, NULL, 0,
2021 KEY_WRITE, NULL, &key, NULL );
2022 if (!l)
2023 {
2024 DWORD size = sizeof(struct connection_settings_header) + 2 * sizeof(DWORD);
2025 BYTE *buf;
2026
2027 if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
2028 {
2029 size += lstrlenW( info->lpszProxy );
2030 if (info->lpszProxyBypass)
2031 size += lstrlenW( info->lpszProxyBypass );
2032 }
2033 if ((buf = malloc( size )))
2034 {
2035 struct connection_settings_header *hdr =
2036 (struct connection_settings_header *)buf;
2037 DWORD *len = (DWORD *)(hdr + 1);
2038
2039 hdr->magic = WINHTTP_SETTINGS_MAGIC;
2040 hdr->unknown = 0;
2041 if (info->dwAccessType == WINHTTP_ACCESS_TYPE_NAMED_PROXY)
2042 {
2043 BYTE *dst;
2044
2045 hdr->flags = PROXY_TYPE_PROXY;
2046 *len++ = lstrlenW( info->lpszProxy );
2047 for (dst = (BYTE *)len, src = info->lpszProxy; *src;
2048 src++, dst++)
2049 *dst = *src;
2050 len = (DWORD *)dst;
2051 if (info->lpszProxyBypass)
2052 {
2053 *len++ = lstrlenW( info->lpszProxyBypass );
2054 for (dst = (BYTE *)len, src = info->lpszProxyBypass; *src;
2055 src++, dst++)
2056 *dst = *src;
2057 }
2058 else
2059 *len++ = 0;
2060 }
2061 else
2062 {
2063 hdr->flags = PROXY_TYPE_DIRECT;
2064 *len++ = 0;
2065 *len++ = 0;
2066 }
2067 l = RegSetValueExW( key, L"WinHttpSettings", 0, REG_BINARY, buf, size );
2068 if (!l)
2069 ret = TRUE;
2070 free( buf );
2071 }
2072 RegCloseKey( key );
2073 }
2074 if (ret) SetLastError( ERROR_SUCCESS );
2075 return ret;
2076 }
2077
2078 /***********************************************************************
2079 * WinHttpCreateProxyResolver (winhttp.@)
2080 */
2081 DWORD WINAPI WinHttpCreateProxyResolver( HINTERNET hsession, HINTERNET *hresolver )
2082 {
2083 FIXME("%p, %p\n", hsession, hresolver);
2084 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2085 }
2086
2087 /***********************************************************************
2088 * WinHttpFreeProxyResult (winhttp.@)
2089 */
2090 void WINAPI WinHttpFreeProxyResult( WINHTTP_PROXY_RESULT *result )
2091 {
2092 FIXME("%p\n", result);
2093 }
2094
2095 /***********************************************************************
2096 * WinHttpFreeProxyResultEx (winhttp.@)
2097 */
2098 void WINAPI WinHttpFreeProxyResultEx( WINHTTP_PROXY_RESULT_EX *result )
2099 {
2100 FIXME("%p\n", result);
2101 }
2102
2103 /***********************************************************************
2104 * WinHttpFreeProxySettings (winhttp.@)
2105 */
2106 void WINAPI WinHttpFreeProxySettings( WINHTTP_PROXY_SETTINGS *settings )
2107 {
2108 FIXME("%p\n", settings);
2109 }
2110
2111 /***********************************************************************
2112 * WinHttpGetProxyForUrlEx (winhttp.@)
2113 */
2114 DWORD WINAPI WinHttpGetProxyForUrlEx( HINTERNET hresolver, const WCHAR *url, WINHTTP_AUTOPROXY_OPTIONS *options,
2115 DWORD_PTR ctx )
2116 {
2117 FIXME( "%p, %s, %p, %Ix\n", hresolver, debugstr_w(url), options, ctx );
2118 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2119 }
2120
2121 /***********************************************************************
2122 * WinHttpGetProxyForUrlEx2 (winhttp.@)
2123 */
2124 DWORD WINAPI WinHttpGetProxyForUrlEx2( HINTERNET hresolver, const WCHAR *url, WINHTTP_AUTOPROXY_OPTIONS *options,
2125 DWORD selection_len, BYTE *selection, DWORD_PTR ctx )
2126 {
2127 FIXME( "%p, %s, %p, %lu, %p, %Ix\n", hresolver, debugstr_w(url), options, selection_len, selection, ctx );
2128 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2129 }
2130
2131 /***********************************************************************
2132 * WinHttpGetProxyResult (winhttp.@)
2133 */
2134 DWORD WINAPI WinHttpGetProxyResult( HINTERNET hresolver, WINHTTP_PROXY_RESULT *result )
2135 {
2136 FIXME("%p, %p\n", hresolver, result);
2137 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2138 }
2139
2140 /***********************************************************************
2141 * WinHttpGetProxyResultEx (winhttp.@)
2142 */
2143 DWORD WINAPI WinHttpGetProxyResultEx( HINTERNET hresolver, WINHTTP_PROXY_RESULT_EX *result )
2144 {
2145 FIXME("%p, %p\n", hresolver, result);
2146 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2147 }
2148
2149 /***********************************************************************
2150 * WinHttpGetProxySettingsVersion (winhttp.@)
2151 */
2152 DWORD WINAPI WinHttpGetProxySettingsVersion( HINTERNET hsession, DWORD *version )
2153 {
2154 FIXME("%p, %p\n", hsession, version);
2155 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2156 }
2157
2158 /***********************************************************************
2159 * WinHttpReadProxySettings (winhttp.@)
2160 */
2161 DWORD WINAPI WinHttpReadProxySettings( HINTERNET hsession, const WCHAR *connection, BOOL use_defaults,
2162 BOOL set_autodiscover, DWORD *version, BOOL *defaults_returned,
2163 WINHTTP_PROXY_SETTINGS *settings)
2164 {
2165 FIXME("%p, %s, %d, %d, %p, %p, %p\n", hsession, debugstr_w(connection), use_defaults, set_autodiscover,
2166 version, defaults_returned, settings);
2167 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2168 }
2169
2170 /***********************************************************************
2171 * WinHttpResetAutoProxy (winhttp.@)
2172 */
2173 DWORD WINAPI WinHttpResetAutoProxy( HINTERNET hsession, DWORD flags )
2174 {
2175 FIXME( "%p, %#lx\n", hsession, flags );
2176 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2177 }
2178
2179 DWORD WINAPI WinHttpWriteProxySettings( HINTERNET hsession, BOOL force, WINHTTP_PROXY_SETTINGS *settings )
2180 {
2181 FIXME("%p, %d, %p\n", hsession, force, settings);
2182 return ERROR_WINHTTP_AUTO_PROXY_SERVICE_ERROR;
2183 }
2184
2185 /***********************************************************************
2186 * WinHttpSetStatusCallback (winhttp.@)
2187 */
2188 WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback( HINTERNET handle, WINHTTP_STATUS_CALLBACK callback,
2189 DWORD flags, DWORD_PTR reserved )
2190 {
2191 struct object_header *hdr;
2192 WINHTTP_STATUS_CALLBACK ret;
2193
2194 TRACE( "%p, %p, %#lx, %Ix\n", handle, callback, flags, reserved );
2195
2196 if (!(hdr = grab_object( handle )))
2197 {
2198 SetLastError( ERROR_INVALID_HANDLE );
2199 return WINHTTP_INVALID_STATUS_CALLBACK;
2200 }
2201 ret = hdr->callback;
2202 hdr->callback = callback;
2203 hdr->notify_mask = flags;
2204
2205 release_object( hdr );
2206 SetLastError( ERROR_SUCCESS );
2207 return ret;
2208 }
2209
2210 /***********************************************************************
2211 * WinHttpSetTimeouts (winhttp.@)
2212 */
2213 BOOL WINAPI WinHttpSetTimeouts( HINTERNET handle, int resolve, int connect, int send, int receive )
2214 {
2215 BOOL ret = TRUE;
2216 struct object_header *hdr;
2217
2218 TRACE("%p, %d, %d, %d, %d\n", handle, resolve, connect, send, receive);
2219
2220 if (resolve < -1 || connect < -1 || send < -1 || receive < -1)
2221 {
2222 SetLastError( ERROR_INVALID_PARAMETER );
2223 return FALSE;
2224 }
2225
2226 if (!(hdr = grab_object( handle )))
2227 {
2228 SetLastError( ERROR_INVALID_HANDLE );
2229 return FALSE;
2230 }
2231
2232 switch(hdr->type)
2233 {
2234 case WINHTTP_HANDLE_TYPE_REQUEST:
2235 {
2236 struct request *request = (struct request *)hdr;
2237 request->connect_timeout = connect;
2238
2239 if (resolve < 0) resolve = 0;
2240 request->resolve_timeout = resolve;
2241
2242 if (send < 0) send = 0;
2243 request->send_timeout = send;
2244
2245 if (receive < 0) receive = 0;
2246 request->receive_timeout = receive;
2247
2248 if (request->netconn)
2249 {
2250 if (netconn_set_timeout( request->netconn, TRUE, send )) ret = FALSE;
2251 if (netconn_set_timeout( request->netconn, FALSE, receive )) ret = FALSE;
2252 }
2253 break;
2254 }
2255 case WINHTTP_HANDLE_TYPE_SESSION:
2256 {
2257 struct session *session = (struct session *)hdr;
2258 session->connect_timeout = connect;
2259
2260 if (resolve < 0) resolve = 0;
2261 session->resolve_timeout = resolve;
2262
2263 if (send < 0) send = 0;
2264 session->send_timeout = send;
2265
2266 if (receive < 0) receive = 0;
2267 session->receive_timeout = receive;
2268 break;
2269 }
2270 default:
2271 SetLastError( ERROR_WINHTTP_INCORRECT_HANDLE_TYPE );
2272 ret = FALSE;
2273 }
2274 release_object( hdr );
2275 if (ret) SetLastError( ERROR_SUCCESS );
2276 return ret;
2277 }
2278
2279 static const WCHAR wkday[7][4] =
2280 {L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat"};
2281 static const WCHAR month[12][4] =
2282 {L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun", L"Jul", L"Aug", L"Sep", L"Oct", L"Nov", L"Dec"};
2283
2284 /***********************************************************************
2285 * WinHttpTimeFromSystemTime (WININET.@)
2286 */
2287 BOOL WINAPI WinHttpTimeFromSystemTime( const SYSTEMTIME *time, LPWSTR string )
2288 {
2289 TRACE("%p, %p\n", time, string);
2290
2291 if (!time || !string)
2292 {
2293 SetLastError( ERROR_INVALID_PARAMETER );
2294 return FALSE;
2295 }
2296
2297 swprintf( string, WINHTTP_TIME_FORMAT_BUFSIZE / sizeof(WCHAR),
2298 L"%s, %02d %s %4d %02d:%02d:%02d GMT",
2299 wkday[time->wDayOfWeek],
2300 time->wDay,
2301 month[time->wMonth - 1],
2302 time->wYear,
2303 time->wHour,
2304 time->wMinute,
2305 time->wSecond );
2306
2307 SetLastError( ERROR_SUCCESS );
2308 return TRUE;
2309 }
2310
2311 /***********************************************************************
2312 * WinHttpTimeToSystemTime (WININET.@)
2313 */
2314 BOOL WINAPI WinHttpTimeToSystemTime( LPCWSTR string, SYSTEMTIME *time )
2315 {
2316 unsigned int i;
2317 const WCHAR *s = string;
2318 WCHAR *end;
2319
2320 TRACE("%s, %p\n", debugstr_w(string), time);
2321
2322 if (!string || !time)
2323 {
2324 SetLastError( ERROR_INVALID_PARAMETER );
2325 return FALSE;
2326 }
2327
2328 /* Windows does this too */
2329 GetSystemTime( time );
2330
2331 /* Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
2332 * a SYSTEMTIME structure.
2333 */
2334
2335 SetLastError( ERROR_SUCCESS );
2336
2337 while (*s && !iswalpha( *s )) s++;
2338 if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2339 time->wDayOfWeek = 7;
2340
2341 for (i = 0; i < 7; i++)
2342 {
2343 if (towupper( wkday[i][0] ) == towupper( s[0] ) &&
2344 towupper( wkday[i][1] ) == towupper( s[1] ) &&
2345 towupper( wkday[i][2] ) == towupper( s[2] ) )
2346 {
2347 time->wDayOfWeek = i;
2348 break;
2349 }
2350 }
2351
2352 if (time->wDayOfWeek > 6) return TRUE;
2353 while (*s && !iswdigit( *s )) s++;
2354 time->wDay = wcstol( s, &end, 10 );
2355 s = end;
2356
2357 while (*s && !iswalpha( *s )) s++;
2358 if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
2359 time->wMonth = 0;
2360
2361 for (i = 0; i < 12; i++)
2362 {
2363 if (towupper( month[i][0]) == towupper( s[0] ) &&
2364 towupper( month[i][1]) == towupper( s[1] ) &&
2365 towupper( month[i][2]) == towupper( s[2] ) )
2366 {
2367 time->wMonth = i + 1;
2368 break;
2369 }
2370 }
2371 if (time->wMonth == 0) return TRUE;
2372
2373 while (*s && !iswdigit( *s )) s++;
2374 if (*s == '\0') return TRUE;
2375 time->wYear = wcstol( s, &end, 10 );
2376 s = end;
2377
2378 while (*s && !iswdigit( *s )) s++;
2379 if (*s == '\0') return TRUE;
2380 time->wHour = wcstol( s, &end, 10 );
2381 s = end;
2382
2383 while (*s && !iswdigit( *s )) s++;
2384 if (*s == '\0') return TRUE;
2385 time->wMinute = wcstol( s, &end, 10 );
2386 s = end;
2387
2388 while (*s && !iswdigit( *s )) s++;
2389 if (*s == '\0') return TRUE;
2390 time->wSecond = wcstol( s, &end, 10 );
2391
2392 time->wMilliseconds = 0;
2393 return TRUE;
2394 }
Windows API implementation