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