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