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