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