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