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