projects / reactos.git / blob
? search:


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