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