?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wininet: Copy and pass along proxyBypass in INTERNET_ConfigureProxy.
[wine.git] / dlls / wininet / internet.c
blob12e4096369f6f671b464527503079878fcca9388
1 /*
2 * Wininet
3 *
4 * Copyright 1999 Corel Corporation
5 * Copyright 2002 CodeWeavers Inc.
6 * Copyright 2002 Jaco Greeff
7 * Copyright 2002 TransGaming Technologies Inc.
8 * Copyright 2004 Mike McCormack for CodeWeavers
9 *
10 * Ulrich Czekalla
11 * Aric Stewart
12 * David Hammerton
13 *
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
18 *
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
23 *
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 */
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #if defined(__MINGW32__) || defined (_MSC_VER)
33 #include <ws2tcpip.h>
34 #endif
35
36 #include <string.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <sys/types.h>
40 #ifdef HAVE_SYS_SOCKET_H
41 # include <sys/socket.h>
42 #endif
43 #ifdef HAVE_POLL_H
44 #include <poll.h>
45 #endif
46 #ifdef HAVE_SYS_POLL_H
47 # include <sys/poll.h>
48 #endif
49 #ifdef HAVE_SYS_TIME_H
50 # include <sys/time.h>
51 #endif
52 #include <stdlib.h>
53 #include <ctype.h>
54 #ifdef HAVE_UNISTD_H
55 # include <unistd.h>
56 #endif
57 #include <assert.h>
58
59 #include "windef.h"
60 #include "winbase.h"
61 #include "winreg.h"
62 #include "winuser.h"
63 #include "wininet.h"
64 #include "winnls.h"
65 #include "wine/debug.h"
66 #include "winerror.h"
67 #define NO_SHLWAPI_STREAM
68 #include "shlwapi.h"
69
70 #include "wine/exception.h"
71
72 #include "internet.h"
73 #include "resource.h"
74
75 #include "wine/unicode.h"
76
77 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
78
79 #define RESPONSE_TIMEOUT 30
80
81 typedef struct
82 {
83 DWORD dwError;
84 CHAR response[MAX_REPLY_LEN];
85 } WITHREADERROR, *LPWITHREADERROR;
86
87 static DWORD g_dwTlsErrIndex = TLS_OUT_OF_INDEXES;
88 HMODULE WININET_hModule;
89
90 static CRITICAL_SECTION WININET_cs;
91 static CRITICAL_SECTION_DEBUG WININET_cs_debug =
92 {
93 0, 0, &WININET_cs,
94 { &WININET_cs_debug.ProcessLocksList, &WININET_cs_debug.ProcessLocksList },
95 0, 0, { (DWORD_PTR)(__FILE__ ": WININET_cs") }
96 };
97 static CRITICAL_SECTION WININET_cs = { &WININET_cs_debug, -1, 0, 0, 0, 0 };
98
99 static object_header_t **handle_table;
100 static UINT_PTR next_handle;
101 static UINT_PTR handle_table_size;
102
103 typedef struct
104 {
105 DWORD proxyEnabled;
106 LPWSTR proxy;
107 LPWSTR proxyBypass;
108 } proxyinfo_t;
109
110 static ULONG max_conns = 2, max_1_0_conns = 4;
111 static ULONG connect_timeout = 60000;
112
113 static const WCHAR szInternetSettings[] =
114 { 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
115 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
116 'I','n','t','e','r','n','e','t',' ','S','e','t','t','i','n','g','s',0 };
117 static const WCHAR szProxyServer[] = { 'P','r','o','x','y','S','e','r','v','e','r', 0 };
118 static const WCHAR szProxyEnable[] = { 'P','r','o','x','y','E','n','a','b','l','e', 0 };
119 static const WCHAR szProxyOverride[] = { 'P','r','o','x','y','O','v','e','r','r','i','d','e', 0 };
120
121 void *alloc_object(object_header_t *parent, const object_vtbl_t *vtbl, size_t size)
122 {
123 UINT_PTR handle = 0, num;
124 object_header_t *ret;
125 object_header_t **p;
126 BOOL res = TRUE;
127
128 ret = heap_alloc_zero(size);
129 if(!ret)
130 return NULL;
131
132 list_init(&ret->children);
133
134 EnterCriticalSection( &WININET_cs );
135
136 if(!handle_table_size) {
137 num = 16;
138 p = heap_alloc_zero(sizeof(handle_table[0]) * num);
139 if(p) {
140 handle_table = p;
141 handle_table_size = num;
142 next_handle = 1;
143 }else {
144 res = FALSE;
145 }
146 }else if(next_handle == handle_table_size) {
147 num = handle_table_size * 2;
148 p = heap_realloc_zero(handle_table, sizeof(handle_table[0]) * num);
149 if(p) {
150 handle_table = p;
151 handle_table_size = num;
152 }else {
153 res = FALSE;
154 }
155 }
156
157 if(res) {
158 handle = next_handle;
159 if(handle_table[handle])
160 ERR("handle isn't free but should be\n");
161 handle_table[handle] = ret;
162 ret->valid_handle = TRUE;
163
164 while(handle_table[next_handle] && next_handle < handle_table_size)
165 next_handle++;
166 }
167
168 LeaveCriticalSection( &WININET_cs );
169
170 if(!res) {
171 heap_free(ret);
172 return NULL;
173 }
174
175 ret->vtbl = vtbl;
176 ret->refs = 1;
177 ret->hInternet = (HINTERNET)handle;
178
179 if(parent) {
180 ret->lpfnStatusCB = parent->lpfnStatusCB;
181 ret->dwInternalFlags = parent->dwInternalFlags & INET_CALLBACKW;
182 }
183
184 return ret;
185 }
186
187 object_header_t *WININET_AddRef( object_header_t *info )
188 {
189 ULONG refs = InterlockedIncrement(&info->refs);
190 TRACE("%p -> refcount = %d\n", info, refs );
191 return info;
192 }
193
194 object_header_t *get_handle_object( HINTERNET hinternet )
195 {
196 object_header_t *info = NULL;
197 UINT_PTR handle = (UINT_PTR) hinternet;
198
199 EnterCriticalSection( &WININET_cs );
200
201 if(handle > 0 && handle < handle_table_size && handle_table[handle] && handle_table[handle]->valid_handle)
202 info = WININET_AddRef(handle_table[handle]);
203
204 LeaveCriticalSection( &WININET_cs );
205
206 TRACE("handle %ld -> %p\n", handle, info);
207
208 return info;
209 }
210
211 static void invalidate_handle(object_header_t *info)
212 {
213 object_header_t *child, *next;
214
215 if(!info->valid_handle)
216 return;
217 info->valid_handle = FALSE;
218
219 /* Free all children as native does */
220 LIST_FOR_EACH_ENTRY_SAFE( child, next, &info->children, object_header_t, entry )
221 {
222 TRACE("invalidating child handle %p for parent %p\n", child->hInternet, info);
223 invalidate_handle( child );
224 }
225
226 WININET_Release(info);
227 }
228
229 BOOL WININET_Release( object_header_t *info )
230 {
231 ULONG refs = InterlockedDecrement(&info->refs);
232 TRACE( "object %p refcount = %d\n", info, refs );
233 if( !refs )
234 {
235 invalidate_handle(info);
236 if ( info->vtbl->CloseConnection )
237 {
238 TRACE( "closing connection %p\n", info);
239 info->vtbl->CloseConnection( info );
240 }
241 /* Don't send a callback if this is a session handle created with InternetOpenUrl */
242 if ((info->htype != WH_HHTTPSESSION && info->htype != WH_HFTPSESSION)
243 || !(info->dwInternalFlags & INET_OPENURL))
244 {
245 INTERNET_SendCallback(info, info->dwContext,
246 INTERNET_STATUS_HANDLE_CLOSING, &info->hInternet,
247 sizeof(HINTERNET));
248 }
249 TRACE( "destroying object %p\n", info);
250 if ( info->htype != WH_HINIT )
251 list_remove( &info->entry );
252 info->vtbl->Destroy( info );
253
254 if(info->hInternet) {
255 UINT_PTR handle = (UINT_PTR)info->hInternet;
256
257 EnterCriticalSection( &WININET_cs );
258
259 handle_table[handle] = NULL;
260 if(next_handle > handle)
261 next_handle = handle;
262
263 LeaveCriticalSection( &WININET_cs );
264 }
265
266 heap_free(info);
267 }
268 return TRUE;
269 }
270
271 /***********************************************************************
272 * DllMain [Internal] Initializes the internal 'WININET.DLL'.
273 *
274 * PARAMS
275 * hinstDLL [I] handle to the DLL's instance
276 * fdwReason [I]
277 * lpvReserved [I] reserved, must be NULL
278 *
279 * RETURNS
280 * Success: TRUE
281 * Failure: FALSE
282 */
283
284 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
285 {
286 TRACE("%p,%x,%p\n", hinstDLL, fdwReason, lpvReserved);
287
288 switch (fdwReason) {
289 case DLL_PROCESS_ATTACH:
290
291 g_dwTlsErrIndex = TlsAlloc();
292
293 if (g_dwTlsErrIndex == TLS_OUT_OF_INDEXES)
294 return FALSE;
295
296 if(!init_urlcache())
297 {
298 TlsFree(g_dwTlsErrIndex);
299 return FALSE;
300 }
301
302 WININET_hModule = hinstDLL;
303 break;
304
305 case DLL_THREAD_ATTACH:
306 break;
307
308 case DLL_THREAD_DETACH:
309 if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
310 {
311 heap_free(TlsGetValue(g_dwTlsErrIndex));
312 }
313 break;
314
315 case DLL_PROCESS_DETACH:
316 collect_connections(COLLECT_CLEANUP);
317 NETCON_unload();
318 free_urlcache();
319 free_cookie();
320
321 if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
322 {
323 heap_free(TlsGetValue(g_dwTlsErrIndex));
324 TlsFree(g_dwTlsErrIndex);
325 }
326 break;
327 }
328 return TRUE;
329 }
330
331 /***********************************************************************
332 * INTERNET_SaveProxySettings
333 *
334 * Stores the proxy settings given by lpwai into the registry
335 *
336 * RETURNS
337 * ERROR_SUCCESS if no error, or error code on fail
338 */
339 static LONG INTERNET_SaveProxySettings( proxyinfo_t *lpwpi )
340 {
341 HKEY key;
342 LONG ret;
343
344 if ((ret = RegOpenKeyW( HKEY_CURRENT_USER, szInternetSettings, &key )))
345 return ret;
346
347 if ((ret = RegSetValueExW( key, szProxyEnable, 0, REG_DWORD, (BYTE*)&lpwpi->proxyEnabled, sizeof(DWORD))))
348 {
349 RegCloseKey( key );
350 return ret;
351 }
352
353 if (lpwpi->proxy)
354 {
355 if ((ret = RegSetValueExW( key, szProxyServer, 0, REG_SZ, (BYTE*)lpwpi->proxy, sizeof(WCHAR) * (lstrlenW(lpwpi->proxy) + 1))))
356 {
357 RegCloseKey( key );
358 return ret;
359 }
360 }
361 else
362 {
363 if ((ret = RegDeleteValueW( key, szProxyServer )))
364 {
365 RegCloseKey( key );
366 return ret;
367 }
368 }
369
370 RegCloseKey(key);
371 return ERROR_SUCCESS;
372 }
373
374 /***********************************************************************
375 * INTERNET_FindProxyForProtocol
376 *
377 * Searches the proxy string for a proxy of the given protocol.
378 * Returns the found proxy, or the default proxy if none of the given
379 * protocol is found.
380 *
381 * PARAMETERS
382 * szProxy [In] proxy string to search
383 * proto [In] protocol to search for, e.g. "http"
384 * foundProxy [Out] found proxy
385 * foundProxyLen [In/Out] length of foundProxy buffer, in WCHARs
386 *
387 * RETURNS
388 * TRUE if a proxy is found, FALSE if not. If foundProxy is too short,
389 * *foundProxyLen is set to the required size in WCHARs, including the
390 * NULL terminator, and the last error is set to ERROR_INSUFFICIENT_BUFFER.
391 */
392 BOOL INTERNET_FindProxyForProtocol(LPCWSTR szProxy, LPCWSTR proto, WCHAR *foundProxy, DWORD *foundProxyLen)
393 {
394 LPCWSTR ptr;
395 BOOL ret = FALSE;
396
397 TRACE("(%s, %s)\n", debugstr_w(szProxy), debugstr_w(proto));
398
399 /* First, look for the specified protocol (proto=scheme://host:port) */
400 for (ptr = szProxy; !ret && ptr && *ptr; )
401 {
402 LPCWSTR end, equal;
403
404 if (!(end = strchrW(ptr, ' ')))
405 end = ptr + strlenW(ptr);
406 if ((equal = strchrW(ptr, '=')) && equal < end &&
407 equal - ptr == strlenW(proto) &&
408 !strncmpiW(proto, ptr, strlenW(proto)))
409 {
410 if (end - equal > *foundProxyLen)
411 {
412 WARN("buffer too short for %s\n",
413 debugstr_wn(equal + 1, end - equal - 1));
414 *foundProxyLen = end - equal;
415 SetLastError(ERROR_INSUFFICIENT_BUFFER);
416 }
417 else
418 {
419 memcpy(foundProxy, equal + 1, (end - equal) * sizeof(WCHAR));
420 foundProxy[end - equal] = 0;
421 ret = TRUE;
422 }
423 }
424 if (*end == ' ')
425 ptr = end + 1;
426 else
427 ptr = end;
428 }
429 if (!ret)
430 {
431 /* It wasn't found: look for no protocol */
432 for (ptr = szProxy; !ret && ptr && *ptr; )
433 {
434 LPCWSTR end;
435
436 if (!(end = strchrW(ptr, ' ')))
437 end = ptr + strlenW(ptr);
438 if (!strchrW(ptr, '='))
439 {
440 if (end - ptr + 1 > *foundProxyLen)
441 {
442 WARN("buffer too short for %s\n",
443 debugstr_wn(ptr, end - ptr));
444 *foundProxyLen = end - ptr + 1;
445 SetLastError(ERROR_INSUFFICIENT_BUFFER);
446 }
447 else
448 {
449 memcpy(foundProxy, ptr, (end - ptr) * sizeof(WCHAR));
450 foundProxy[end - ptr] = 0;
451 ret = TRUE;
452 }
453 }
454 if (*end == ' ')
455 ptr = end + 1;
456 else
457 ptr = end;
458 }
459 }
460 if (ret)
461 TRACE("found proxy for %s: %s\n", debugstr_w(proto),
462 debugstr_w(foundProxy));
463 return ret;
464 }
465
466 /***********************************************************************
467 * InternetInitializeAutoProxyDll (WININET.@)
468 *
469 * Setup the internal proxy
470 *
471 * PARAMETERS
472 * dwReserved
473 *
474 * RETURNS
475 * FALSE on failure
476 *
477 */
478 BOOL WINAPI InternetInitializeAutoProxyDll(DWORD dwReserved)
479 {
480 FIXME("STUB\n");
481 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
482 return FALSE;
483 }
484
485 /***********************************************************************
486 * DetectAutoProxyUrl (WININET.@)
487 *
488 * Auto detect the proxy url
489 *
490 * RETURNS
491 * FALSE on failure
492 *
493 */
494 BOOL WINAPI DetectAutoProxyUrl(LPSTR lpszAutoProxyUrl,
495 DWORD dwAutoProxyUrlLength, DWORD dwDetectFlags)
496 {
497 FIXME("STUB\n");
498 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
499 return FALSE;
500 }
501
502 static void FreeProxyInfo( proxyinfo_t *lpwpi )
503 {
504 heap_free(lpwpi->proxy);
505 heap_free(lpwpi->proxyBypass);
506 }
507
508 static proxyinfo_t *global_proxy;
509
510 static void free_global_proxy( void )
511 {
512 EnterCriticalSection( &WININET_cs );
513 if (global_proxy)
514 {
515 FreeProxyInfo( global_proxy );
516 heap_free( global_proxy );
517 }
518 LeaveCriticalSection( &WININET_cs );
519 }
520
521 /***********************************************************************
522 * INTERNET_LoadProxySettings
523 *
524 * Loads proxy information from process-wide global settings, the registry,
525 * or the environment into lpwpi.
526 *
527 * The caller should call FreeProxyInfo when done with lpwpi.
528 *
529 * FIXME:
530 * The proxy may be specified in the form 'http=proxy.my.org'
531 * Presumably that means there can be ftp=ftpproxy.my.org too.
532 */
533 static LONG INTERNET_LoadProxySettings( proxyinfo_t *lpwpi )
534 {
535 HKEY key;
536 DWORD type, len;
537 LPCSTR envproxy;
538 LONG ret;
539
540 EnterCriticalSection( &WININET_cs );
541 if (global_proxy)
542 {
543 lpwpi->proxyEnabled = global_proxy->proxyEnabled;
544 lpwpi->proxy = heap_strdupW( global_proxy->proxy );
545 lpwpi->proxyBypass = heap_strdupW( global_proxy->proxyBypass );
546 }
547 LeaveCriticalSection( &WININET_cs );
548
549 if ((ret = RegOpenKeyW( HKEY_CURRENT_USER, szInternetSettings, &key )))
550 return ret;
551
552 len = sizeof(DWORD);
553 if (RegQueryValueExW( key, szProxyEnable, NULL, &type, (BYTE *)&lpwpi->proxyEnabled, &len ) || type != REG_DWORD)
554 {
555 lpwpi->proxyEnabled = 0;
556 if((ret = RegSetValueExW( key, szProxyEnable, 0, REG_DWORD, (BYTE *)&lpwpi->proxyEnabled, sizeof(DWORD) )))
557 {
558 RegCloseKey( key );
559 return ret;
560 }
561 }
562
563 if (!(envproxy = getenv( "http_proxy" )) || lpwpi->proxyEnabled)
564 {
565 TRACE("Proxy is enabled.\n");
566
567 /* figure out how much memory the proxy setting takes */
568 if (!RegQueryValueExW( key, szProxyServer, NULL, &type, NULL, &len ) && len && (type == REG_SZ))
569 {
570 LPWSTR szProxy, p;
571 static const WCHAR szHttp[] = {'h','t','t','p','=',0};
572
573 if (!(szProxy = heap_alloc(len)))
574 {
575 RegCloseKey( key );
576 return ERROR_OUTOFMEMORY;
577 }
578 RegQueryValueExW( key, szProxyServer, NULL, &type, (BYTE*)szProxy, &len );
579
580 /* find the http proxy, and strip away everything else */
581 p = strstrW( szProxy, szHttp );
582 if (p)
583 {
584 p += lstrlenW( szHttp );
585 lstrcpyW( szProxy, p );
586 }
587 p = strchrW( szProxy, ' ' );
588 if (p) *p = 0;
589
590 lpwpi->proxy = szProxy;
591
592 TRACE("http proxy = %s\n", debugstr_w(lpwpi->proxy));
593 }
594 else
595 {
596 TRACE("No proxy server settings in registry.\n");
597 lpwpi->proxy = NULL;
598 }
599 }
600 else if (envproxy)
601 {
602 WCHAR *envproxyW;
603
604 len = MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, NULL, 0 );
605 if (!(envproxyW = heap_alloc(len * sizeof(WCHAR))))
606 return ERROR_OUTOFMEMORY;
607 MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, envproxyW, len );
608
609 lpwpi->proxyEnabled = 1;
610 lpwpi->proxy = envproxyW;
611
612 TRACE("http proxy (from environment) = %s\n", debugstr_w(lpwpi->proxy));
613 }
614
615 lpwpi->proxyBypass = NULL;
616 if (lpwpi->proxyEnabled)
617 {
618 if (!(envproxy = getenv( "no_proxy" )))
619 {
620 /* figure out how much memory the proxy setting takes */
621 if (!RegQueryValueExW( key, szProxyOverride, NULL, &type, NULL, &len ) && len && (type == REG_SZ))
622 {
623 LPWSTR szProxy;
624
625 if (!(szProxy = heap_alloc(len)))
626 {
627 RegCloseKey( key );
628 return ERROR_OUTOFMEMORY;
629 }
630 RegQueryValueExW( key, szProxyOverride, NULL, &type, (BYTE*)szProxy, &len );
631
632 lpwpi->proxyBypass = szProxy;
633
634 TRACE("http proxy bypass = %s\n", debugstr_w(lpwpi->proxyBypass));
635 }
636 else
637 {
638 TRACE("No proxy bypass server settings in registry.\n");
639 }
640 }
641 else if (envproxy)
642 {
643 WCHAR *envproxyW;
644
645 len = MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, NULL, 0 );
646 if (!(envproxyW = heap_alloc(len * sizeof(WCHAR))))
647 return ERROR_OUTOFMEMORY;
648 MultiByteToWideChar( CP_UNIXCP, 0, envproxy, -1, envproxyW, len );
649
650 lpwpi->proxyBypass = envproxyW;
651
652 TRACE("http proxy bypass (from environment) = %s\n", debugstr_w(lpwpi->proxyBypass));
653 }
654 }
655
656 RegCloseKey( key );
657
658 return ERROR_SUCCESS;
659 }
660
661 /***********************************************************************
662 * INTERNET_ConfigureProxy
663 */
664 static BOOL INTERNET_ConfigureProxy( appinfo_t *lpwai )
665 {
666 proxyinfo_t wpi;
667
668 if (INTERNET_LoadProxySettings( &wpi ))
669 return FALSE;
670
671 if (wpi.proxyEnabled)
672 {
673 WCHAR proxyurl[INTERNET_MAX_URL_LENGTH];
674 WCHAR username[INTERNET_MAX_USER_NAME_LENGTH];
675 WCHAR password[INTERNET_MAX_PASSWORD_LENGTH];
676 WCHAR hostname[INTERNET_MAX_HOST_NAME_LENGTH];
677 URL_COMPONENTSW UrlComponents;
678
679 UrlComponents.dwStructSize = sizeof UrlComponents;
680 UrlComponents.dwSchemeLength = 0;
681 UrlComponents.lpszHostName = hostname;
682 UrlComponents.dwHostNameLength = INTERNET_MAX_HOST_NAME_LENGTH;
683 UrlComponents.lpszUserName = username;
684 UrlComponents.dwUserNameLength = INTERNET_MAX_USER_NAME_LENGTH;
685 UrlComponents.lpszPassword = password;
686 UrlComponents.dwPasswordLength = INTERNET_MAX_PASSWORD_LENGTH;
687 UrlComponents.dwUrlPathLength = 0;
688 UrlComponents.dwExtraInfoLength = 0;
689
690 if(InternetCrackUrlW(wpi.proxy, 0, 0, &UrlComponents))
691 {
692 static const WCHAR szFormat[] = { 'h','t','t','p',':','/','/','%','s',':','%','u',0 };
693
694 if(UrlComponents.nPort == INTERNET_INVALID_PORT_NUMBER)
695 UrlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
696 sprintfW(proxyurl, szFormat, hostname, UrlComponents.nPort);
697
698 lpwai->accessType = INTERNET_OPEN_TYPE_PROXY;
699 lpwai->proxy = heap_strdupW(proxyurl);
700 lpwai->proxyBypass = heap_strdupW(wpi.proxyBypass);
701 if (UrlComponents.dwUserNameLength)
702 {
703 lpwai->proxyUsername = heap_strdupW(UrlComponents.lpszUserName);
704 lpwai->proxyPassword = heap_strdupW(UrlComponents.lpszPassword);
705 }
706
707 TRACE("http proxy = %s bypass = %s\n", debugstr_w(lpwai->proxy), debugstr_w(lpwai->proxyBypass));
708 return TRUE;
709 }
710 else
711 {
712 TRACE("Failed to parse proxy: %s\n", debugstr_w(wpi.proxy));
713 lpwai->proxy = NULL;
714 }
715 }
716
717 lpwai->accessType = INTERNET_OPEN_TYPE_DIRECT;
718 return FALSE;
719 }
720
721 /***********************************************************************
722 * dump_INTERNET_FLAGS
723 *
724 * Helper function to TRACE the internet flags.
725 *
726 * RETURNS
727 * None
728 *
729 */
730 static void dump_INTERNET_FLAGS(DWORD dwFlags)
731 {
732 #define FE(x) { x, #x }
733 static const wininet_flag_info flag[] = {
734 FE(INTERNET_FLAG_RELOAD),
735 FE(INTERNET_FLAG_RAW_DATA),
736 FE(INTERNET_FLAG_EXISTING_CONNECT),
737 FE(INTERNET_FLAG_ASYNC),
738 FE(INTERNET_FLAG_PASSIVE),
739 FE(INTERNET_FLAG_NO_CACHE_WRITE),
740 FE(INTERNET_FLAG_MAKE_PERSISTENT),
741 FE(INTERNET_FLAG_FROM_CACHE),
742 FE(INTERNET_FLAG_SECURE),
743 FE(INTERNET_FLAG_KEEP_CONNECTION),
744 FE(INTERNET_FLAG_NO_AUTO_REDIRECT),
745 FE(INTERNET_FLAG_READ_PREFETCH),
746 FE(INTERNET_FLAG_NO_COOKIES),
747 FE(INTERNET_FLAG_NO_AUTH),
748 FE(INTERNET_FLAG_CACHE_IF_NET_FAIL),
749 FE(INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP),
750 FE(INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS),
751 FE(INTERNET_FLAG_IGNORE_CERT_DATE_INVALID),
752 FE(INTERNET_FLAG_IGNORE_CERT_CN_INVALID),
753 FE(INTERNET_FLAG_RESYNCHRONIZE),
754 FE(INTERNET_FLAG_HYPERLINK),
755 FE(INTERNET_FLAG_NO_UI),
756 FE(INTERNET_FLAG_PRAGMA_NOCACHE),
757 FE(INTERNET_FLAG_CACHE_ASYNC),
758 FE(INTERNET_FLAG_FORMS_SUBMIT),
759 FE(INTERNET_FLAG_NEED_FILE),
760 FE(INTERNET_FLAG_TRANSFER_ASCII),
761 FE(INTERNET_FLAG_TRANSFER_BINARY)
762 };
763 #undef FE
764 unsigned int i;
765
766 for (i = 0; i < (sizeof(flag) / sizeof(flag[0])); i++) {
767 if (flag[i].val & dwFlags) {
768 TRACE(" %s", flag[i].name);
769 dwFlags &= ~flag[i].val;
770 }
771 }
772 if (dwFlags)
773 TRACE(" Unknown flags (%08x)\n", dwFlags);
774 else
775 TRACE("\n");
776 }
777
778 /***********************************************************************
779 * INTERNET_CloseHandle (internal)
780 *
781 * Close internet handle
782 *
783 */
784 static VOID APPINFO_Destroy(object_header_t *hdr)
785 {
786 appinfo_t *lpwai = (appinfo_t*)hdr;
787
788 TRACE("%p\n",lpwai);
789
790 heap_free(lpwai->agent);
791 heap_free(lpwai->proxy);
792 heap_free(lpwai->proxyBypass);
793 heap_free(lpwai->proxyUsername);
794 heap_free(lpwai->proxyPassword);
795 }
796
797 static DWORD APPINFO_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
798 {
799 appinfo_t *ai = (appinfo_t*)hdr;
800
801 switch(option) {
802 case INTERNET_OPTION_HANDLE_TYPE:
803 TRACE("INTERNET_OPTION_HANDLE_TYPE\n");
804
805 if (*size < sizeof(ULONG))
806 return ERROR_INSUFFICIENT_BUFFER;
807
808 *size = sizeof(DWORD);
809 *(DWORD*)buffer = INTERNET_HANDLE_TYPE_INTERNET;
810 return ERROR_SUCCESS;
811
812 case INTERNET_OPTION_USER_AGENT: {
813 DWORD bufsize;
814
815 TRACE("INTERNET_OPTION_USER_AGENT\n");
816
817 bufsize = *size;
818
819 if (unicode) {
820 DWORD len = ai->agent ? strlenW(ai->agent) : 0;
821
822 *size = (len + 1) * sizeof(WCHAR);
823 if(!buffer || bufsize < *size)
824 return ERROR_INSUFFICIENT_BUFFER;
825
826 if (ai->agent)
827 strcpyW(buffer, ai->agent);
828 else
829 *(WCHAR *)buffer = 0;
830 /* If the buffer is copied, the returned length doesn't include
831 * the NULL terminator.
832 */
833 *size = len;
834 }else {
835 if (ai->agent)
836 *size = WideCharToMultiByte(CP_ACP, 0, ai->agent, -1, NULL, 0, NULL, NULL);
837 else
838 *size = 1;
839 if(!buffer || bufsize < *size)
840 return ERROR_INSUFFICIENT_BUFFER;
841
842 if (ai->agent)
843 WideCharToMultiByte(CP_ACP, 0, ai->agent, -1, buffer, *size, NULL, NULL);
844 else
845 *(char *)buffer = 0;
846 /* If the buffer is copied, the returned length doesn't include
847 * the NULL terminator.
848 */
849 *size -= 1;
850 }
851
852 return ERROR_SUCCESS;
853 }
854
855 case INTERNET_OPTION_PROXY:
856 if(!size) return ERROR_INVALID_PARAMETER;
857 if (unicode) {
858 INTERNET_PROXY_INFOW *pi = (INTERNET_PROXY_INFOW *)buffer;
859 DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
860 LPWSTR proxy, proxy_bypass;
861
862 if (ai->proxy)
863 proxyBytesRequired = (lstrlenW(ai->proxy) + 1) * sizeof(WCHAR);
864 if (ai->proxyBypass)
865 proxyBypassBytesRequired = (lstrlenW(ai->proxyBypass) + 1) * sizeof(WCHAR);
866 if (!pi || *size < sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired)
867 {
868 *size = sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired;
869 return ERROR_INSUFFICIENT_BUFFER;
870 }
871 proxy = (LPWSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOW));
872 proxy_bypass = (LPWSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired);
873
874 pi->dwAccessType = ai->accessType;
875 pi->lpszProxy = NULL;
876 pi->lpszProxyBypass = NULL;
877 if (ai->proxy) {
878 lstrcpyW(proxy, ai->proxy);
879 pi->lpszProxy = proxy;
880 }
881
882 if (ai->proxyBypass) {
883 lstrcpyW(proxy_bypass, ai->proxyBypass);
884 pi->lpszProxyBypass = proxy_bypass;
885 }
886
887 *size = sizeof(INTERNET_PROXY_INFOW) + proxyBytesRequired + proxyBypassBytesRequired;
888 return ERROR_SUCCESS;
889 }else {
890 INTERNET_PROXY_INFOA *pi = (INTERNET_PROXY_INFOA *)buffer;
891 DWORD proxyBytesRequired = 0, proxyBypassBytesRequired = 0;
892 LPSTR proxy, proxy_bypass;
893
894 if (ai->proxy)
895 proxyBytesRequired = WideCharToMultiByte(CP_ACP, 0, ai->proxy, -1, NULL, 0, NULL, NULL);
896 if (ai->proxyBypass)
897 proxyBypassBytesRequired = WideCharToMultiByte(CP_ACP, 0, ai->proxyBypass, -1,
898 NULL, 0, NULL, NULL);
899 if (!pi || *size < sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired)
900 {
901 *size = sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired;
902 return ERROR_INSUFFICIENT_BUFFER;
903 }
904 proxy = (LPSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOA));
905 proxy_bypass = (LPSTR)((LPBYTE)buffer + sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired);
906
907 pi->dwAccessType = ai->accessType;
908 pi->lpszProxy = NULL;
909 pi->lpszProxyBypass = NULL;
910 if (ai->proxy) {
911 WideCharToMultiByte(CP_ACP, 0, ai->proxy, -1, proxy, proxyBytesRequired, NULL, NULL);
912 pi->lpszProxy = proxy;
913 }
914
915 if (ai->proxyBypass) {
916 WideCharToMultiByte(CP_ACP, 0, ai->proxyBypass, -1, proxy_bypass,
917 proxyBypassBytesRequired, NULL, NULL);
918 pi->lpszProxyBypass = proxy_bypass;
919 }
920
921 *size = sizeof(INTERNET_PROXY_INFOA) + proxyBytesRequired + proxyBypassBytesRequired;
922 return ERROR_SUCCESS;
923 }
924
925 case INTERNET_OPTION_CONNECT_TIMEOUT:
926 TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
927
928 if (*size < sizeof(ULONG))
929 return ERROR_INSUFFICIENT_BUFFER;
930
931 *(ULONG*)buffer = ai->connect_timeout;
932 *size = sizeof(ULONG);
933
934 return ERROR_SUCCESS;
935 }
936
937 return INET_QueryOption(hdr, option, buffer, size, unicode);
938 }
939
940 static DWORD APPINFO_SetOption(object_header_t *hdr, DWORD option, void *buf, DWORD size)
941 {
942 appinfo_t *ai = (appinfo_t*)hdr;
943
944 switch(option) {
945 case INTERNET_OPTION_CONNECT_TIMEOUT:
946 TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
947
948 if(size != sizeof(connect_timeout))
949 return ERROR_INTERNET_BAD_OPTION_LENGTH;
950 if(!*(ULONG*)buf)
951 return ERROR_BAD_ARGUMENTS;
952
953 ai->connect_timeout = *(ULONG*)buf;
954 return ERROR_SUCCESS;
955 case INTERNET_OPTION_USER_AGENT:
956 heap_free(ai->agent);
957 if (!(ai->agent = heap_strdupW(buf))) return ERROR_OUTOFMEMORY;
958 return ERROR_SUCCESS;
959 }
960
961 return INET_SetOption(hdr, option, buf, size);
962 }
963
964 static const object_vtbl_t APPINFOVtbl = {
965 APPINFO_Destroy,
966 NULL,
967 APPINFO_QueryOption,
968 APPINFO_SetOption,
969 NULL,
970 NULL,
971 NULL,
972 NULL
973 };
974
975
976 /***********************************************************************
977 * InternetOpenW (WININET.@)
978 *
979 * Per-application initialization of wininet
980 *
981 * RETURNS
982 * HINTERNET on success
983 * NULL on failure
984 *
985 */
986 HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType,
987 LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags)
988 {
989 appinfo_t *lpwai = NULL;
990
991 if (TRACE_ON(wininet)) {
992 #define FE(x) { x, #x }
993 static const wininet_flag_info access_type[] = {
994 FE(INTERNET_OPEN_TYPE_PRECONFIG),
995 FE(INTERNET_OPEN_TYPE_DIRECT),
996 FE(INTERNET_OPEN_TYPE_PROXY),
997 FE(INTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXY)
998 };
999 #undef FE
1000 DWORD i;
1001 const char *access_type_str = "Unknown";
1002
1003 TRACE("(%s, %i, %s, %s, %i)\n", debugstr_w(lpszAgent), dwAccessType,
1004 debugstr_w(lpszProxy), debugstr_w(lpszProxyBypass), dwFlags);
1005 for (i = 0; i < (sizeof(access_type) / sizeof(access_type[0])); i++) {
1006 if (access_type[i].val == dwAccessType) {
1007 access_type_str = access_type[i].name;
1008 break;
1009 }
1010 }
1011 TRACE(" access type : %s\n", access_type_str);
1012 TRACE(" flags :");
1013 dump_INTERNET_FLAGS(dwFlags);
1014 }
1015
1016 /* Clear any error information */
1017 INTERNET_SetLastError(0);
1018
1019 if((dwAccessType == INTERNET_OPEN_TYPE_PROXY) && !lpszProxy) {
1020 SetLastError(ERROR_INVALID_PARAMETER);
1021 return NULL;
1022 }
1023
1024 lpwai = alloc_object(NULL, &APPINFOVtbl, sizeof(appinfo_t));
1025 if (!lpwai) {
1026 SetLastError(ERROR_OUTOFMEMORY);
1027 return NULL;
1028 }
1029
1030 lpwai->hdr.htype = WH_HINIT;
1031 lpwai->hdr.dwFlags = dwFlags;
1032 lpwai->accessType = dwAccessType;
1033 lpwai->proxyUsername = NULL;
1034 lpwai->proxyPassword = NULL;
1035 lpwai->connect_timeout = connect_timeout;
1036
1037 lpwai->agent = heap_strdupW(lpszAgent);
1038 if(dwAccessType == INTERNET_OPEN_TYPE_PRECONFIG)
1039 INTERNET_ConfigureProxy( lpwai );
1040 else if(dwAccessType == INTERNET_OPEN_TYPE_PROXY) {
1041 lpwai->proxy = heap_strdupW(lpszProxy);
1042 lpwai->proxyBypass = heap_strdupW(lpszProxyBypass);
1043 }
1044
1045 TRACE("returning %p\n", lpwai);
1046
1047 return lpwai->hdr.hInternet;
1048 }
1049
1050
1051 /***********************************************************************
1052 * InternetOpenA (WININET.@)
1053 *
1054 * Per-application initialization of wininet
1055 *
1056 * RETURNS
1057 * HINTERNET on success
1058 * NULL on failure
1059 *
1060 */
1061 HINTERNET WINAPI InternetOpenA(LPCSTR lpszAgent, DWORD dwAccessType,
1062 LPCSTR lpszProxy, LPCSTR lpszProxyBypass, DWORD dwFlags)
1063 {
1064 WCHAR *szAgent, *szProxy, *szBypass;
1065 HINTERNET rc;
1066
1067 TRACE("(%s, 0x%08x, %s, %s, 0x%08x)\n", debugstr_a(lpszAgent),
1068 dwAccessType, debugstr_a(lpszProxy), debugstr_a(lpszProxyBypass), dwFlags);
1069
1070 szAgent = heap_strdupAtoW(lpszAgent);
1071 szProxy = heap_strdupAtoW(lpszProxy);
1072 szBypass = heap_strdupAtoW(lpszProxyBypass);
1073
1074 rc = InternetOpenW(szAgent, dwAccessType, szProxy, szBypass, dwFlags);
1075
1076 heap_free(szAgent);
1077 heap_free(szProxy);
1078 heap_free(szBypass);
1079 return rc;
1080 }
1081
1082 /***********************************************************************
1083 * InternetGetLastResponseInfoA (WININET.@)
1084 *
1085 * Return last wininet error description on the calling thread
1086 *
1087 * RETURNS
1088 * TRUE on success of writing to buffer
1089 * FALSE on failure
1090 *
1091 */
1092 BOOL WINAPI InternetGetLastResponseInfoA(LPDWORD lpdwError,
1093 LPSTR lpszBuffer, LPDWORD lpdwBufferLength)
1094 {
1095 LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
1096
1097 TRACE("\n");
1098
1099 if (lpwite)
1100 {
1101 *lpdwError = lpwite->dwError;
1102 if (lpwite->dwError)
1103 {
1104 memcpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
1105 *lpdwBufferLength = strlen(lpszBuffer);
1106 }
1107 else
1108 *lpdwBufferLength = 0;
1109 }
1110 else
1111 {
1112 *lpdwError = 0;
1113 *lpdwBufferLength = 0;
1114 }
1115
1116 return TRUE;
1117 }
1118
1119 /***********************************************************************
1120 * InternetGetLastResponseInfoW (WININET.@)
1121 *
1122 * Return last wininet error description on the calling thread
1123 *
1124 * RETURNS
1125 * TRUE on success of writing to buffer
1126 * FALSE on failure
1127 *
1128 */
1129 BOOL WINAPI InternetGetLastResponseInfoW(LPDWORD lpdwError,
1130 LPWSTR lpszBuffer, LPDWORD lpdwBufferLength)
1131 {
1132 LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
1133
1134 TRACE("\n");
1135
1136 if (lpwite)
1137 {
1138 *lpdwError = lpwite->dwError;
1139 if (lpwite->dwError)
1140 {
1141 memcpy(lpszBuffer, lpwite->response, *lpdwBufferLength);
1142 *lpdwBufferLength = lstrlenW(lpszBuffer);
1143 }
1144 else
1145 *lpdwBufferLength = 0;
1146 }
1147 else
1148 {
1149 *lpdwError = 0;
1150 *lpdwBufferLength = 0;
1151 }
1152
1153 return TRUE;
1154 }
1155
1156 /***********************************************************************
1157 * InternetGetConnectedState (WININET.@)
1158 *
1159 * Return connected state
1160 *
1161 * RETURNS
1162 * TRUE if connected
1163 * if lpdwStatus is not null, return the status (off line,
1164 * modem, lan...) in it.
1165 * FALSE if not connected
1166 */
1167 BOOL WINAPI InternetGetConnectedState(LPDWORD lpdwStatus, DWORD dwReserved)
1168 {
1169 TRACE("(%p, 0x%08x)\n", lpdwStatus, dwReserved);
1170
1171 if (lpdwStatus) {
1172 WARN("always returning LAN connection.\n");
1173 *lpdwStatus = INTERNET_CONNECTION_LAN;
1174 }
1175 return TRUE;
1176 }
1177
1178
1179 /***********************************************************************
1180 * InternetGetConnectedStateExW (WININET.@)
1181 *
1182 * Return connected state
1183 *
1184 * PARAMS
1185 *
1186 * lpdwStatus [O] Flags specifying the status of the internet connection.
1187 * lpszConnectionName [O] Pointer to buffer to receive the friendly name of the internet connection.
1188 * dwNameLen [I] Size of the buffer, in characters.
1189 * dwReserved [I] Reserved. Must be set to 0.
1190 *
1191 * RETURNS
1192 * TRUE if connected
1193 * if lpdwStatus is not null, return the status (off line,
1194 * modem, lan...) in it.
1195 * FALSE if not connected
1196 *
1197 * NOTES
1198 * If the system has no available network connections, an empty string is
1199 * stored in lpszConnectionName. If there is a LAN connection, a localized
1200 * "LAN Connection" string is stored. Presumably, if only a dial-up
1201 * connection is available then the name of the dial-up connection is
1202 * returned. Why any application, other than the "Internet Settings" CPL,
1203 * would want to use this function instead of the simpler InternetGetConnectedStateW
1204 * function is beyond me.
1205 */
1206 BOOL WINAPI InternetGetConnectedStateExW(LPDWORD lpdwStatus, LPWSTR lpszConnectionName,
1207 DWORD dwNameLen, DWORD dwReserved)
1208 {
1209 TRACE("(%p, %p, %d, 0x%08x)\n", lpdwStatus, lpszConnectionName, dwNameLen, dwReserved);
1210
1211 /* Must be zero */
1212 if(dwReserved)
1213 return FALSE;
1214
1215 if (lpdwStatus) {
1216 WARN("always returning LAN connection.\n");
1217 *lpdwStatus = INTERNET_CONNECTION_LAN;
1218 }
1219 return LoadStringW(WININET_hModule, IDS_LANCONNECTION, lpszConnectionName, dwNameLen);
1220 }
1221
1222
1223 /***********************************************************************
1224 * InternetGetConnectedStateExA (WININET.@)
1225 */
1226 BOOL WINAPI InternetGetConnectedStateExA(LPDWORD lpdwStatus, LPSTR lpszConnectionName,
1227 DWORD dwNameLen, DWORD dwReserved)
1228 {
1229 LPWSTR lpwszConnectionName = NULL;
1230 BOOL rc;
1231
1232 TRACE("(%p, %p, %d, 0x%08x)\n", lpdwStatus, lpszConnectionName, dwNameLen, dwReserved);
1233
1234 if (lpszConnectionName && dwNameLen > 0)
1235 lpwszConnectionName = heap_alloc(dwNameLen * sizeof(WCHAR));
1236
1237 rc = InternetGetConnectedStateExW(lpdwStatus,lpwszConnectionName, dwNameLen,
1238 dwReserved);
1239 if (rc && lpwszConnectionName)
1240 {
1241 WideCharToMultiByte(CP_ACP,0,lpwszConnectionName,-1,lpszConnectionName,
1242 dwNameLen, NULL, NULL);
1243 heap_free(lpwszConnectionName);
1244 }
1245 return rc;
1246 }
1247
1248
1249 /***********************************************************************
1250 * InternetConnectW (WININET.@)
1251 *
1252 * Open a ftp, gopher or http session
1253 *
1254 * RETURNS
1255 * HINTERNET a session handle on success
1256 * NULL on failure
1257 *
1258 */
1259 HINTERNET WINAPI InternetConnectW(HINTERNET hInternet,
1260 LPCWSTR lpszServerName, INTERNET_PORT nServerPort,
1261 LPCWSTR lpszUserName, LPCWSTR lpszPassword,
1262 DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
1263 {
1264 appinfo_t *hIC;
1265 HINTERNET rc = NULL;
1266 DWORD res = ERROR_SUCCESS;
1267
1268 TRACE("(%p, %s, %i, %s, %s, %i, %x, %lx)\n", hInternet, debugstr_w(lpszServerName),
1269 nServerPort, debugstr_w(lpszUserName), debugstr_w(lpszPassword),
1270 dwService, dwFlags, dwContext);
1271
1272 if (!lpszServerName)
1273 {
1274 SetLastError(ERROR_INVALID_PARAMETER);
1275 return NULL;
1276 }
1277
1278 hIC = (appinfo_t*)get_handle_object( hInternet );
1279 if ( (hIC == NULL) || (hIC->hdr.htype != WH_HINIT) )
1280 {
1281 res = ERROR_INVALID_HANDLE;
1282 goto lend;
1283 }
1284
1285 switch (dwService)
1286 {
1287 case INTERNET_SERVICE_FTP:
1288 rc = FTP_Connect(hIC, lpszServerName, nServerPort,
1289 lpszUserName, lpszPassword, dwFlags, dwContext, 0);
1290 if(!rc)
1291 res = INTERNET_GetLastError();
1292 break;
1293
1294 case INTERNET_SERVICE_HTTP:
1295 res = HTTP_Connect(hIC, lpszServerName, nServerPort,
1296 lpszUserName, lpszPassword, dwFlags, dwContext, 0, &rc);
1297 break;
1298
1299 case INTERNET_SERVICE_GOPHER:
1300 default:
1301 break;
1302 }
1303 lend:
1304 if( hIC )
1305 WININET_Release( &hIC->hdr );
1306
1307 TRACE("returning %p\n", rc);
1308 SetLastError(res);
1309 return rc;
1310 }
1311
1312
1313 /***********************************************************************
1314 * InternetConnectA (WININET.@)
1315 *
1316 * Open a ftp, gopher or http session
1317 *
1318 * RETURNS
1319 * HINTERNET a session handle on success
1320 * NULL on failure
1321 *
1322 */
1323 HINTERNET WINAPI InternetConnectA(HINTERNET hInternet,
1324 LPCSTR lpszServerName, INTERNET_PORT nServerPort,
1325 LPCSTR lpszUserName, LPCSTR lpszPassword,
1326 DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
1327 {
1328 HINTERNET rc = NULL;
1329 LPWSTR szServerName;
1330 LPWSTR szUserName;
1331 LPWSTR szPassword;
1332
1333 szServerName = heap_strdupAtoW(lpszServerName);
1334 szUserName = heap_strdupAtoW(lpszUserName);
1335 szPassword = heap_strdupAtoW(lpszPassword);
1336
1337 rc = InternetConnectW(hInternet, szServerName, nServerPort,
1338 szUserName, szPassword, dwService, dwFlags, dwContext);
1339
1340 heap_free(szServerName);
1341 heap_free(szUserName);
1342 heap_free(szPassword);
1343 return rc;
1344 }
1345
1346
1347 /***********************************************************************
1348 * InternetFindNextFileA (WININET.@)
1349 *
1350 * Continues a file search from a previous call to FindFirstFile
1351 *
1352 * RETURNS
1353 * TRUE on success
1354 * FALSE on failure
1355 *
1356 */
1357 BOOL WINAPI InternetFindNextFileA(HINTERNET hFind, LPVOID lpvFindData)
1358 {
1359 BOOL ret;
1360 WIN32_FIND_DATAW fd;
1361
1362 ret = InternetFindNextFileW(hFind, lpvFindData?&fd:NULL);
1363 if(lpvFindData)
1364 WININET_find_data_WtoA(&fd, (LPWIN32_FIND_DATAA)lpvFindData);
1365 return ret;
1366 }
1367
1368 /***********************************************************************
1369 * InternetFindNextFileW (WININET.@)
1370 *
1371 * Continues a file search from a previous call to FindFirstFile
1372 *
1373 * RETURNS
1374 * TRUE on success
1375 * FALSE on failure
1376 *
1377 */
1378 BOOL WINAPI InternetFindNextFileW(HINTERNET hFind, LPVOID lpvFindData)
1379 {
1380 object_header_t *hdr;
1381 DWORD res;
1382
1383 TRACE("\n");
1384
1385 hdr = get_handle_object(hFind);
1386 if(!hdr) {
1387 WARN("Invalid handle\n");
1388 SetLastError(ERROR_INVALID_HANDLE);
1389 return FALSE;
1390 }
1391
1392 if(hdr->vtbl->FindNextFileW) {
1393 res = hdr->vtbl->FindNextFileW(hdr, lpvFindData);
1394 }else {
1395 WARN("Handle doesn't support NextFile\n");
1396 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
1397 }
1398
1399 WININET_Release(hdr);
1400
1401 if(res != ERROR_SUCCESS)
1402 SetLastError(res);
1403 return res == ERROR_SUCCESS;
1404 }
1405
1406 /***********************************************************************
1407 * InternetCloseHandle (WININET.@)
1408 *
1409 * Generic close handle function
1410 *
1411 * RETURNS
1412 * TRUE on success
1413 * FALSE on failure
1414 *
1415 */
1416 BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
1417 {
1418 object_header_t *obj;
1419
1420 TRACE("%p\n", hInternet);
1421
1422 obj = get_handle_object( hInternet );
1423 if (!obj) {
1424 SetLastError(ERROR_INVALID_HANDLE);
1425 return FALSE;
1426 }
1427
1428 invalidate_handle(obj);
1429 WININET_Release(obj);
1430
1431 return TRUE;
1432 }
1433
1434
1435 /***********************************************************************
1436 * ConvertUrlComponentValue (Internal)
1437 *
1438 * Helper function for InternetCrackUrlA
1439 *
1440 */
1441 static void ConvertUrlComponentValue(LPSTR* lppszComponent, LPDWORD dwComponentLen,
1442 LPWSTR lpwszComponent, DWORD dwwComponentLen,
1443 LPCSTR lpszStart, LPCWSTR lpwszStart)
1444 {
1445 TRACE("%p %d %p %d %p %p\n", *lppszComponent, *dwComponentLen, lpwszComponent, dwwComponentLen, lpszStart, lpwszStart);
1446 if (*dwComponentLen != 0)
1447 {
1448 DWORD nASCIILength=WideCharToMultiByte(CP_ACP,0,lpwszComponent,dwwComponentLen,NULL,0,NULL,NULL);
1449 if (*lppszComponent == NULL)
1450 {
1451 if (lpwszComponent)
1452 {
1453 int offset = WideCharToMultiByte(CP_ACP, 0, lpwszStart, lpwszComponent-lpwszStart, NULL, 0, NULL, NULL);
1454 *lppszComponent = (LPSTR)lpszStart + offset;
1455 }
1456 else
1457 *lppszComponent = NULL;
1458
1459 *dwComponentLen = nASCIILength;
1460 }
1461 else
1462 {
1463 DWORD ncpylen = min((*dwComponentLen)-1, nASCIILength);
1464 WideCharToMultiByte(CP_ACP,0,lpwszComponent,dwwComponentLen,*lppszComponent,ncpylen+1,NULL,NULL);
1465 (*lppszComponent)[ncpylen]=0;
1466 *dwComponentLen = ncpylen;
1467 }
1468 }
1469 }
1470
1471
1472 /***********************************************************************
1473 * InternetCrackUrlA (WININET.@)
1474 *
1475 * See InternetCrackUrlW.
1476 */
1477 BOOL WINAPI InternetCrackUrlA(LPCSTR lpszUrl, DWORD dwUrlLength, DWORD dwFlags,
1478 LPURL_COMPONENTSA lpUrlComponents)
1479 {
1480 DWORD nLength;
1481 URL_COMPONENTSW UCW;
1482 BOOL ret = FALSE;
1483 WCHAR *lpwszUrl, *hostname = NULL, *username = NULL, *password = NULL, *path = NULL,
1484 *scheme = NULL, *extra = NULL;
1485
1486 TRACE("(%s %u %x %p)\n",
1487 lpszUrl ? debugstr_an(lpszUrl, dwUrlLength ? dwUrlLength : strlen(lpszUrl)) : "(null)",
1488 dwUrlLength, dwFlags, lpUrlComponents);
1489
1490 if (!lpszUrl || !*lpszUrl || !lpUrlComponents ||
1491 lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSA))
1492 {
1493 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1494 return FALSE;
1495 }
1496
1497 if(dwUrlLength<=0)
1498 dwUrlLength=-1;
1499 nLength=MultiByteToWideChar(CP_ACP,0,lpszUrl,dwUrlLength,NULL,0);
1500
1501 /* if dwUrlLength=-1 then nLength includes null but length to
1502 InternetCrackUrlW should not include it */
1503 if (dwUrlLength == -1) nLength--;
1504
1505 lpwszUrl = heap_alloc((nLength + 1) * sizeof(WCHAR));
1506 MultiByteToWideChar(CP_ACP,0,lpszUrl,dwUrlLength,lpwszUrl,nLength + 1);
1507 lpwszUrl[nLength] = '\0';
1508
1509 memset(&UCW,0,sizeof(UCW));
1510 UCW.dwStructSize = sizeof(URL_COMPONENTSW);
1511 if (lpUrlComponents->dwHostNameLength)
1512 {
1513 UCW.dwHostNameLength = lpUrlComponents->dwHostNameLength;
1514 if (lpUrlComponents->lpszHostName)
1515 {
1516 hostname = heap_alloc(UCW.dwHostNameLength * sizeof(WCHAR));
1517 UCW.lpszHostName = hostname;
1518 }
1519 }
1520 if (lpUrlComponents->dwUserNameLength)
1521 {
1522 UCW.dwUserNameLength = lpUrlComponents->dwUserNameLength;
1523 if (lpUrlComponents->lpszUserName)
1524 {
1525 username = heap_alloc(UCW.dwUserNameLength * sizeof(WCHAR));
1526 UCW.lpszUserName = username;
1527 }
1528 }
1529 if (lpUrlComponents->dwPasswordLength)
1530 {
1531 UCW.dwPasswordLength = lpUrlComponents->dwPasswordLength;
1532 if (lpUrlComponents->lpszPassword)
1533 {
1534 password = heap_alloc(UCW.dwPasswordLength * sizeof(WCHAR));
1535 UCW.lpszPassword = password;
1536 }
1537 }
1538 if (lpUrlComponents->dwUrlPathLength)
1539 {
1540 UCW.dwUrlPathLength = lpUrlComponents->dwUrlPathLength;
1541 if (lpUrlComponents->lpszUrlPath)
1542 {
1543 path = heap_alloc(UCW.dwUrlPathLength * sizeof(WCHAR));
1544 UCW.lpszUrlPath = path;
1545 }
1546 }
1547 if (lpUrlComponents->dwSchemeLength)
1548 {
1549 UCW.dwSchemeLength = lpUrlComponents->dwSchemeLength;
1550 if (lpUrlComponents->lpszScheme)
1551 {
1552 scheme = heap_alloc(UCW.dwSchemeLength * sizeof(WCHAR));
1553 UCW.lpszScheme = scheme;
1554 }
1555 }
1556 if (lpUrlComponents->dwExtraInfoLength)
1557 {
1558 UCW.dwExtraInfoLength = lpUrlComponents->dwExtraInfoLength;
1559 if (lpUrlComponents->lpszExtraInfo)
1560 {
1561 extra = heap_alloc(UCW.dwExtraInfoLength * sizeof(WCHAR));
1562 UCW.lpszExtraInfo = extra;
1563 }
1564 }
1565 if ((ret = InternetCrackUrlW(lpwszUrl, nLength, dwFlags, &UCW)))
1566 {
1567 ConvertUrlComponentValue(&lpUrlComponents->lpszHostName, &lpUrlComponents->dwHostNameLength,
1568 UCW.lpszHostName, UCW.dwHostNameLength, lpszUrl, lpwszUrl);
1569 ConvertUrlComponentValue(&lpUrlComponents->lpszUserName, &lpUrlComponents->dwUserNameLength,
1570 UCW.lpszUserName, UCW.dwUserNameLength, lpszUrl, lpwszUrl);
1571 ConvertUrlComponentValue(&lpUrlComponents->lpszPassword, &lpUrlComponents->dwPasswordLength,
1572 UCW.lpszPassword, UCW.dwPasswordLength, lpszUrl, lpwszUrl);
1573 ConvertUrlComponentValue(&lpUrlComponents->lpszUrlPath, &lpUrlComponents->dwUrlPathLength,
1574 UCW.lpszUrlPath, UCW.dwUrlPathLength, lpszUrl, lpwszUrl);
1575 ConvertUrlComponentValue(&lpUrlComponents->lpszScheme, &lpUrlComponents->dwSchemeLength,
1576 UCW.lpszScheme, UCW.dwSchemeLength, lpszUrl, lpwszUrl);
1577 ConvertUrlComponentValue(&lpUrlComponents->lpszExtraInfo, &lpUrlComponents->dwExtraInfoLength,
1578 UCW.lpszExtraInfo, UCW.dwExtraInfoLength, lpszUrl, lpwszUrl);
1579
1580 lpUrlComponents->nScheme = UCW.nScheme;
1581 lpUrlComponents->nPort = UCW.nPort;
1582
1583 TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", debugstr_a(lpszUrl),
1584 debugstr_an(lpUrlComponents->lpszScheme, lpUrlComponents->dwSchemeLength),
1585 debugstr_an(lpUrlComponents->lpszHostName, lpUrlComponents->dwHostNameLength),
1586 debugstr_an(lpUrlComponents->lpszUrlPath, lpUrlComponents->dwUrlPathLength),
1587 debugstr_an(lpUrlComponents->lpszExtraInfo, lpUrlComponents->dwExtraInfoLength));
1588 }
1589 heap_free(lpwszUrl);
1590 heap_free(hostname);
1591 heap_free(username);
1592 heap_free(password);
1593 heap_free(path);
1594 heap_free(scheme);
1595 heap_free(extra);
1596 return ret;
1597 }
1598
1599 static const WCHAR url_schemes[][7] =
1600 {
1601 {'f','t','p',0},
1602 {'g','o','p','h','e','r',0},
1603 {'h','t','t','p',0},
1604 {'h','t','t','p','s',0},
1605 {'f','i','l','e',0},
1606 {'n','e','w','s',0},
1607 {'m','a','i','l','t','o',0},
1608 {'r','e','s',0},
1609 };
1610
1611 /***********************************************************************
1612 * GetInternetSchemeW (internal)
1613 *
1614 * Get scheme of url
1615 *
1616 * RETURNS
1617 * scheme on success
1618 * INTERNET_SCHEME_UNKNOWN on failure
1619 *
1620 */
1621 static INTERNET_SCHEME GetInternetSchemeW(LPCWSTR lpszScheme, DWORD nMaxCmp)
1622 {
1623 int i;
1624
1625 TRACE("%s %d\n",debugstr_wn(lpszScheme, nMaxCmp), nMaxCmp);
1626
1627 if(lpszScheme==NULL)
1628 return INTERNET_SCHEME_UNKNOWN;
1629
1630 for (i = 0; i < sizeof(url_schemes)/sizeof(url_schemes[0]); i++)
1631 if (!strncmpiW(lpszScheme, url_schemes[i], nMaxCmp))
1632 return INTERNET_SCHEME_FIRST + i;
1633
1634 return INTERNET_SCHEME_UNKNOWN;
1635 }
1636
1637 /***********************************************************************
1638 * SetUrlComponentValueW (Internal)
1639 *
1640 * Helper function for InternetCrackUrlW
1641 *
1642 * PARAMS
1643 * lppszComponent [O] Holds the returned string
1644 * dwComponentLen [I] Holds the size of lppszComponent
1645 * [O] Holds the length of the string in lppszComponent without '\0'
1646 * lpszStart [I] Holds the string to copy from
1647 * len [I] Holds the length of lpszStart without '\0'
1648 *
1649 * RETURNS
1650 * TRUE on success
1651 * FALSE on failure
1652 *
1653 */
1654 static BOOL SetUrlComponentValueW(LPWSTR* lppszComponent, LPDWORD dwComponentLen, LPCWSTR lpszStart, DWORD len)
1655 {
1656 TRACE("%s (%d)\n", debugstr_wn(lpszStart,len), len);
1657
1658 if ( (*dwComponentLen == 0) && (*lppszComponent == NULL) )
1659 return FALSE;
1660
1661 if (*dwComponentLen != 0 || *lppszComponent == NULL)
1662 {
1663 if (*lppszComponent == NULL)
1664 {
1665 *lppszComponent = (LPWSTR)lpszStart;
1666 *dwComponentLen = len;
1667 }
1668 else
1669 {
1670 DWORD ncpylen = min((*dwComponentLen)-1, len);
1671 memcpy(*lppszComponent, lpszStart, ncpylen*sizeof(WCHAR));
1672 (*lppszComponent)[ncpylen] = '\0';
1673 *dwComponentLen = ncpylen;
1674 }
1675 }
1676
1677 return TRUE;
1678 }
1679
1680 /***********************************************************************
1681 * InternetCrackUrlW (WININET.@)
1682 *
1683 * Break up URL into its components
1684 *
1685 * RETURNS
1686 * TRUE on success
1687 * FALSE on failure
1688 */
1689 BOOL WINAPI InternetCrackUrlW(LPCWSTR lpszUrl_orig, DWORD dwUrlLength_orig, DWORD dwFlags,
1690 LPURL_COMPONENTSW lpUC)
1691 {
1692 /*
1693 * RFC 1808
1694 * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
1695 *
1696 */
1697 LPCWSTR lpszParam = NULL;
1698 BOOL found_colon = FALSE;
1699 LPCWSTR lpszap, lpszUrl = lpszUrl_orig;
1700 LPCWSTR lpszcp = NULL, lpszNetLoc;
1701 LPWSTR lpszUrl_decode = NULL;
1702 DWORD dwUrlLength = dwUrlLength_orig;
1703
1704 TRACE("(%s %u %x %p)\n",
1705 lpszUrl ? debugstr_wn(lpszUrl, dwUrlLength ? dwUrlLength : strlenW(lpszUrl)) : "(null)",
1706 dwUrlLength, dwFlags, lpUC);
1707
1708 if (!lpszUrl_orig || !*lpszUrl_orig || !lpUC)
1709 {
1710 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
1711 return FALSE;
1712 }
1713 if (!dwUrlLength) dwUrlLength = strlenW(lpszUrl);
1714
1715 if (dwFlags & ICU_DECODE)
1716 {
1717 WCHAR *url_tmp;
1718 DWORD len = dwUrlLength + 1;
1719
1720 if (!(url_tmp = heap_alloc(len * sizeof(WCHAR))))
1721 {
1722 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1723 return FALSE;
1724 }
1725 memcpy(url_tmp, lpszUrl_orig, dwUrlLength * sizeof(WCHAR));
1726 url_tmp[dwUrlLength] = 0;
1727 if (!(lpszUrl_decode = heap_alloc(len * sizeof(WCHAR))))
1728 {
1729 heap_free(url_tmp);
1730 INTERNET_SetLastError(ERROR_OUTOFMEMORY);
1731 return FALSE;
1732 }
1733 if (InternetCanonicalizeUrlW(url_tmp, lpszUrl_decode, &len, ICU_DECODE | ICU_NO_ENCODE))
1734 {
1735 dwUrlLength = len;
1736 lpszUrl = lpszUrl_decode;
1737 }
1738 heap_free(url_tmp);
1739 }
1740 lpszap = lpszUrl;
1741
1742 /* Determine if the URI is absolute. */
1743 while (lpszap - lpszUrl < dwUrlLength)
1744 {
1745 if (isalnumW(*lpszap) || *lpszap == '+' || *lpszap == '.' || *lpszap == '-')
1746 {
1747 lpszap++;
1748 continue;
1749 }
1750 if (*lpszap == ':')
1751 {
1752 found_colon = TRUE;
1753 lpszcp = lpszap;
1754 }
1755 else
1756 {
1757 lpszcp = lpszUrl; /* Relative url */
1758 }
1759
1760 break;
1761 }
1762
1763 if(!found_colon){
1764 SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
1765 return 0;
1766 }
1767
1768 lpUC->nScheme = INTERNET_SCHEME_UNKNOWN;
1769 lpUC->nPort = INTERNET_INVALID_PORT_NUMBER;
1770
1771 /* Parse <params> */
1772 lpszParam = memchrW(lpszap, '?', dwUrlLength - (lpszap - lpszUrl));
1773 if(!lpszParam)
1774 lpszParam = memchrW(lpszap, '#', dwUrlLength - (lpszap - lpszUrl));
1775
1776 SetUrlComponentValueW(&lpUC->lpszExtraInfo, &lpUC->dwExtraInfoLength,
1777 lpszParam, lpszParam ? dwUrlLength-(lpszParam-lpszUrl) : 0);
1778
1779
1780 /* Get scheme first. */
1781 lpUC->nScheme = GetInternetSchemeW(lpszUrl, lpszcp - lpszUrl);
1782 SetUrlComponentValueW(&lpUC->lpszScheme, &lpUC->dwSchemeLength,
1783 lpszUrl, lpszcp - lpszUrl);
1784
1785 /* Eat ':' in protocol. */
1786 lpszcp++;
1787
1788 /* double slash indicates the net_loc portion is present */
1789 if ((lpszcp[0] == '/') && (lpszcp[1] == '/'))
1790 {
1791 lpszcp += 2;
1792
1793 lpszNetLoc = memchrW(lpszcp, '/', dwUrlLength - (lpszcp - lpszUrl));
1794 if (lpszParam)
1795 {
1796 if (lpszNetLoc)
1797 lpszNetLoc = min(lpszNetLoc, lpszParam);
1798 else
1799 lpszNetLoc = lpszParam;
1800 }
1801 else if (!lpszNetLoc)
1802 lpszNetLoc = lpszcp + dwUrlLength-(lpszcp-lpszUrl);
1803
1804 /* Parse net-loc */
1805 if (lpszNetLoc)
1806 {
1807 LPCWSTR lpszHost;
1808 LPCWSTR lpszPort;
1809
1810 /* [<user>[<:password>]@]<host>[:<port>] */
1811 /* First find the user and password if they exist */
1812
1813 lpszHost = memchrW(lpszcp, '@', dwUrlLength - (lpszcp - lpszUrl));
1814 if (lpszHost == NULL || lpszHost > lpszNetLoc)
1815 {
1816 /* username and password not specified. */
1817 SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
1818 SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
1819 }
1820 else /* Parse out username and password */
1821 {
1822 LPCWSTR lpszUser = lpszcp;
1823 LPCWSTR lpszPasswd = lpszHost;
1824
1825 while (lpszcp < lpszHost)
1826 {
1827 if (*lpszcp == ':')
1828 lpszPasswd = lpszcp;
1829
1830 lpszcp++;
1831 }
1832
1833 SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength,
1834 lpszUser, lpszPasswd - lpszUser);
1835
1836 if (lpszPasswd != lpszHost)
1837 lpszPasswd++;
1838 SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength,
1839 lpszPasswd == lpszHost ? NULL : lpszPasswd,
1840 lpszHost - lpszPasswd);
1841
1842 lpszcp++; /* Advance to beginning of host */
1843 }
1844
1845 /* Parse <host><:port> */
1846
1847 lpszHost = lpszcp;
1848 lpszPort = lpszNetLoc;
1849
1850 /* special case for res:// URLs: there is no port here, so the host is the
1851 entire string up to the first '/' */
1852 if(lpUC->nScheme==INTERNET_SCHEME_RES)
1853 {
1854 SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
1855 lpszHost, lpszPort - lpszHost);
1856 lpszcp=lpszNetLoc;
1857 }
1858 else
1859 {
1860 while (lpszcp < lpszNetLoc)
1861 {
1862 if (*lpszcp == ':')
1863 lpszPort = lpszcp;
1864
1865 lpszcp++;
1866 }
1867
1868 /* If the scheme is "file" and the host is just one letter, it's not a host */
1869 if(lpUC->nScheme==INTERNET_SCHEME_FILE && lpszPort <= lpszHost+1)
1870 {
1871 lpszcp=lpszHost;
1872 SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
1873 NULL, 0);
1874 }
1875 else
1876 {
1877 SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength,
1878 lpszHost, lpszPort - lpszHost);
1879 if (lpszPort != lpszNetLoc)
1880 lpUC->nPort = atoiW(++lpszPort);
1881 else switch (lpUC->nScheme)
1882 {
1883 case INTERNET_SCHEME_HTTP:
1884 lpUC->nPort = INTERNET_DEFAULT_HTTP_PORT;
1885 break;
1886 case INTERNET_SCHEME_HTTPS:
1887 lpUC->nPort = INTERNET_DEFAULT_HTTPS_PORT;
1888 break;
1889 case INTERNET_SCHEME_FTP:
1890 lpUC->nPort = INTERNET_DEFAULT_FTP_PORT;
1891 break;
1892 case INTERNET_SCHEME_GOPHER:
1893 lpUC->nPort = INTERNET_DEFAULT_GOPHER_PORT;
1894 break;
1895 default:
1896 break;
1897 }
1898 }
1899 }
1900 }
1901 }
1902 else
1903 {
1904 SetUrlComponentValueW(&lpUC->lpszUserName, &lpUC->dwUserNameLength, NULL, 0);
1905 SetUrlComponentValueW(&lpUC->lpszPassword, &lpUC->dwPasswordLength, NULL, 0);
1906 SetUrlComponentValueW(&lpUC->lpszHostName, &lpUC->dwHostNameLength, NULL, 0);
1907 }
1908
1909 /* Here lpszcp points to:
1910 *
1911 * <protocol>:[//<net_loc>][/path][;<params>][?<query>][#<fragment>]
1912 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1913 */
1914 if (lpszcp != 0 && lpszcp - lpszUrl < dwUrlLength && (!lpszParam || lpszcp <= lpszParam))
1915 {
1916 DWORD len;
1917
1918 /* Only truncate the parameter list if it's already been saved
1919 * in lpUC->lpszExtraInfo.
1920 */
1921 if (lpszParam && lpUC->dwExtraInfoLength && lpUC->lpszExtraInfo)
1922 len = lpszParam - lpszcp;
1923 else
1924 {
1925 /* Leave the parameter list in lpszUrlPath. Strip off any trailing
1926 * newlines if necessary.
1927 */
1928 LPWSTR lpsznewline = memchrW(lpszcp, '\n', dwUrlLength - (lpszcp - lpszUrl));
1929 if (lpsznewline != NULL)
1930 len = lpsznewline - lpszcp;
1931 else
1932 len = dwUrlLength-(lpszcp-lpszUrl);
1933 }
1934 if (lpUC->dwUrlPathLength && lpUC->lpszUrlPath &&
1935 lpUC->nScheme == INTERNET_SCHEME_FILE)
1936 {
1937 WCHAR tmppath[MAX_PATH];
1938 if (*lpszcp == '/')
1939 {
1940 len = MAX_PATH;
1941 PathCreateFromUrlW(lpszUrl_orig, tmppath, &len, 0);
1942 }
1943 else
1944 {
1945 WCHAR *iter;
1946 memcpy(tmppath, lpszcp, len * sizeof(WCHAR));
1947 tmppath[len] = '\0';
1948
1949 iter = tmppath;
1950 while (*iter) {
1951 if (*iter == '/')
1952 *iter = '\\';
1953 ++iter;
1954 }
1955 }
1956 /* if ends in \. or \.. append a backslash */
1957 if (tmppath[len - 1] == '.' &&
1958 (tmppath[len - 2] == '\\' ||
1959 (tmppath[len - 2] == '.' && tmppath[len - 3] == '\\')))
1960 {
1961 if (len < MAX_PATH - 1)
1962 {
1963 tmppath[len] = '\\';
1964 tmppath[len+1] = '\0';
1965 ++len;
1966 }
1967 }
1968 SetUrlComponentValueW(&lpUC->lpszUrlPath, &lpUC->dwUrlPathLength,
1969 tmppath, len);
1970 }
1971 else
1972 SetUrlComponentValueW(&lpUC->lpszUrlPath, &lpUC->dwUrlPathLength,
1973 lpszcp, len);
1974 }
1975 else
1976 {
1977 if (lpUC->lpszUrlPath && (lpUC->dwUrlPathLength > 0))
1978 lpUC->lpszUrlPath[0] = 0;
1979 lpUC->dwUrlPathLength = 0;
1980 }
1981
1982 TRACE("%s: scheme(%s) host(%s) path(%s) extra(%s)\n", debugstr_wn(lpszUrl,dwUrlLength),
1983 debugstr_wn(lpUC->lpszScheme,lpUC->dwSchemeLength),
1984 debugstr_wn(lpUC->lpszHostName,lpUC->dwHostNameLength),
1985 debugstr_wn(lpUC->lpszUrlPath,lpUC->dwUrlPathLength),
1986 debugstr_wn(lpUC->lpszExtraInfo,lpUC->dwExtraInfoLength));
1987
1988 heap_free( lpszUrl_decode );
1989 return TRUE;
1990 }
1991
1992 /***********************************************************************
1993 * InternetAttemptConnect (WININET.@)
1994 *
1995 * Attempt to make a connection to the internet
1996 *
1997 * RETURNS
1998 * ERROR_SUCCESS on success
1999 * Error value on failure
2000 *
2001 */
2002 DWORD WINAPI InternetAttemptConnect(DWORD dwReserved)
2003 {
2004 FIXME("Stub\n");
2005 return ERROR_SUCCESS;
2006 }
2007
2008
2009 /***********************************************************************
2010 * convert_url_canonicalization_flags
2011 *
2012 * Helper for InternetCanonicalizeUrl
2013 *
2014 * PARAMS
2015 * dwFlags [I] Flags suitable for InternetCanonicalizeUrl
2016 *
2017 * RETURNS
2018 * Flags suitable for UrlCanonicalize
2019 */
2020 static DWORD convert_url_canonicalization_flags(DWORD dwFlags)
2021 {
2022 DWORD dwUrlFlags = URL_WININET_COMPATIBILITY | URL_ESCAPE_UNSAFE;
2023
2024 if (dwFlags & ICU_BROWSER_MODE) dwUrlFlags |= URL_BROWSER_MODE;
2025 if (dwFlags & ICU_DECODE) dwUrlFlags |= URL_UNESCAPE;
2026 if (dwFlags & ICU_ENCODE_PERCENT) dwUrlFlags |= URL_ESCAPE_PERCENT;
2027 if (dwFlags & ICU_ENCODE_SPACES_ONLY) dwUrlFlags |= URL_ESCAPE_SPACES_ONLY;
2028 /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
2029 if (dwFlags & ICU_NO_ENCODE) dwUrlFlags ^= URL_ESCAPE_UNSAFE;
2030 if (dwFlags & ICU_NO_META) dwUrlFlags |= URL_NO_META;
2031
2032 return dwUrlFlags;
2033 }
2034
2035 /***********************************************************************
2036 * InternetCanonicalizeUrlA (WININET.@)
2037 *
2038 * Escape unsafe characters and spaces
2039 *
2040 * RETURNS
2041 * TRUE on success
2042 * FALSE on failure
2043 *
2044 */
2045 BOOL WINAPI InternetCanonicalizeUrlA(LPCSTR lpszUrl, LPSTR lpszBuffer,
2046 LPDWORD lpdwBufferLength, DWORD dwFlags)
2047 {
2048 HRESULT hr;
2049
2050 TRACE("(%s, %p, %p, 0x%08x) bufferlength: %d\n", debugstr_a(lpszUrl), lpszBuffer,
2051 lpdwBufferLength, dwFlags, lpdwBufferLength ? *lpdwBufferLength : -1);
2052
2053 dwFlags = convert_url_canonicalization_flags(dwFlags);
2054 hr = UrlCanonicalizeA(lpszUrl, lpszBuffer, lpdwBufferLength, dwFlags);
2055 if (hr == E_POINTER) SetLastError(ERROR_INSUFFICIENT_BUFFER);
2056 if (hr == E_INVALIDARG) SetLastError(ERROR_INVALID_PARAMETER);
2057
2058 return hr == S_OK;
2059 }
2060
2061 /***********************************************************************
2062 * InternetCanonicalizeUrlW (WININET.@)
2063 *
2064 * Escape unsafe characters and spaces
2065 *
2066 * RETURNS
2067 * TRUE on success
2068 * FALSE on failure
2069 *
2070 */
2071 BOOL WINAPI InternetCanonicalizeUrlW(LPCWSTR lpszUrl, LPWSTR lpszBuffer,
2072 LPDWORD lpdwBufferLength, DWORD dwFlags)
2073 {
2074 HRESULT hr;
2075
2076 TRACE("(%s, %p, %p, 0x%08x) bufferlength: %d\n", debugstr_w(lpszUrl), lpszBuffer,
2077 lpdwBufferLength, dwFlags, lpdwBufferLength ? *lpdwBufferLength : -1);
2078
2079 dwFlags = convert_url_canonicalization_flags(dwFlags);
2080 hr = UrlCanonicalizeW(lpszUrl, lpszBuffer, lpdwBufferLength, dwFlags);
2081 if (hr == E_POINTER) SetLastError(ERROR_INSUFFICIENT_BUFFER);
2082 if (hr == E_INVALIDARG) SetLastError(ERROR_INVALID_PARAMETER);
2083
2084 return hr == S_OK;
2085 }
2086
2087 /* #################################################### */
2088
2089 static INTERNET_STATUS_CALLBACK set_status_callback(
2090 object_header_t *lpwh, INTERNET_STATUS_CALLBACK callback, BOOL unicode)
2091 {
2092 INTERNET_STATUS_CALLBACK ret;
2093
2094 if (unicode) lpwh->dwInternalFlags |= INET_CALLBACKW;
2095 else lpwh->dwInternalFlags &= ~INET_CALLBACKW;
2096
2097 ret = lpwh->lpfnStatusCB;
2098 lpwh->lpfnStatusCB = callback;
2099
2100 return ret;
2101 }
2102
2103 /***********************************************************************
2104 * InternetSetStatusCallbackA (WININET.@)
2105 *
2106 * Sets up a callback function which is called as progress is made
2107 * during an operation.
2108 *
2109 * RETURNS
2110 * Previous callback or NULL on success
2111 * INTERNET_INVALID_STATUS_CALLBACK on failure
2112 *
2113 */
2114 INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackA(
2115 HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
2116 {
2117 INTERNET_STATUS_CALLBACK retVal;
2118 object_header_t *lpwh;
2119
2120 TRACE("%p\n", hInternet);
2121
2122 if (!(lpwh = get_handle_object(hInternet)))
2123 return INTERNET_INVALID_STATUS_CALLBACK;
2124
2125 retVal = set_status_callback(lpwh, lpfnIntCB, FALSE);
2126
2127 WININET_Release( lpwh );
2128 return retVal;
2129 }
2130
2131 /***********************************************************************
2132 * InternetSetStatusCallbackW (WININET.@)
2133 *
2134 * Sets up a callback function which is called as progress is made
2135 * during an operation.
2136 *
2137 * RETURNS
2138 * Previous callback or NULL on success
2139 * INTERNET_INVALID_STATUS_CALLBACK on failure
2140 *
2141 */
2142 INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackW(
2143 HINTERNET hInternet ,INTERNET_STATUS_CALLBACK lpfnIntCB)
2144 {
2145 INTERNET_STATUS_CALLBACK retVal;
2146 object_header_t *lpwh;
2147
2148 TRACE("%p\n", hInternet);
2149
2150 if (!(lpwh = get_handle_object(hInternet)))
2151 return INTERNET_INVALID_STATUS_CALLBACK;
2152
2153 retVal = set_status_callback(lpwh, lpfnIntCB, TRUE);
2154
2155 WININET_Release( lpwh );
2156 return retVal;
2157 }
2158
2159 /***********************************************************************
2160 * InternetSetFilePointer (WININET.@)
2161 */
2162 DWORD WINAPI InternetSetFilePointer(HINTERNET hFile, LONG lDistanceToMove,
2163 PVOID pReserved, DWORD dwMoveContext, DWORD_PTR dwContext)
2164 {
2165 FIXME("(%p %d %p %d %lx): stub\n", hFile, lDistanceToMove, pReserved, dwMoveContext, dwContext);
2166 return FALSE;
2167 }
2168
2169 /***********************************************************************
2170 * InternetWriteFile (WININET.@)
2171 *
2172 * Write data to an open internet file
2173 *
2174 * RETURNS
2175 * TRUE on success
2176 * FALSE on failure
2177 *
2178 */
2179 BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer,
2180 DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
2181 {
2182 object_header_t *lpwh;
2183 BOOL res;
2184
2185 TRACE("(%p %p %d %p)\n", hFile, lpBuffer, dwNumOfBytesToWrite, lpdwNumOfBytesWritten);
2186
2187 lpwh = get_handle_object( hFile );
2188 if (!lpwh) {
2189 WARN("Invalid handle\n");
2190 SetLastError(ERROR_INVALID_HANDLE);
2191 return FALSE;
2192 }
2193
2194 if(lpwh->vtbl->WriteFile) {
2195 res = lpwh->vtbl->WriteFile(lpwh, lpBuffer, dwNumOfBytesToWrite, lpdwNumOfBytesWritten);
2196 }else {
2197 WARN("No Writefile method.\n");
2198 res = ERROR_INVALID_HANDLE;
2199 }
2200
2201 WININET_Release( lpwh );
2202
2203 if(res != ERROR_SUCCESS)
2204 SetLastError(res);
2205 return res == ERROR_SUCCESS;
2206 }
2207
2208
2209 /***********************************************************************
2210 * InternetReadFile (WININET.@)
2211 *
2212 * Read data from an open internet file
2213 *
2214 * RETURNS
2215 * TRUE on success
2216 * FALSE on failure
2217 *
2218 */
2219 BOOL WINAPI InternetReadFile(HINTERNET hFile, LPVOID lpBuffer,
2220 DWORD dwNumOfBytesToRead, LPDWORD pdwNumOfBytesRead)
2221 {
2222 object_header_t *hdr;
2223 DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2224
2225 TRACE("%p %p %d %p\n", hFile, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead);
2226
2227 hdr = get_handle_object(hFile);
2228 if (!hdr) {
2229 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2230 return FALSE;
2231 }
2232
2233 if(hdr->vtbl->ReadFile)
2234 res = hdr->vtbl->ReadFile(hdr, lpBuffer, dwNumOfBytesToRead, pdwNumOfBytesRead);
2235
2236 WININET_Release(hdr);
2237
2238 TRACE("-- %s (%u) (bytes read: %d)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE", res,
2239 pdwNumOfBytesRead ? *pdwNumOfBytesRead : -1);
2240
2241 if(res != ERROR_SUCCESS)
2242 SetLastError(res);
2243 return res == ERROR_SUCCESS;
2244 }
2245
2246 /***********************************************************************
2247 * InternetReadFileExA (WININET.@)
2248 *
2249 * Read data from an open internet file
2250 *
2251 * PARAMS
2252 * hFile [I] Handle returned by InternetOpenUrl or HttpOpenRequest.
2253 * lpBuffersOut [I/O] Buffer.
2254 * dwFlags [I] Flags. See notes.
2255 * dwContext [I] Context for callbacks.
2256 *
2257 * RETURNS
2258 * TRUE on success
2259 * FALSE on failure
2260 *
2261 * NOTES
2262 * The parameter dwFlags include zero or more of the following flags:
2263 *|IRF_ASYNC - Makes the call asynchronous.
2264 *|IRF_SYNC - Makes the call synchronous.
2265 *|IRF_USE_CONTEXT - Forces dwContext to be used.
2266 *|IRF_NO_WAIT - Don't block if the data is not available, just return what is available.
2267 *
2268 * However, in testing IRF_USE_CONTEXT seems to have no effect - dwContext isn't used.
2269 *
2270 * SEE
2271 * InternetOpenUrlA(), HttpOpenRequestA()
2272 */
2273 BOOL WINAPI InternetReadFileExA(HINTERNET hFile, LPINTERNET_BUFFERSA lpBuffersOut,
2274 DWORD dwFlags, DWORD_PTR dwContext)
2275 {
2276 object_header_t *hdr;
2277 DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2278
2279 TRACE("(%p %p 0x%x 0x%lx)\n", hFile, lpBuffersOut, dwFlags, dwContext);
2280
2281 if (lpBuffersOut->dwStructSize != sizeof(*lpBuffersOut)) {
2282 SetLastError(ERROR_INVALID_PARAMETER);
2283 return FALSE;
2284 }
2285
2286 hdr = get_handle_object(hFile);
2287 if (!hdr) {
2288 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2289 return FALSE;
2290 }
2291
2292 if(hdr->vtbl->ReadFileEx)
2293 res = hdr->vtbl->ReadFileEx(hdr, lpBuffersOut->lpvBuffer, lpBuffersOut->dwBufferLength,
2294 &lpBuffersOut->dwBufferLength, dwFlags, dwContext);
2295
2296 WININET_Release(hdr);
2297
2298 TRACE("-- %s (%u, bytes read: %d)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE",
2299 res, lpBuffersOut->dwBufferLength);
2300
2301 if(res != ERROR_SUCCESS)
2302 SetLastError(res);
2303 return res == ERROR_SUCCESS;
2304 }
2305
2306 /***********************************************************************
2307 * InternetReadFileExW (WININET.@)
2308 * SEE
2309 * InternetReadFileExA()
2310 */
2311 BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer,
2312 DWORD dwFlags, DWORD_PTR dwContext)
2313 {
2314 object_header_t *hdr;
2315 DWORD res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2316
2317 TRACE("(%p %p 0x%x 0x%lx)\n", hFile, lpBuffer, dwFlags, dwContext);
2318
2319 if (lpBuffer->dwStructSize != sizeof(*lpBuffer)) {
2320 SetLastError(ERROR_INVALID_PARAMETER);
2321 return FALSE;
2322 }
2323
2324 hdr = get_handle_object(hFile);
2325 if (!hdr) {
2326 INTERNET_SetLastError(ERROR_INVALID_HANDLE);
2327 return FALSE;
2328 }
2329
2330 if(hdr->vtbl->ReadFileEx)
2331 res = hdr->vtbl->ReadFileEx(hdr, lpBuffer->lpvBuffer, lpBuffer->dwBufferLength, &lpBuffer->dwBufferLength,
2332 dwFlags, dwContext);
2333
2334 WININET_Release(hdr);
2335
2336 TRACE("-- %s (%u, bytes read: %d)\n", res == ERROR_SUCCESS ? "TRUE": "FALSE",
2337 res, lpBuffer->dwBufferLength);
2338
2339 if(res != ERROR_SUCCESS)
2340 SetLastError(res);
2341 return res == ERROR_SUCCESS;
2342 }
2343
2344 static DWORD query_global_option(DWORD option, void *buffer, DWORD *size, BOOL unicode)
2345 {
2346 /* FIXME: This function currently handles more options than it should. Options requiring
2347 * proper handles should be moved to proper functions */
2348 switch(option) {
2349 case INTERNET_OPTION_HTTP_VERSION:
2350 if (*size < sizeof(HTTP_VERSION_INFO))
2351 return ERROR_INSUFFICIENT_BUFFER;
2352
2353 /*
2354 * Presently hardcoded to 1.1
2355 */
2356 ((HTTP_VERSION_INFO*)buffer)->dwMajorVersion = 1;
2357 ((HTTP_VERSION_INFO*)buffer)->dwMinorVersion = 1;
2358 *size = sizeof(HTTP_VERSION_INFO);
2359
2360 return ERROR_SUCCESS;
2361
2362 case INTERNET_OPTION_CONNECTED_STATE:
2363 FIXME("INTERNET_OPTION_CONNECTED_STATE: semi-stub\n");
2364
2365 if (*size < sizeof(ULONG))
2366 return ERROR_INSUFFICIENT_BUFFER;
2367
2368 *(ULONG*)buffer = INTERNET_STATE_CONNECTED;
2369 *size = sizeof(ULONG);
2370
2371 return ERROR_SUCCESS;
2372
2373 case INTERNET_OPTION_PROXY: {
2374 appinfo_t ai;
2375 BOOL ret;
2376
2377 TRACE("Getting global proxy info\n");
2378 memset(&ai, 0, sizeof(appinfo_t));
2379 INTERNET_ConfigureProxy(&ai);
2380
2381 ret = APPINFO_QueryOption(&ai.hdr, INTERNET_OPTION_PROXY, buffer, size, unicode); /* FIXME */
2382 APPINFO_Destroy(&ai.hdr);
2383 return ret;
2384 }
2385
2386 case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2387 TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER\n");
2388
2389 if (*size < sizeof(ULONG))
2390 return ERROR_INSUFFICIENT_BUFFER;
2391
2392 *(ULONG*)buffer = max_conns;
2393 *size = sizeof(ULONG);
2394
2395 return ERROR_SUCCESS;
2396
2397 case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2398 TRACE("INTERNET_OPTION_MAX_CONNS_1_0_SERVER\n");
2399
2400 if (*size < sizeof(ULONG))
2401 return ERROR_INSUFFICIENT_BUFFER;
2402
2403 *(ULONG*)buffer = max_1_0_conns;
2404 *size = sizeof(ULONG);
2405
2406 return ERROR_SUCCESS;
2407
2408 case INTERNET_OPTION_SECURITY_FLAGS:
2409 FIXME("INTERNET_OPTION_SECURITY_FLAGS: Stub\n");
2410 return ERROR_SUCCESS;
2411
2412 case INTERNET_OPTION_VERSION: {
2413 static const INTERNET_VERSION_INFO info = { 1, 2 };
2414
2415 TRACE("INTERNET_OPTION_VERSION\n");
2416
2417 if (*size < sizeof(INTERNET_VERSION_INFO))
2418 return ERROR_INSUFFICIENT_BUFFER;
2419
2420 memcpy(buffer, &info, sizeof(info));
2421 *size = sizeof(info);
2422
2423 return ERROR_SUCCESS;
2424 }
2425
2426 case INTERNET_OPTION_PER_CONNECTION_OPTION: {
2427 INTERNET_PER_CONN_OPTION_LISTW *con = buffer;
2428 INTERNET_PER_CONN_OPTION_LISTA *conA = buffer;
2429 DWORD res = ERROR_SUCCESS, i;
2430 proxyinfo_t pi;
2431 LONG ret;
2432
2433 TRACE("Getting global proxy info\n");
2434 if((ret = INTERNET_LoadProxySettings(&pi)))
2435 return ret;
2436
2437 FIXME("INTERNET_OPTION_PER_CONNECTION_OPTION stub\n");
2438
2439 if (*size < sizeof(INTERNET_PER_CONN_OPTION_LISTW)) {
2440 FreeProxyInfo(&pi);
2441 return ERROR_INSUFFICIENT_BUFFER;
2442 }
2443
2444 for (i = 0; i < con->dwOptionCount; i++) {
2445 INTERNET_PER_CONN_OPTIONW *optionW = con->pOptions + i;
2446 INTERNET_PER_CONN_OPTIONA *optionA = conA->pOptions + i;
2447
2448 switch (optionW->dwOption) {
2449 case INTERNET_PER_CONN_FLAGS:
2450 if(pi.proxyEnabled)
2451 optionW->Value.dwValue = PROXY_TYPE_PROXY;
2452 else
2453 optionW->Value.dwValue = PROXY_TYPE_DIRECT;
2454 break;
2455
2456 case INTERNET_PER_CONN_PROXY_SERVER:
2457 if (unicode)
2458 optionW->Value.pszValue = heap_strdupW(pi.proxy);
2459 else
2460 optionA->Value.pszValue = heap_strdupWtoA(pi.proxy);
2461 break;
2462
2463 case INTERNET_PER_CONN_PROXY_BYPASS:
2464 if (unicode)
2465 optionW->Value.pszValue = heap_strdupW(pi.proxyBypass);
2466 else
2467 optionA->Value.pszValue = heap_strdupWtoA(pi.proxyBypass);
2468 break;
2469
2470 case INTERNET_PER_CONN_AUTOCONFIG_URL:
2471 case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
2472 case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
2473 case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
2474 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
2475 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
2476 FIXME("Unhandled dwOption %d\n", optionW->dwOption);
2477 memset(&optionW->Value, 0, sizeof(optionW->Value));
2478 break;
2479
2480 default:
2481 FIXME("Unknown dwOption %d\n", optionW->dwOption);
2482 res = ERROR_INVALID_PARAMETER;
2483 break;
2484 }
2485 }
2486 FreeProxyInfo(&pi);
2487
2488 return res;
2489 }
2490 case INTERNET_OPTION_REQUEST_FLAGS:
2491 case INTERNET_OPTION_USER_AGENT:
2492 *size = 0;
2493 return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2494 case INTERNET_OPTION_POLICY:
2495 return ERROR_INVALID_PARAMETER;
2496 case INTERNET_OPTION_CONNECT_TIMEOUT:
2497 TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
2498
2499 if (*size < sizeof(ULONG))
2500 return ERROR_INSUFFICIENT_BUFFER;
2501
2502 *(ULONG*)buffer = connect_timeout;
2503 *size = sizeof(ULONG);
2504
2505 return ERROR_SUCCESS;
2506 }
2507
2508 FIXME("Stub for %d\n", option);
2509 return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2510 }
2511
2512 DWORD INET_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
2513 {
2514 switch(option) {
2515 case INTERNET_OPTION_CONTEXT_VALUE:
2516 if (!size)
2517 return ERROR_INVALID_PARAMETER;
2518
2519 if (*size < sizeof(DWORD_PTR)) {
2520 *size = sizeof(DWORD_PTR);
2521 return ERROR_INSUFFICIENT_BUFFER;
2522 }
2523 if (!buffer)
2524 return ERROR_INVALID_PARAMETER;
2525
2526 *(DWORD_PTR *)buffer = hdr->dwContext;
2527 *size = sizeof(DWORD_PTR);
2528 return ERROR_SUCCESS;
2529
2530 case INTERNET_OPTION_REQUEST_FLAGS:
2531 WARN("INTERNET_OPTION_REQUEST_FLAGS\n");
2532 *size = sizeof(DWORD);
2533 return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2534
2535 case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2536 case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2537 WARN("Called on global option %u\n", option);
2538 return ERROR_INTERNET_INVALID_OPERATION;
2539 }
2540
2541 /* FIXME: we shouldn't call it here */
2542 return query_global_option(option, buffer, size, unicode);
2543 }
2544
2545 /***********************************************************************
2546 * InternetQueryOptionW (WININET.@)
2547 *
2548 * Queries an options on the specified handle
2549 *
2550 * RETURNS
2551 * TRUE on success
2552 * FALSE on failure
2553 *
2554 */
2555 BOOL WINAPI InternetQueryOptionW(HINTERNET hInternet, DWORD dwOption,
2556 LPVOID lpBuffer, LPDWORD lpdwBufferLength)
2557 {
2558 object_header_t *hdr;
2559 DWORD res = ERROR_INVALID_HANDLE;
2560
2561 TRACE("%p %d %p %p\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
2562
2563 if(hInternet) {
2564 hdr = get_handle_object(hInternet);
2565 if (hdr) {
2566 res = hdr->vtbl->QueryOption(hdr, dwOption, lpBuffer, lpdwBufferLength, TRUE);
2567 WININET_Release(hdr);
2568 }
2569 }else {
2570 res = query_global_option(dwOption, lpBuffer, lpdwBufferLength, TRUE);
2571 }
2572
2573 if(res != ERROR_SUCCESS)
2574 SetLastError(res);
2575 return res == ERROR_SUCCESS;
2576 }
2577
2578 /***********************************************************************
2579 * InternetQueryOptionA (WININET.@)
2580 *
2581 * Queries an options on the specified handle
2582 *
2583 * RETURNS
2584 * TRUE on success
2585 * FALSE on failure
2586 *
2587 */
2588 BOOL WINAPI InternetQueryOptionA(HINTERNET hInternet, DWORD dwOption,
2589 LPVOID lpBuffer, LPDWORD lpdwBufferLength)
2590 {
2591 object_header_t *hdr;
2592 DWORD res = ERROR_INVALID_HANDLE;
2593
2594 TRACE("%p %d %p %p\n", hInternet, dwOption, lpBuffer, lpdwBufferLength);
2595
2596 if(hInternet) {
2597 hdr = get_handle_object(hInternet);
2598 if (hdr) {
2599 res = hdr->vtbl->QueryOption(hdr, dwOption, lpBuffer, lpdwBufferLength, FALSE);
2600 WININET_Release(hdr);
2601 }
2602 }else {
2603 res = query_global_option(dwOption, lpBuffer, lpdwBufferLength, FALSE);
2604 }
2605
2606 if(res != ERROR_SUCCESS)
2607 SetLastError(res);
2608 return res == ERROR_SUCCESS;
2609 }
2610
2611 DWORD INET_SetOption(object_header_t *hdr, DWORD option, void *buf, DWORD size)
2612 {
2613 switch(option) {
2614 case INTERNET_OPTION_CALLBACK:
2615 WARN("Not settable option %u\n", option);
2616 return ERROR_INTERNET_OPTION_NOT_SETTABLE;
2617 case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2618 case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2619 WARN("Called on global option %u\n", option);
2620 return ERROR_INTERNET_INVALID_OPERATION;
2621 }
2622
2623 return ERROR_INTERNET_INVALID_OPTION;
2624 }
2625
2626 static DWORD set_global_option(DWORD option, void *buf, DWORD size)
2627 {
2628 switch(option) {
2629 case INTERNET_OPTION_CALLBACK:
2630 WARN("Not global option %u\n", option);
2631 return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
2632
2633 case INTERNET_OPTION_MAX_CONNS_PER_SERVER:
2634 TRACE("INTERNET_OPTION_MAX_CONNS_PER_SERVER\n");
2635
2636 if(size != sizeof(max_conns))
2637 return ERROR_INTERNET_BAD_OPTION_LENGTH;
2638 if(!*(ULONG*)buf)
2639 return ERROR_BAD_ARGUMENTS;
2640
2641 max_conns = *(ULONG*)buf;
2642 return ERROR_SUCCESS;
2643
2644 case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
2645 TRACE("INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER\n");
2646
2647 if(size != sizeof(max_1_0_conns))
2648 return ERROR_INTERNET_BAD_OPTION_LENGTH;
2649 if(!*(ULONG*)buf)
2650 return ERROR_BAD_ARGUMENTS;
2651
2652 max_1_0_conns = *(ULONG*)buf;
2653 return ERROR_SUCCESS;
2654
2655 case INTERNET_OPTION_CONNECT_TIMEOUT:
2656 TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
2657
2658 if(size != sizeof(connect_timeout))
2659 return ERROR_INTERNET_BAD_OPTION_LENGTH;
2660 if(!*(ULONG*)buf)
2661 return ERROR_BAD_ARGUMENTS;
2662
2663 connect_timeout = *(ULONG*)buf;
2664 return ERROR_SUCCESS;
2665
2666 case INTERNET_OPTION_SETTINGS_CHANGED:
2667 FIXME("INTERNETOPTION_SETTINGS_CHANGED semi-stub\n");
2668 collect_connections(COLLECT_CONNECTIONS);
2669 return ERROR_SUCCESS;
2670 }
2671
2672 return ERROR_INTERNET_INVALID_OPTION;
2673 }
2674
2675 /***********************************************************************
2676 * InternetSetOptionW (WININET.@)
2677 *
2678 * Sets an options on the specified handle
2679 *
2680 * RETURNS
2681 * TRUE on success
2682 * FALSE on failure
2683 *
2684 */
2685 BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
2686 LPVOID lpBuffer, DWORD dwBufferLength)
2687 {
2688 object_header_t *lpwhh;
2689 BOOL ret = TRUE;
2690 DWORD res;
2691
2692 TRACE("(%p %d %p %d)\n", hInternet, dwOption, lpBuffer, dwBufferLength);
2693
2694 lpwhh = (object_header_t*) get_handle_object( hInternet );
2695 if(lpwhh)
2696 res = lpwhh->vtbl->SetOption(lpwhh, dwOption, lpBuffer, dwBufferLength);
2697 else
2698 res = set_global_option(dwOption, lpBuffer, dwBufferLength);
2699
2700 if(res != ERROR_INTERNET_INVALID_OPTION) {
2701 if(lpwhh)
2702 WININET_Release(lpwhh);
2703
2704 if(res != ERROR_SUCCESS)
2705 SetLastError(res);
2706
2707 return res == ERROR_SUCCESS;
2708 }
2709
2710 switch (dwOption)
2711 {
2712 case INTERNET_OPTION_HTTP_VERSION:
2713 {
2714 HTTP_VERSION_INFO* pVersion=(HTTP_VERSION_INFO*)lpBuffer;
2715 FIXME("Option INTERNET_OPTION_HTTP_VERSION(%d,%d): STUB\n",pVersion->dwMajorVersion,pVersion->dwMinorVersion);
2716 }
2717 break;
2718 case INTERNET_OPTION_ERROR_MASK:
2719 {
2720 if(!lpwhh) {
2721 SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2722 return FALSE;
2723 } else if(*(ULONG*)lpBuffer & (~(INTERNET_ERROR_MASK_INSERT_CDROM|
2724 INTERNET_ERROR_MASK_COMBINED_SEC_CERT|
2725 INTERNET_ERROR_MASK_LOGIN_FAILURE_DISPLAY_ENTITY_BODY))) {
2726 SetLastError(ERROR_INVALID_PARAMETER);
2727 ret = FALSE;
2728 } else if(dwBufferLength != sizeof(ULONG)) {
2729 SetLastError(ERROR_INTERNET_BAD_OPTION_LENGTH);
2730 ret = FALSE;
2731 } else
2732 TRACE("INTERNET_OPTION_ERROR_MASK: %x\n", *(ULONG*)lpBuffer);
2733 lpwhh->ErrorMask = *(ULONG*)lpBuffer;
2734 }
2735 break;
2736 case INTERNET_OPTION_PROXY:
2737 {
2738 INTERNET_PROXY_INFOW *info = lpBuffer;
2739
2740 if (!lpBuffer || dwBufferLength < sizeof(INTERNET_PROXY_INFOW))
2741 {
2742 SetLastError(ERROR_INVALID_PARAMETER);
2743 return FALSE;
2744 }
2745 if (!hInternet)
2746 {
2747 EnterCriticalSection( &WININET_cs );
2748 free_global_proxy();
2749 global_proxy = heap_alloc( sizeof(proxyinfo_t) );
2750 if (global_proxy)
2751 {
2752 if (info->dwAccessType == INTERNET_OPEN_TYPE_PROXY)
2753 {
2754 global_proxy->proxyEnabled = 1;
2755 global_proxy->proxy = heap_strdupW( info->lpszProxy );
2756 global_proxy->proxyBypass = heap_strdupW( info->lpszProxyBypass );
2757 }
2758 else
2759 {
2760 global_proxy->proxyEnabled = 0;
2761 global_proxy->proxy = global_proxy->proxyBypass = NULL;
2762 }
2763 }
2764 LeaveCriticalSection( &WININET_cs );
2765 }
2766 else
2767 {
2768 /* In general, each type of object should handle
2769 * INTERNET_OPTION_PROXY directly. This FIXME ensures it doesn't
2770 * get silently dropped.
2771 */
2772 FIXME("INTERNET_OPTION_PROXY unimplemented\n");
2773 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2774 ret = FALSE;
2775 }
2776 break;
2777 }
2778 case INTERNET_OPTION_CODEPAGE:
2779 {
2780 ULONG codepage = *(ULONG *)lpBuffer;
2781 FIXME("Option INTERNET_OPTION_CODEPAGE (%d): STUB\n", codepage);
2782 }
2783 break;
2784 case INTERNET_OPTION_REQUEST_PRIORITY:
2785 {
2786 ULONG priority = *(ULONG *)lpBuffer;
2787 FIXME("Option INTERNET_OPTION_REQUEST_PRIORITY (%d): STUB\n", priority);
2788 }
2789 break;
2790 case INTERNET_OPTION_CONNECT_TIMEOUT:
2791 {
2792 ULONG connecttimeout = *(ULONG *)lpBuffer;
2793 FIXME("Option INTERNET_OPTION_CONNECT_TIMEOUT (%d): STUB\n", connecttimeout);
2794 }
2795 break;
2796 case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
2797 {
2798 ULONG receivetimeout = *(ULONG *)lpBuffer;
2799 FIXME("Option INTERNET_OPTION_DATA_RECEIVE_TIMEOUT (%d): STUB\n", receivetimeout);
2800 }
2801 break;
2802 case INTERNET_OPTION_RESET_URLCACHE_SESSION:
2803 FIXME("Option INTERNET_OPTION_RESET_URLCACHE_SESSION: STUB\n");
2804 break;
2805 case INTERNET_OPTION_END_BROWSER_SESSION:
2806 FIXME("Option INTERNET_OPTION_END_BROWSER_SESSION: STUB\n");
2807 break;
2808 case INTERNET_OPTION_CONNECTED_STATE:
2809 FIXME("Option INTERNET_OPTION_CONNECTED_STATE: STUB\n");
2810 break;
2811 case INTERNET_OPTION_DISABLE_PASSPORT_AUTH:
2812 TRACE("Option INTERNET_OPTION_DISABLE_PASSPORT_AUTH: harmless stub, since not enabled\n");
2813 break;
2814 case INTERNET_OPTION_SEND_TIMEOUT:
2815 case INTERNET_OPTION_RECEIVE_TIMEOUT:
2816 case INTERNET_OPTION_DATA_SEND_TIMEOUT:
2817 {
2818 ULONG timeout = *(ULONG *)lpBuffer;
2819 FIXME("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT/DATA_SEND_TIMEOUT %d\n", timeout);
2820 break;
2821 }
2822 case INTERNET_OPTION_CONNECT_RETRIES:
2823 {
2824 ULONG retries = *(ULONG *)lpBuffer;
2825 FIXME("INTERNET_OPTION_CONNECT_RETRIES %d\n", retries);
2826 break;
2827 }
2828 case INTERNET_OPTION_CONTEXT_VALUE:
2829 {
2830 if (!lpwhh)
2831 {
2832 SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
2833 return FALSE;
2834 }
2835 if (!lpBuffer || dwBufferLength != sizeof(DWORD_PTR))
2836 {
2837 SetLastError(ERROR_INVALID_PARAMETER);
2838 ret = FALSE;
2839 }
2840 else
2841 lpwhh->dwContext = *(DWORD_PTR *)lpBuffer;
2842 break;
2843 }
2844 case INTERNET_OPTION_SECURITY_FLAGS:
2845 FIXME("Option INTERNET_OPTION_SECURITY_FLAGS; STUB\n");
2846 break;
2847 case INTERNET_OPTION_DISABLE_AUTODIAL:
2848 FIXME("Option INTERNET_OPTION_DISABLE_AUTODIAL; STUB\n");
2849 break;
2850 case INTERNET_OPTION_HTTP_DECODING:
2851 FIXME("INTERNET_OPTION_HTTP_DECODING; STUB\n");
2852 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2853 ret = FALSE;
2854 break;
2855 case INTERNET_OPTION_COOKIES_3RD_PARTY:
2856 FIXME("INTERNET_OPTION_COOKIES_3RD_PARTY; STUB\n");
2857 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2858 ret = FALSE;
2859 break;
2860 case INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY:
2861 FIXME("INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY; STUB\n");
2862 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2863 ret = FALSE;
2864 break;
2865 case INTERNET_OPTION_CODEPAGE_PATH:
2866 FIXME("INTERNET_OPTION_CODEPAGE_PATH; STUB\n");
2867 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2868 ret = FALSE;
2869 break;
2870 case INTERNET_OPTION_CODEPAGE_EXTRA:
2871 FIXME("INTERNET_OPTION_CODEPAGE_EXTRA; STUB\n");
2872 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2873 ret = FALSE;
2874 break;
2875 case INTERNET_OPTION_IDN:
2876 FIXME("INTERNET_OPTION_IDN; STUB\n");
2877 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2878 ret = FALSE;
2879 break;
2880 case INTERNET_OPTION_POLICY:
2881 SetLastError(ERROR_INVALID_PARAMETER);
2882 ret = FALSE;
2883 break;
2884 case INTERNET_OPTION_PER_CONNECTION_OPTION: {
2885 INTERNET_PER_CONN_OPTION_LISTW *con = lpBuffer;
2886 LONG res;
2887 unsigned int i;
2888 proxyinfo_t pi;
2889
2890 INTERNET_LoadProxySettings(&pi);
2891
2892 for (i = 0; i < con->dwOptionCount; i++) {
2893 INTERNET_PER_CONN_OPTIONW *option = con->pOptions + i;
2894
2895 switch (option->dwOption) {
2896 case INTERNET_PER_CONN_PROXY_SERVER:
2897 heap_free(pi.proxy);
2898 pi.proxy = heap_strdupW(option->Value.pszValue);
2899 break;
2900
2901 case INTERNET_PER_CONN_FLAGS:
2902 if(option->Value.dwValue & PROXY_TYPE_PROXY)
2903 pi.proxyEnabled = 1;
2904 else
2905 {
2906 if(option->Value.dwValue != PROXY_TYPE_DIRECT)
2907 FIXME("Unhandled flags: 0x%x\n", option->Value.dwValue);
2908 pi.proxyEnabled = 0;
2909 }
2910 break;
2911
2912 case INTERNET_PER_CONN_AUTOCONFIG_URL:
2913 case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
2914 case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
2915 case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
2916 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
2917 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
2918 case INTERNET_PER_CONN_PROXY_BYPASS:
2919 FIXME("Unhandled dwOption %d\n", option->dwOption);
2920 break;
2921
2922 default:
2923 FIXME("Unknown dwOption %d\n", option->dwOption);
2924 SetLastError(ERROR_INVALID_PARAMETER);
2925 break;
2926 }
2927 }
2928
2929 if ((res = INTERNET_SaveProxySettings(&pi)))
2930 SetLastError(res);
2931
2932 FreeProxyInfo(&pi);
2933
2934 ret = (res == ERROR_SUCCESS);
2935 break;
2936 }
2937 default:
2938 FIXME("Option %d STUB\n",dwOption);
2939 SetLastError(ERROR_INTERNET_INVALID_OPTION);
2940 ret = FALSE;
2941 break;
2942 }
2943
2944 if(lpwhh)
2945 WININET_Release( lpwhh );
2946
2947 return ret;
2948 }
2949
2950
2951 /***********************************************************************
2952 * InternetSetOptionA (WININET.@)
2953 *
2954 * Sets an options on the specified handle.
2955 *
2956 * RETURNS
2957 * TRUE on success
2958 * FALSE on failure
2959 *
2960 */
2961 BOOL WINAPI InternetSetOptionA(HINTERNET hInternet, DWORD dwOption,
2962 LPVOID lpBuffer, DWORD dwBufferLength)
2963 {
2964 LPVOID wbuffer;
2965 DWORD wlen;
2966 BOOL r;
2967
2968 switch( dwOption )
2969 {
2970 case INTERNET_OPTION_PROXY:
2971 {
2972 LPINTERNET_PROXY_INFOA pi = (LPINTERNET_PROXY_INFOA) lpBuffer;
2973 LPINTERNET_PROXY_INFOW piw;
2974 DWORD proxlen, prbylen;
2975 LPWSTR prox, prby;
2976
2977 proxlen = MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, NULL, 0);
2978 prbylen= MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, NULL, 0);
2979 wlen = sizeof(*piw) + proxlen + prbylen;
2980 wbuffer = heap_alloc(wlen*sizeof(WCHAR) );
2981 piw = (LPINTERNET_PROXY_INFOW) wbuffer;
2982 piw->dwAccessType = pi->dwAccessType;
2983 prox = (LPWSTR) &piw[1];
2984 prby = &prox[proxlen+1];
2985 MultiByteToWideChar( CP_ACP, 0, pi->lpszProxy, -1, prox, proxlen);
2986 MultiByteToWideChar( CP_ACP, 0, pi->lpszProxyBypass, -1, prby, prbylen);
2987 piw->lpszProxy = prox;
2988 piw->lpszProxyBypass = prby;
2989 }
2990 break;
2991 case INTERNET_OPTION_USER_AGENT:
2992 case INTERNET_OPTION_USERNAME:
2993 case INTERNET_OPTION_PASSWORD:
2994 case INTERNET_OPTION_PROXY_USERNAME:
2995 case INTERNET_OPTION_PROXY_PASSWORD:
2996 wlen = MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, NULL, 0 );
2997 if (!(wbuffer = heap_alloc( wlen * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
2998 MultiByteToWideChar( CP_ACP, 0, lpBuffer, -1, wbuffer, wlen );
2999 break;
3000 case INTERNET_OPTION_PER_CONNECTION_OPTION: {
3001 unsigned int i;
3002 INTERNET_PER_CONN_OPTION_LISTW *listW;
3003 INTERNET_PER_CONN_OPTION_LISTA *listA = lpBuffer;
3004 wlen = sizeof(INTERNET_PER_CONN_OPTION_LISTW);
3005 wbuffer = heap_alloc(wlen);
3006 listW = wbuffer;
3007
3008 listW->dwSize = sizeof(INTERNET_PER_CONN_OPTION_LISTW);
3009 if (listA->pszConnection)
3010 {
3011 wlen = MultiByteToWideChar( CP_ACP, 0, listA->pszConnection, -1, NULL, 0 );
3012 listW->pszConnection = heap_alloc(wlen*sizeof(WCHAR));
3013 MultiByteToWideChar( CP_ACP, 0, listA->pszConnection, -1, listW->pszConnection, wlen );
3014 }
3015 else
3016 listW->pszConnection = NULL;
3017 listW->dwOptionCount = listA->dwOptionCount;
3018 listW->dwOptionError = listA->dwOptionError;
3019 listW->pOptions = heap_alloc(sizeof(INTERNET_PER_CONN_OPTIONW) * listA->dwOptionCount);
3020
3021 for (i = 0; i < listA->dwOptionCount; ++i) {
3022 INTERNET_PER_CONN_OPTIONA *optA = listA->pOptions + i;
3023 INTERNET_PER_CONN_OPTIONW *optW = listW->pOptions + i;
3024
3025 optW->dwOption = optA->dwOption;
3026
3027 switch (optA->dwOption) {
3028 case INTERNET_PER_CONN_AUTOCONFIG_URL:
3029 case INTERNET_PER_CONN_PROXY_BYPASS:
3030 case INTERNET_PER_CONN_PROXY_SERVER:
3031 case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
3032 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
3033 if (optA->Value.pszValue)
3034 {
3035 wlen = MultiByteToWideChar( CP_ACP, 0, optA->Value.pszValue, -1, NULL, 0 );
3036 optW->Value.pszValue = heap_alloc(wlen*sizeof(WCHAR));
3037 MultiByteToWideChar( CP_ACP, 0, optA->Value.pszValue, -1, optW->Value.pszValue, wlen );
3038 }
3039 else
3040 optW->Value.pszValue = NULL;
3041 break;
3042 case INTERNET_PER_CONN_AUTODISCOVERY_FLAGS:
3043 case INTERNET_PER_CONN_FLAGS:
3044 case INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS:
3045 optW->Value.dwValue = optA->Value.dwValue;
3046 break;
3047 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME:
3048 optW->Value.ftValue = optA->Value.ftValue;
3049 break;
3050 default:
3051 WARN("Unknown PER_CONN dwOption: %d, guessing at conversion to Wide\n", optA->dwOption);
3052 optW->Value.dwValue = optA->Value.dwValue;
3053 break;
3054 }
3055 }
3056 }
3057 break;
3058 default:
3059 wbuffer = lpBuffer;
3060 wlen = dwBufferLength;
3061 }
3062
3063 r = InternetSetOptionW(hInternet,dwOption, wbuffer, wlen);
3064
3065 if( lpBuffer != wbuffer )
3066 {
3067 if (dwOption == INTERNET_OPTION_PER_CONNECTION_OPTION)
3068 {
3069 INTERNET_PER_CONN_OPTION_LISTW *list = wbuffer;
3070 unsigned int i;
3071 for (i = 0; i < list->dwOptionCount; ++i) {
3072 INTERNET_PER_CONN_OPTIONW *opt = list->pOptions + i;
3073 switch (opt->dwOption) {
3074 case INTERNET_PER_CONN_AUTOCONFIG_URL:
3075 case INTERNET_PER_CONN_PROXY_BYPASS:
3076 case INTERNET_PER_CONN_PROXY_SERVER:
3077 case INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL:
3078 case INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL:
3079 heap_free( opt->Value.pszValue );
3080 break;
3081 default:
3082 break;
3083 }
3084 }
3085 heap_free( list->pOptions );
3086 }
3087 heap_free( wbuffer );
3088 }
3089
3090 return r;
3091 }
3092
3093
3094 /***********************************************************************
3095 * InternetSetOptionExA (WININET.@)
3096 */
3097 BOOL WINAPI InternetSetOptionExA(HINTERNET hInternet, DWORD dwOption,
3098 LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
3099 {
3100 FIXME("Flags %08x ignored\n", dwFlags);
3101 return InternetSetOptionA( hInternet, dwOption, lpBuffer, dwBufferLength );
3102 }
3103
3104 /***********************************************************************
3105 * InternetSetOptionExW (WININET.@)
3106 */
3107 BOOL WINAPI InternetSetOptionExW(HINTERNET hInternet, DWORD dwOption,
3108 LPVOID lpBuffer, DWORD dwBufferLength, DWORD dwFlags)
3109 {
3110 FIXME("Flags %08x ignored\n", dwFlags);
3111 if( dwFlags & ~ISO_VALID_FLAGS )
3112 {
3113 SetLastError( ERROR_INVALID_PARAMETER );
3114 return FALSE;
3115 }
3116 return InternetSetOptionW( hInternet, dwOption, lpBuffer, dwBufferLength );
3117 }
3118
3119 static const WCHAR WININET_wkday[7][4] =
3120 { { 'S','u','n', 0 }, { 'M','o','n', 0 }, { 'T','u','e', 0 }, { 'W','e','d', 0 },
3121 { 'T','h','u', 0 }, { 'F','r','i', 0 }, { 'S','a','t', 0 } };
3122 static const WCHAR WININET_month[12][4] =
3123 { { 'J','a','n', 0 }, { 'F','e','b', 0 }, { 'M','a','r', 0 }, { 'A','p','r', 0 },
3124 { 'M','a','y', 0 }, { 'J','u','n', 0 }, { 'J','u','l', 0 }, { 'A','u','g', 0 },
3125 { 'S','e','p', 0 }, { 'O','c','t', 0 }, { 'N','o','v', 0 }, { 'D','e','c', 0 } };
3126
3127 /***********************************************************************
3128 * InternetTimeFromSystemTimeA (WININET.@)
3129 */
3130 BOOL WINAPI InternetTimeFromSystemTimeA( const SYSTEMTIME* time, DWORD format, LPSTR string, DWORD size )
3131 {
3132 BOOL ret;
3133 WCHAR stringW[INTERNET_RFC1123_BUFSIZE];
3134
3135 TRACE( "%p 0x%08x %p 0x%08x\n", time, format, string, size );
3136
3137 if (!time || !string || format != INTERNET_RFC1123_FORMAT)
3138 {
3139 SetLastError(ERROR_INVALID_PARAMETER);
3140 return FALSE;
3141 }
3142
3143 if (size < INTERNET_RFC1123_BUFSIZE * sizeof(*string))
3144 {
3145 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3146 return FALSE;
3147 }
3148
3149 ret = InternetTimeFromSystemTimeW( time, format, stringW, sizeof(stringW) );
3150 if (ret) WideCharToMultiByte( CP_ACP, 0, stringW, -1, string, size, NULL, NULL );
3151
3152 return ret;
3153 }
3154
3155 /***********************************************************************
3156 * InternetTimeFromSystemTimeW (WININET.@)
3157 */
3158 BOOL WINAPI InternetTimeFromSystemTimeW( const SYSTEMTIME* time, DWORD format, LPWSTR string, DWORD size )
3159 {
3160 static const WCHAR date[] =
3161 { '%','s',',',' ','%','0','2','d',' ','%','s',' ','%','4','d',' ','%','0',
3162 '2','d',':','%','0','2','d',':','%','0','2','d',' ','G','M','T', 0 };
3163
3164 TRACE( "%p 0x%08x %p 0x%08x\n", time, format, string, size );
3165
3166 if (!time || !string || format != INTERNET_RFC1123_FORMAT)
3167 {
3168 SetLastError(ERROR_INVALID_PARAMETER);
3169 return FALSE;
3170 }
3171
3172 if (size < INTERNET_RFC1123_BUFSIZE * sizeof(*string))
3173 {
3174 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3175 return FALSE;
3176 }
3177
3178 sprintfW( string, date,
3179 WININET_wkday[time->wDayOfWeek],
3180 time->wDay,
3181 WININET_month[time->wMonth - 1],
3182 time->wYear,
3183 time->wHour,
3184 time->wMinute,
3185 time->wSecond );
3186
3187 return TRUE;
3188 }
3189
3190 /***********************************************************************
3191 * InternetTimeToSystemTimeA (WININET.@)
3192 */
3193 BOOL WINAPI InternetTimeToSystemTimeA( LPCSTR string, SYSTEMTIME* time, DWORD reserved )
3194 {
3195 BOOL ret = FALSE;
3196 WCHAR *stringW;
3197
3198 TRACE( "%s %p 0x%08x\n", debugstr_a(string), time, reserved );
3199
3200 stringW = heap_strdupAtoW(string);
3201 if (stringW)
3202 {
3203 ret = InternetTimeToSystemTimeW( stringW, time, reserved );
3204 heap_free( stringW );
3205 }
3206 return ret;
3207 }
3208
3209 /***********************************************************************
3210 * InternetTimeToSystemTimeW (WININET.@)
3211 */
3212 BOOL WINAPI InternetTimeToSystemTimeW( LPCWSTR string, SYSTEMTIME* time, DWORD reserved )
3213 {
3214 unsigned int i;
3215 const WCHAR *s = string;
3216 WCHAR *end;
3217
3218 TRACE( "%s %p 0x%08x\n", debugstr_w(string), time, reserved );
3219
3220 if (!string || !time) return FALSE;
3221
3222 /* Windows does this too */
3223 GetSystemTime( time );
3224
3225 /* Convert an RFC1123 time such as 'Fri, 07 Jan 2005 12:06:35 GMT' into
3226 * a SYSTEMTIME structure.
3227 */
3228
3229 while (*s && !isalphaW( *s )) s++;
3230 if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
3231 time->wDayOfWeek = 7;
3232
3233 for (i = 0; i < 7; i++)
3234 {
3235 if (toupperW( WININET_wkday[i][0] ) == toupperW( s[0] ) &&
3236 toupperW( WININET_wkday[i][1] ) == toupperW( s[1] ) &&
3237 toupperW( WININET_wkday[i][2] ) == toupperW( s[2] ) )
3238 {
3239 time->wDayOfWeek = i;
3240 break;
3241 }
3242 }
3243
3244 if (time->wDayOfWeek > 6) return TRUE;
3245 while (*s && !isdigitW( *s )) s++;
3246 time->wDay = strtolW( s, &end, 10 );
3247 s = end;
3248
3249 while (*s && !isalphaW( *s )) s++;
3250 if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0') return TRUE;
3251 time->wMonth = 0;
3252
3253 for (i = 0; i < 12; i++)
3254 {
3255 if (toupperW( WININET_month[i][0]) == toupperW( s[0] ) &&
3256 toupperW( WININET_month[i][1]) == toupperW( s[1] ) &&
3257 toupperW( WININET_month[i][2]) == toupperW( s[2] ) )
3258 {
3259 time->wMonth = i + 1;
3260 break;
3261 }
3262 }
3263 if (time->wMonth == 0) return TRUE;
3264
3265 while (*s && !isdigitW( *s )) s++;
3266 if (*s == '\0') return TRUE;
3267 time->wYear = strtolW( s, &end, 10 );
3268 s = end;
3269
3270 while (*s && !isdigitW( *s )) s++;
3271 if (*s == '\0') return TRUE;
3272 time->wHour = strtolW( s, &end, 10 );
3273 s = end;
3274
3275 while (*s && !isdigitW( *s )) s++;
3276 if (*s == '\0') return TRUE;
3277 time->wMinute = strtolW( s, &end, 10 );
3278 s = end;
3279
3280 while (*s && !isdigitW( *s )) s++;
3281 if (*s == '\0') return TRUE;
3282 time->wSecond = strtolW( s, &end, 10 );
3283 s = end;
3284
3285 time->wMilliseconds = 0;
3286 return TRUE;
3287 }
3288
3289 /***********************************************************************
3290 * InternetCheckConnectionW (WININET.@)
3291 *
3292 * Pings a requested host to check internet connection
3293 *
3294 * RETURNS
3295 * TRUE on success and FALSE on failure. If a failure then
3296 * ERROR_NOT_CONNECTED is placed into GetLastError
3297 *
3298 */
3299 BOOL WINAPI InternetCheckConnectionW( LPCWSTR lpszUrl, DWORD dwFlags, DWORD dwReserved )
3300 {
3301 /*
3302 * this is a kludge which runs the resident ping program and reads the output.
3303 *
3304 * Anyone have a better idea?
3305 */
3306
3307 BOOL rc = FALSE;
3308 static const CHAR ping[] = "ping -c 1 ";
3309 static const CHAR redirect[] = " >/dev/null 2>/dev/null";
3310 CHAR *command = NULL;
3311 WCHAR hostW[INTERNET_MAX_HOST_NAME_LENGTH];
3312 DWORD len;
3313 INTERNET_PORT port;
3314 int status = -1;
3315
3316 FIXME("\n");
3317
3318 /*
3319 * Crack or set the Address
3320 */
3321 if (lpszUrl == NULL)
3322 {
3323 /*
3324 * According to the doc we are supposed to use the ip for the next
3325 * server in the WnInet internal server database. I have
3326 * no idea what that is or how to get it.
3327 *
3328 * So someone needs to implement this.
3329 */
3330 FIXME("Unimplemented with URL of NULL\n");
3331 return TRUE;
3332 }
3333 else
3334 {
3335 URL_COMPONENTSW components;
3336
3337 ZeroMemory(&components,sizeof(URL_COMPONENTSW));
3338 components.lpszHostName = (LPWSTR)hostW;
3339 components.dwHostNameLength = INTERNET_MAX_HOST_NAME_LENGTH;
3340
3341 if (!InternetCrackUrlW(lpszUrl,0,0,&components))
3342 goto End;
3343
3344 TRACE("host name : %s\n",debugstr_w(components.lpszHostName));
3345 port = components.nPort;
3346 TRACE("port: %d\n", port);
3347 }
3348
3349 if (dwFlags & FLAG_ICC_FORCE_CONNECTION)
3350 {
3351 struct sockaddr_storage saddr;
3352 socklen_t sa_len = sizeof(saddr);
3353 int fd;
3354
3355 if (!GetAddress(hostW, port, (struct sockaddr *)&saddr, &sa_len))
3356 goto End;
3357 fd = socket(saddr.ss_family, SOCK_STREAM, 0);
3358 if (fd != -1)
3359 {
3360 if (connect(fd, (struct sockaddr *)&saddr, sa_len) == 0)
3361 rc = TRUE;
3362 close(fd);
3363 }
3364 }
3365 else
3366 {
3367 /*
3368 * Build our ping command
3369 */
3370 len = WideCharToMultiByte(CP_UNIXCP, 0, hostW, -1, NULL, 0, NULL, NULL);
3371 command = heap_alloc(strlen(ping)+len+strlen(redirect));
3372 strcpy(command,ping);
3373 WideCharToMultiByte(CP_UNIXCP, 0, hostW, -1, command+strlen(ping), len, NULL, NULL);
3374 strcat(command,redirect);
3375
3376 TRACE("Ping command is : %s\n",command);
3377
3378 status = system(command);
3379
3380 TRACE("Ping returned a code of %i\n",status);
3381
3382 /* Ping return code of 0 indicates success */
3383 if (status == 0)
3384 rc = TRUE;
3385 }
3386
3387 End:
3388 heap_free( command );
3389 if (rc == FALSE)
3390 INTERNET_SetLastError(ERROR_NOT_CONNECTED);
3391
3392 return rc;
3393 }
3394
3395
3396 /***********************************************************************
3397 * InternetCheckConnectionA (WININET.@)
3398 *
3399 * Pings a requested host to check internet connection
3400 *
3401 * RETURNS
3402 * TRUE on success and FALSE on failure. If a failure then
3403 * ERROR_NOT_CONNECTED is placed into GetLastError
3404 *
3405 */
3406 BOOL WINAPI InternetCheckConnectionA(LPCSTR lpszUrl, DWORD dwFlags, DWORD dwReserved)
3407 {
3408 WCHAR *url = NULL;
3409 BOOL rc;
3410
3411 if(lpszUrl) {
3412 url = heap_strdupAtoW(lpszUrl);
3413 if(!url)
3414 return FALSE;
3415 }
3416
3417 rc = InternetCheckConnectionW(url, dwFlags, dwReserved);
3418
3419 heap_free(url);
3420 return rc;
3421 }
3422
3423
3424 /**********************************************************
3425 * INTERNET_InternetOpenUrlW (internal)
3426 *
3427 * Opens an URL
3428 *
3429 * RETURNS
3430 * handle of connection or NULL on failure
3431 */
3432 static HINTERNET INTERNET_InternetOpenUrlW(appinfo_t *hIC, LPCWSTR lpszUrl,
3433 LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
3434 {
3435 URL_COMPONENTSW urlComponents;
3436 WCHAR protocol[INTERNET_MAX_SCHEME_LENGTH];
3437 WCHAR hostName[INTERNET_MAX_HOST_NAME_LENGTH];
3438 WCHAR userName[INTERNET_MAX_USER_NAME_LENGTH];
3439 WCHAR password[INTERNET_MAX_PASSWORD_LENGTH];
3440 WCHAR path[INTERNET_MAX_PATH_LENGTH];
3441 WCHAR extra[1024];
3442 HINTERNET client = NULL, client1 = NULL;
3443 DWORD res;
3444
3445 TRACE("(%p, %s, %s, %08x, %08x, %08lx)\n", hIC, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
3446 dwHeadersLength, dwFlags, dwContext);
3447
3448 urlComponents.dwStructSize = sizeof(URL_COMPONENTSW);
3449 urlComponents.lpszScheme = protocol;
3450 urlComponents.dwSchemeLength = INTERNET_MAX_SCHEME_LENGTH;
3451 urlComponents.lpszHostName = hostName;
3452 urlComponents.dwHostNameLength = INTERNET_MAX_HOST_NAME_LENGTH;
3453 urlComponents.lpszUserName = userName;
3454 urlComponents.dwUserNameLength = INTERNET_MAX_USER_NAME_LENGTH;
3455 urlComponents.lpszPassword = password;
3456 urlComponents.dwPasswordLength = INTERNET_MAX_PASSWORD_LENGTH;
3457 urlComponents.lpszUrlPath = path;
3458 urlComponents.dwUrlPathLength = INTERNET_MAX_PATH_LENGTH;
3459 urlComponents.lpszExtraInfo = extra;
3460 urlComponents.dwExtraInfoLength = 1024;
3461 if(!InternetCrackUrlW(lpszUrl, strlenW(lpszUrl), 0, &urlComponents))
3462 return NULL;
3463 switch(urlComponents.nScheme) {
3464 case INTERNET_SCHEME_FTP:
3465 if(urlComponents.nPort == 0)
3466 urlComponents.nPort = INTERNET_DEFAULT_FTP_PORT;
3467 client = FTP_Connect(hIC, hostName, urlComponents.nPort,
3468 userName, password, dwFlags, dwContext, INET_OPENURL);
3469 if(client == NULL)
3470 break;
3471 client1 = FtpOpenFileW(client, path, GENERIC_READ, dwFlags, dwContext);
3472 if(client1 == NULL) {
3473 InternetCloseHandle(client);
3474 break;
3475 }
3476 break;
3477
3478 case INTERNET_SCHEME_HTTP:
3479 case INTERNET_SCHEME_HTTPS: {
3480 static const WCHAR szStars[] = { '*','/','*', 0 };
3481 LPCWSTR accept[2] = { szStars, NULL };
3482 if(urlComponents.nPort == 0) {
3483 if(urlComponents.nScheme == INTERNET_SCHEME_HTTP)
3484 urlComponents.nPort = INTERNET_DEFAULT_HTTP_PORT;
3485 else
3486 urlComponents.nPort = INTERNET_DEFAULT_HTTPS_PORT;
3487 }
3488 if (urlComponents.nScheme == INTERNET_SCHEME_HTTPS) dwFlags |= INTERNET_FLAG_SECURE;
3489
3490 /* FIXME: should use pointers, not handles, as handles are not thread-safe */
3491 res = HTTP_Connect(hIC, hostName, urlComponents.nPort,
3492 userName, password, dwFlags, dwContext, INET_OPENURL, &client);
3493 if(res != ERROR_SUCCESS) {
3494 INTERNET_SetLastError(res);
3495 break;
3496 }
3497
3498 if (urlComponents.dwExtraInfoLength) {
3499 WCHAR *path_extra;
3500 DWORD len = urlComponents.dwUrlPathLength + urlComponents.dwExtraInfoLength + 1;
3501
3502 if (!(path_extra = heap_alloc(len * sizeof(WCHAR))))
3503 {
3504 InternetCloseHandle(client);
3505 break;
3506 }
3507 strcpyW(path_extra, urlComponents.lpszUrlPath);
3508 strcatW(path_extra, urlComponents.lpszExtraInfo);
3509 client1 = HttpOpenRequestW(client, NULL, path_extra, NULL, NULL, accept, dwFlags, dwContext);
3510 heap_free(path_extra);
3511 }
3512 else
3513 client1 = HttpOpenRequestW(client, NULL, path, NULL, NULL, accept, dwFlags, dwContext);
3514
3515 if(client1 == NULL) {
3516 InternetCloseHandle(client);
3517 break;
3518 }
3519 HttpAddRequestHeadersW(client1, lpszHeaders, dwHeadersLength, HTTP_ADDREQ_FLAG_ADD);
3520 if (!HttpSendRequestW(client1, NULL, 0, NULL, 0) &&
3521 GetLastError() != ERROR_IO_PENDING) {
3522 InternetCloseHandle(client1);
3523 client1 = NULL;
3524 break;
3525 }
3526 }
3527 case INTERNET_SCHEME_GOPHER:
3528 /* gopher doesn't seem to be implemented in wine, but it's supposed
3529 * to be supported by InternetOpenUrlA. */
3530 default:
3531 SetLastError(ERROR_INTERNET_UNRECOGNIZED_SCHEME);
3532 break;
3533 }
3534
3535 TRACE(" %p <--\n", client1);
3536
3537 return client1;
3538 }
3539
3540 /**********************************************************
3541 * InternetOpenUrlW (WININET.@)
3542 *
3543 * Opens an URL
3544 *
3545 * RETURNS
3546 * handle of connection or NULL on failure
3547 */
3548 typedef struct {
3549 task_header_t hdr;
3550 WCHAR *url;
3551 WCHAR *headers;
3552 DWORD headers_len;
3553 DWORD flags;
3554 DWORD_PTR context;
3555 } open_url_task_t;
3556
3557 static void AsyncInternetOpenUrlProc(task_header_t *hdr)
3558 {
3559 open_url_task_t *task = (open_url_task_t*)hdr;
3560
3561 TRACE("%p\n", task->hdr.hdr);
3562
3563 INTERNET_InternetOpenUrlW((appinfo_t*)task->hdr.hdr, task->url, task->headers,
3564 task->headers_len, task->flags, task->context);
3565 heap_free(task->url);
3566 heap_free(task->headers);
3567 }
3568
3569 HINTERNET WINAPI InternetOpenUrlW(HINTERNET hInternet, LPCWSTR lpszUrl,
3570 LPCWSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
3571 {
3572 HINTERNET ret = NULL;
3573 appinfo_t *hIC = NULL;
3574
3575 if (TRACE_ON(wininet)) {
3576 TRACE("(%p, %s, %s, %08x, %08x, %08lx)\n", hInternet, debugstr_w(lpszUrl), debugstr_w(lpszHeaders),
3577 dwHeadersLength, dwFlags, dwContext);
3578 TRACE(" flags :");
3579 dump_INTERNET_FLAGS(dwFlags);
3580 }
3581
3582 if (!lpszUrl)
3583 {
3584 SetLastError(ERROR_INVALID_PARAMETER);
3585 goto lend;
3586 }
3587
3588 hIC = (appinfo_t*)get_handle_object( hInternet );
3589 if (NULL == hIC || hIC->hdr.htype != WH_HINIT) {
3590 SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
3591 goto lend;
3592 }
3593
3594 if (hIC->hdr.dwFlags & INTERNET_FLAG_ASYNC) {
3595 open_url_task_t *task;
3596
3597 task = alloc_async_task(&hIC->hdr, AsyncInternetOpenUrlProc, sizeof(*task));
3598 task->url = heap_strdupW(lpszUrl);
3599 task->headers = heap_strdupW(lpszHeaders);
3600 task->headers_len = dwHeadersLength;
3601 task->flags = dwFlags;
3602 task->context = dwContext;
3603
3604 INTERNET_AsyncCall(&task->hdr);
3605 SetLastError(ERROR_IO_PENDING);
3606 } else {
3607 ret = INTERNET_InternetOpenUrlW(hIC, lpszUrl, lpszHeaders, dwHeadersLength, dwFlags, dwContext);
3608 }
3609
3610 lend:
3611 if( hIC )
3612 WININET_Release( &hIC->hdr );
3613 TRACE(" %p <--\n", ret);
3614
3615 return ret;
3616 }
3617
3618 /**********************************************************
3619 * InternetOpenUrlA (WININET.@)
3620 *
3621 * Opens an URL
3622 *
3623 * RETURNS
3624 * handle of connection or NULL on failure
3625 */
3626 HINTERNET WINAPI InternetOpenUrlA(HINTERNET hInternet, LPCSTR lpszUrl,
3627 LPCSTR lpszHeaders, DWORD dwHeadersLength, DWORD dwFlags, DWORD_PTR dwContext)
3628 {
3629 HINTERNET rc = NULL;
3630 DWORD lenHeaders = 0;
3631 LPWSTR szUrl = NULL;
3632 LPWSTR szHeaders = NULL;
3633
3634 TRACE("\n");
3635
3636 if(lpszUrl) {
3637 szUrl = heap_strdupAtoW(lpszUrl);
3638 if(!szUrl)
3639 return NULL;
3640 }
3641
3642 if(lpszHeaders) {
3643 lenHeaders = MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, NULL, 0 );
3644 szHeaders = heap_alloc(lenHeaders*sizeof(WCHAR));
3645 if(!szHeaders) {
3646 heap_free(szUrl);
3647 return NULL;
3648 }
3649 MultiByteToWideChar(CP_ACP, 0, lpszHeaders, dwHeadersLength, szHeaders, lenHeaders);
3650 }
3651
3652 rc = InternetOpenUrlW(hInternet, szUrl, szHeaders,
3653 lenHeaders, dwFlags, dwContext);
3654
3655 heap_free(szUrl);
3656 heap_free(szHeaders);
3657 return rc;
3658 }
3659
3660
3661 static LPWITHREADERROR INTERNET_AllocThreadError(void)
3662 {
3663 LPWITHREADERROR lpwite = heap_alloc(sizeof(*lpwite));
3664
3665 if (lpwite)
3666 {
3667 lpwite->dwError = 0;
3668 lpwite->response[0] = '\0';
3669 }
3670
3671 if (!TlsSetValue(g_dwTlsErrIndex, lpwite))
3672 {
3673 heap_free(lpwite);
3674 return NULL;
3675 }
3676 return lpwite;
3677 }
3678
3679
3680 /***********************************************************************
3681 * INTERNET_SetLastError (internal)
3682 *
3683 * Set last thread specific error
3684 *
3685 * RETURNS
3686 *
3687 */
3688 void INTERNET_SetLastError(DWORD dwError)
3689 {
3690 LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
3691
3692 if (!lpwite)
3693 lpwite = INTERNET_AllocThreadError();
3694
3695 SetLastError(dwError);
3696 if(lpwite)
3697 lpwite->dwError = dwError;
3698 }
3699
3700
3701 /***********************************************************************
3702 * INTERNET_GetLastError (internal)
3703 *
3704 * Get last thread specific error
3705 *
3706 * RETURNS
3707 *
3708 */
3709 DWORD INTERNET_GetLastError(void)
3710 {
3711 LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
3712 if (!lpwite) return 0;
3713 /* TlsGetValue clears last error, so set it again here */
3714 SetLastError(lpwite->dwError);
3715 return lpwite->dwError;
3716 }
3717
3718
3719 /***********************************************************************
3720 * INTERNET_WorkerThreadFunc (internal)
3721 *
3722 * Worker thread execution function
3723 *
3724 * RETURNS
3725 *
3726 */
3727 static DWORD CALLBACK INTERNET_WorkerThreadFunc(LPVOID lpvParam)
3728 {
3729 task_header_t *task = lpvParam;
3730
3731 TRACE("\n");
3732
3733 task->proc(task);
3734 WININET_Release(task->hdr);
3735 heap_free(task);
3736
3737 if (g_dwTlsErrIndex != TLS_OUT_OF_INDEXES)
3738 {
3739 heap_free(TlsGetValue(g_dwTlsErrIndex));
3740 TlsSetValue(g_dwTlsErrIndex, NULL);
3741 }
3742 return TRUE;
3743 }
3744
3745 void *alloc_async_task(object_header_t *hdr, async_task_proc_t proc, size_t size)
3746 {
3747 task_header_t *task;
3748
3749 task = heap_alloc(size);
3750 if(!task)
3751 return NULL;
3752
3753 task->hdr = WININET_AddRef(hdr);
3754 task->proc = proc;
3755 return task;
3756 }
3757
3758 /***********************************************************************
3759 * INTERNET_AsyncCall (internal)
3760 *
3761 * Retrieves work request from queue
3762 *
3763 * RETURNS
3764 *
3765 */
3766 DWORD INTERNET_AsyncCall(task_header_t *task)
3767 {
3768 BOOL bSuccess;
3769
3770 TRACE("\n");
3771
3772 bSuccess = QueueUserWorkItem(INTERNET_WorkerThreadFunc, task, WT_EXECUTELONGFUNCTION);
3773 if (!bSuccess)
3774 {
3775 heap_free(task);
3776 return ERROR_INTERNET_ASYNC_THREAD_FAILED;
3777 }
3778 return ERROR_SUCCESS;
3779 }
3780
3781
3782 /***********************************************************************
3783 * INTERNET_GetResponseBuffer (internal)
3784 *
3785 * RETURNS
3786 *
3787 */
3788 LPSTR INTERNET_GetResponseBuffer(void)
3789 {
3790 LPWITHREADERROR lpwite = TlsGetValue(g_dwTlsErrIndex);
3791 if (!lpwite)
3792 lpwite = INTERNET_AllocThreadError();
3793 TRACE("\n");
3794 return lpwite->response;
3795 }
3796
3797 /***********************************************************************
3798 * INTERNET_GetNextLine (internal)
3799 *
3800 * Parse next line in directory string listing
3801 *
3802 * RETURNS
3803 * Pointer to beginning of next line
3804 * NULL on failure
3805 *
3806 */
3807
3808 LPSTR INTERNET_GetNextLine(INT nSocket, LPDWORD dwLen)
3809 {
3810 struct pollfd pfd;
3811 BOOL bSuccess = FALSE;
3812 INT nRecv = 0;
3813 LPSTR lpszBuffer = INTERNET_GetResponseBuffer();
3814
3815 TRACE("\n");
3816
3817 pfd.fd = nSocket;
3818 pfd.events = POLLIN;
3819
3820 while (nRecv < MAX_REPLY_LEN)
3821 {
3822 if (poll(&pfd,1, RESPONSE_TIMEOUT * 1000) > 0)
3823 {
3824 if (recv(nSocket, &lpszBuffer[nRecv], 1, 0) <= 0)
3825 {
3826 INTERNET_SetLastError(ERROR_FTP_TRANSFER_IN_PROGRESS);
3827 goto lend;
3828 }
3829
3830 if (lpszBuffer[nRecv] == '\n')
3831 {
3832 bSuccess = TRUE;
3833 break;
3834 }
3835 if (lpszBuffer[nRecv] != '\r')
3836 nRecv++;
3837 }
3838 else
3839 {
3840 INTERNET_SetLastError(ERROR_INTERNET_TIMEOUT);
3841 goto lend;
3842 }
3843 }
3844
3845 lend:
3846 if (bSuccess)
3847 {
3848 lpszBuffer[nRecv] = '\0';
3849 *dwLen = nRecv - 1;
3850 TRACE(":%d %s\n", nRecv, lpszBuffer);
3851 return lpszBuffer;
3852 }
3853 else
3854 {
3855 return NULL;
3856 }
3857 }
3858
3859 /**********************************************************
3860 * InternetQueryDataAvailable (WININET.@)
3861 *
3862 * Determines how much data is available to be read.
3863 *
3864 * RETURNS
3865 * TRUE on success, FALSE if an error occurred. If
3866 * INTERNET_FLAG_ASYNC was specified in InternetOpen, and
3867 * no data is presently available, FALSE is returned with
3868 * the last error ERROR_IO_PENDING; a callback with status
3869 * INTERNET_STATUS_REQUEST_COMPLETE will be sent when more
3870 * data is available.
3871 */
3872 BOOL WINAPI InternetQueryDataAvailable( HINTERNET hFile,
3873 LPDWORD lpdwNumberOfBytesAvailable,
3874 DWORD dwFlags, DWORD_PTR dwContext)
3875 {
3876 object_header_t *hdr;
3877 DWORD res;
3878
3879 TRACE("(%p %p %x %lx)\n", hFile, lpdwNumberOfBytesAvailable, dwFlags, dwContext);
3880
3881 hdr = get_handle_object( hFile );
3882 if (!hdr) {
3883 SetLastError(ERROR_INVALID_HANDLE);
3884 return FALSE;
3885 }
3886
3887 if(hdr->vtbl->QueryDataAvailable) {
3888 res = hdr->vtbl->QueryDataAvailable(hdr, lpdwNumberOfBytesAvailable, dwFlags, dwContext);
3889 }else {
3890 WARN("wrong handle\n");
3891 res = ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
3892 }
3893
3894 WININET_Release(hdr);
3895
3896 if(res != ERROR_SUCCESS)
3897 SetLastError(res);
3898 return res == ERROR_SUCCESS;
3899 }
3900
3901
3902 /***********************************************************************
3903 * InternetLockRequestFile (WININET.@)
3904 */
3905 BOOL WINAPI InternetLockRequestFile( HINTERNET hInternet, HANDLE
3906 *lphLockReqHandle)
3907 {
3908 FIXME("STUB\n");
3909 return FALSE;
3910 }
3911
3912 BOOL WINAPI InternetUnlockRequestFile( HANDLE hLockHandle)
3913 {
3914 FIXME("STUB\n");
3915 return FALSE;
3916 }
3917
3918
3919 /***********************************************************************
3920 * InternetAutodial (WININET.@)
3921 *
3922 * On windows this function is supposed to dial the default internet
3923 * connection. We don't want to have Wine dial out to the internet so
3924 * we return TRUE by default. It might be nice to check if we are connected.
3925 *
3926 * RETURNS
3927 * TRUE on success
3928 * FALSE on failure
3929 *
3930 */
3931 BOOL WINAPI InternetAutodial(DWORD dwFlags, HWND hwndParent)
3932 {
3933 FIXME("STUB\n");
3934
3935 /* Tell that we are connected to the internet. */
3936 return TRUE;
3937 }
3938
3939 /***********************************************************************
3940 * InternetAutodialHangup (WININET.@)
3941 *
3942 * Hangs up a connection made with InternetAutodial
3943 *
3944 * PARAM
3945 * dwReserved
3946 * RETURNS
3947 * TRUE on success
3948 * FALSE on failure
3949 *
3950 */
3951 BOOL WINAPI InternetAutodialHangup(DWORD dwReserved)
3952 {
3953 FIXME("STUB\n");
3954
3955 /* we didn't dial, we don't disconnect */
3956 return TRUE;
3957 }
3958
3959 /***********************************************************************
3960 * InternetCombineUrlA (WININET.@)
3961 *
3962 * Combine a base URL with a relative URL
3963 *
3964 * RETURNS
3965 * TRUE on success
3966 * FALSE on failure
3967 *
3968 */
3969
3970 BOOL WINAPI InternetCombineUrlA(LPCSTR lpszBaseUrl, LPCSTR lpszRelativeUrl,
3971 LPSTR lpszBuffer, LPDWORD lpdwBufferLength,
3972 DWORD dwFlags)
3973 {
3974 HRESULT hr=S_OK;
3975
3976 TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_a(lpszBaseUrl), debugstr_a(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
3977
3978 /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
3979 dwFlags ^= ICU_NO_ENCODE;
3980 hr=UrlCombineA(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
3981
3982 return (hr==S_OK);
3983 }
3984
3985 /***********************************************************************
3986 * InternetCombineUrlW (WININET.@)
3987 *
3988 * Combine a base URL with a relative URL
3989 *
3990 * RETURNS
3991 * TRUE on success
3992 * FALSE on failure
3993 *
3994 */
3995
3996 BOOL WINAPI InternetCombineUrlW(LPCWSTR lpszBaseUrl, LPCWSTR lpszRelativeUrl,
3997 LPWSTR lpszBuffer, LPDWORD lpdwBufferLength,
3998 DWORD dwFlags)
3999 {
4000 HRESULT hr=S_OK;
4001
4002 TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_w(lpszBaseUrl), debugstr_w(lpszRelativeUrl), lpszBuffer, lpdwBufferLength, dwFlags);
4003
4004 /* Flip this bit to correspond to URL_ESCAPE_UNSAFE */
4005 dwFlags ^= ICU_NO_ENCODE;
4006 hr=UrlCombineW(lpszBaseUrl,lpszRelativeUrl,lpszBuffer,lpdwBufferLength,dwFlags);
4007
4008 return (hr==S_OK);
4009 }
4010
4011 /* max port num is 65535 => 5 digits */
4012 #define MAX_WORD_DIGITS 5
4013
4014 #define URL_GET_COMP_LENGTH(url, component) ((url)->dw##component##Length ? \
4015 (url)->dw##component##Length : strlenW((url)->lpsz##component))
4016 #define URL_GET_COMP_LENGTHA(url, component) ((url)->dw##component##Length ? \
4017 (url)->dw##component##Length : strlen((url)->lpsz##component))
4018
4019 static BOOL url_uses_default_port(INTERNET_SCHEME nScheme, INTERNET_PORT nPort)
4020 {
4021 if ((nScheme == INTERNET_SCHEME_HTTP) &&
4022 (nPort == INTERNET_DEFAULT_HTTP_PORT))
4023 return TRUE;
4024 if ((nScheme == INTERNET_SCHEME_HTTPS) &&
4025 (nPort == INTERNET_DEFAULT_HTTPS_PORT))
4026 return TRUE;
4027 if ((nScheme == INTERNET_SCHEME_FTP) &&
4028 (nPort == INTERNET_DEFAULT_FTP_PORT))
4029 return TRUE;
4030 if ((nScheme == INTERNET_SCHEME_GOPHER) &&
4031 (nPort == INTERNET_DEFAULT_GOPHER_PORT))
4032 return TRUE;
4033
4034 if (nPort == INTERNET_INVALID_PORT_NUMBER)
4035 return TRUE;
4036
4037 return FALSE;
4038 }
4039
4040 /* opaque urls do not fit into the standard url hierarchy and don't have
4041 * two following slashes */
4042 static inline BOOL scheme_is_opaque(INTERNET_SCHEME nScheme)
4043 {
4044 return (nScheme != INTERNET_SCHEME_FTP) &&
4045 (nScheme != INTERNET_SCHEME_GOPHER) &&
4046 (nScheme != INTERNET_SCHEME_HTTP) &&
4047 (nScheme != INTERNET_SCHEME_HTTPS) &&
4048 (nScheme != INTERNET_SCHEME_FILE);
4049 }
4050
4051 static LPCWSTR INTERNET_GetSchemeString(INTERNET_SCHEME scheme)
4052 {
4053 int index;
4054 if (scheme < INTERNET_SCHEME_FIRST)
4055 return NULL;
4056 index = scheme - INTERNET_SCHEME_FIRST;
4057 if (index >= sizeof(url_schemes)/sizeof(url_schemes[0]))
4058 return NULL;
4059 return (LPCWSTR)url_schemes[index];
4060 }
4061
4062 /* we can calculate using ansi strings because we're just
4063 * calculating string length, not size
4064 */
4065 static BOOL calc_url_length(LPURL_COMPONENTSW lpUrlComponents,
4066 LPDWORD lpdwUrlLength)
4067 {
4068 INTERNET_SCHEME nScheme;
4069
4070 *lpdwUrlLength = 0;
4071
4072 if (lpUrlComponents->lpszScheme)
4073 {
4074 DWORD dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
4075 *lpdwUrlLength += dwLen;
4076 nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
4077 }
4078 else
4079 {
4080 LPCWSTR scheme;
4081
4082 nScheme = lpUrlComponents->nScheme;
4083
4084 if (nScheme == INTERNET_SCHEME_DEFAULT)
4085 nScheme = INTERNET_SCHEME_HTTP;
4086 scheme = INTERNET_GetSchemeString(nScheme);
4087 *lpdwUrlLength += strlenW(scheme);
4088 }
4089
4090 (*lpdwUrlLength)++; /* ':' */
4091 if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
4092 *lpdwUrlLength += strlen("//");
4093
4094 if (lpUrlComponents->lpszUserName)
4095 {
4096 *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
4097 *lpdwUrlLength += strlen("@");
4098 }
4099 else
4100 {
4101 if (lpUrlComponents->lpszPassword)
4102 {
4103 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
4104 return FALSE;
4105 }
4106 }
4107
4108 if (lpUrlComponents->lpszPassword)
4109 {
4110 *lpdwUrlLength += strlen(":");
4111 *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, Password);
4112 }
4113
4114 if (lpUrlComponents->lpszHostName)
4115 {
4116 *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
4117
4118 if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
4119 {
4120 char szPort[MAX_WORD_DIGITS+1];
4121
4122 sprintf(szPort, "%d", lpUrlComponents->nPort);
4123 *lpdwUrlLength += strlen(szPort);
4124 *lpdwUrlLength += strlen(":");
4125 }
4126
4127 if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
4128 (*lpdwUrlLength)++; /* '/' */
4129 }
4130
4131 if (lpUrlComponents->lpszUrlPath)
4132 *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
4133
4134 if (lpUrlComponents->lpszExtraInfo)
4135 *lpdwUrlLength += URL_GET_COMP_LENGTH(lpUrlComponents, ExtraInfo);
4136
4137 return TRUE;
4138 }
4139
4140 static void convert_urlcomp_atow(LPURL_COMPONENTSA lpUrlComponents, LPURL_COMPONENTSW urlCompW)
4141 {
4142 INT len;
4143
4144 ZeroMemory(urlCompW, sizeof(URL_COMPONENTSW));
4145
4146 urlCompW->dwStructSize = sizeof(URL_COMPONENTSW);
4147 urlCompW->dwSchemeLength = lpUrlComponents->dwSchemeLength;
4148 urlCompW->nScheme = lpUrlComponents->nScheme;
4149 urlCompW->dwHostNameLength = lpUrlComponents->dwHostNameLength;
4150 urlCompW->nPort = lpUrlComponents->nPort;
4151 urlCompW->dwUserNameLength = lpUrlComponents->dwUserNameLength;
4152 urlCompW->dwPasswordLength = lpUrlComponents->dwPasswordLength;
4153 urlCompW->dwUrlPathLength = lpUrlComponents->dwUrlPathLength;
4154 urlCompW->dwExtraInfoLength = lpUrlComponents->dwExtraInfoLength;
4155
4156 if (lpUrlComponents->lpszScheme)
4157 {
4158 len = URL_GET_COMP_LENGTHA(lpUrlComponents, Scheme) + 1;
4159 urlCompW->lpszScheme = heap_alloc(len * sizeof(WCHAR));
4160 MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszScheme,
4161 -1, urlCompW->lpszScheme, len);
4162 }
4163
4164 if (lpUrlComponents->lpszHostName)
4165 {
4166 len = URL_GET_COMP_LENGTHA(lpUrlComponents, HostName) + 1;
4167 urlCompW->lpszHostName = heap_alloc(len * sizeof(WCHAR));
4168 MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszHostName,
4169 -1, urlCompW->lpszHostName, len);
4170 }
4171
4172 if (lpUrlComponents->lpszUserName)
4173 {
4174 len = URL_GET_COMP_LENGTHA(lpUrlComponents, UserName) + 1;
4175 urlCompW->lpszUserName = heap_alloc(len * sizeof(WCHAR));
4176 MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUserName,
4177 -1, urlCompW->lpszUserName, len);
4178 }
4179
4180 if (lpUrlComponents->lpszPassword)
4181 {
4182 len = URL_GET_COMP_LENGTHA(lpUrlComponents, Password) + 1;
4183 urlCompW->lpszPassword = heap_alloc(len * sizeof(WCHAR));
4184 MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszPassword,
4185 -1, urlCompW->lpszPassword, len);
4186 }
4187
4188 if (lpUrlComponents->lpszUrlPath)
4189 {
4190 len = URL_GET_COMP_LENGTHA(lpUrlComponents, UrlPath) + 1;
4191 urlCompW->lpszUrlPath = heap_alloc(len * sizeof(WCHAR));
4192 MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszUrlPath,
4193 -1, urlCompW->lpszUrlPath, len);
4194 }
4195
4196 if (lpUrlComponents->lpszExtraInfo)
4197 {
4198 len = URL_GET_COMP_LENGTHA(lpUrlComponents, ExtraInfo) + 1;
4199 urlCompW->lpszExtraInfo = heap_alloc(len * sizeof(WCHAR));
4200 MultiByteToWideChar(CP_ACP, 0, lpUrlComponents->lpszExtraInfo,
4201 -1, urlCompW->lpszExtraInfo, len);
4202 }
4203 }
4204
4205 /***********************************************************************
4206 * InternetCreateUrlA (WININET.@)
4207 *
4208 * See InternetCreateUrlW.
4209 */
4210 BOOL WINAPI InternetCreateUrlA(LPURL_COMPONENTSA lpUrlComponents, DWORD dwFlags,
4211 LPSTR lpszUrl, LPDWORD lpdwUrlLength)
4212 {
4213 BOOL ret;
4214 LPWSTR urlW = NULL;
4215 URL_COMPONENTSW urlCompW;
4216
4217 TRACE("(%p,%d,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
4218
4219 if (!lpUrlComponents || lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
4220 {
4221 SetLastError(ERROR_INVALID_PARAMETER);
4222 return FALSE;
4223 }
4224
4225 convert_urlcomp_atow(lpUrlComponents, &urlCompW);
4226
4227 if (lpszUrl)
4228 urlW = heap_alloc(*lpdwUrlLength * sizeof(WCHAR));
4229
4230 ret = InternetCreateUrlW(&urlCompW, dwFlags, urlW, lpdwUrlLength);
4231
4232 if (!ret && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
4233 *lpdwUrlLength /= sizeof(WCHAR);
4234
4235 /* on success, lpdwUrlLength points to the size of urlW in WCHARS
4236 * minus one, so add one to leave room for NULL terminator
4237 */
4238 if (ret)
4239 WideCharToMultiByte(CP_ACP, 0, urlW, -1, lpszUrl, *lpdwUrlLength + 1, NULL, NULL);
4240
4241 heap_free(urlCompW.lpszScheme);
4242 heap_free(urlCompW.lpszHostName);
4243 heap_free(urlCompW.lpszUserName);
4244 heap_free(urlCompW.lpszPassword);
4245 heap_free(urlCompW.lpszUrlPath);
4246 heap_free(urlCompW.lpszExtraInfo);
4247 heap_free(urlW);
4248 return ret;
4249 }
4250
4251 /***********************************************************************
4252 * InternetCreateUrlW (WININET.@)
4253 *
4254 * Creates a URL from its component parts.
4255 *
4256 * PARAMS
4257 * lpUrlComponents [I] URL Components.
4258 * dwFlags [I] Flags. See notes.
4259 * lpszUrl [I] Buffer in which to store the created URL.
4260 * lpdwUrlLength [I/O] On input, the length of the buffer pointed to by
4261 * lpszUrl in characters. On output, the number of bytes
4262 * required to store the URL including terminator.
4263 *
4264 * NOTES
4265 *
4266 * The dwFlags parameter can be zero or more of the following:
4267 *|ICU_ESCAPE - Generates escape sequences for unsafe characters in the path and extra info of the URL.
4268 *
4269 * RETURNS
4270 * TRUE on success
4271 * FALSE on failure
4272 *
4273 */
4274 BOOL WINAPI InternetCreateUrlW(LPURL_COMPONENTSW lpUrlComponents, DWORD dwFlags,
4275 LPWSTR lpszUrl, LPDWORD lpdwUrlLength)
4276 {
4277 DWORD dwLen;
4278 INTERNET_SCHEME nScheme;
4279
4280 static const WCHAR slashSlashW[] = {'/','/'};
4281 static const WCHAR fmtW[] = {'%','u',0};
4282
4283 TRACE("(%p,%d,%p,%p)\n", lpUrlComponents, dwFlags, lpszUrl, lpdwUrlLength);
4284
4285 if (!lpUrlComponents || lpUrlComponents->dwStructSize != sizeof(URL_COMPONENTSW) || !lpdwUrlLength)
4286 {
4287 INTERNET_SetLastError(ERROR_INVALID_PARAMETER);
4288 return FALSE;
4289 }
4290
4291 if (!calc_url_length(lpUrlComponents, &dwLen))
4292 return FALSE;
4293
4294 if (!lpszUrl || *lpdwUrlLength < dwLen)
4295 {
4296 *lpdwUrlLength = (dwLen + 1) * sizeof(WCHAR);
4297 INTERNET_SetLastError(ERROR_INSUFFICIENT_BUFFER);
4298 return FALSE;
4299 }
4300
4301 *lpdwUrlLength = dwLen;
4302 lpszUrl[0] = 0x00;
4303
4304 dwLen = 0;
4305
4306 if (lpUrlComponents->lpszScheme)
4307 {
4308 dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Scheme);
4309 memcpy(lpszUrl, lpUrlComponents->lpszScheme, dwLen * sizeof(WCHAR));
4310 lpszUrl += dwLen;
4311
4312 nScheme = GetInternetSchemeW(lpUrlComponents->lpszScheme, dwLen);
4313 }
4314 else
4315 {
4316 LPCWSTR scheme;
4317 nScheme = lpUrlComponents->nScheme;
4318
4319 if (nScheme == INTERNET_SCHEME_DEFAULT)
4320 nScheme = INTERNET_SCHEME_HTTP;
4321
4322 scheme = INTERNET_GetSchemeString(nScheme);
4323 dwLen = strlenW(scheme);
4324 memcpy(lpszUrl, scheme, dwLen * sizeof(WCHAR));
4325 lpszUrl += dwLen;
4326 }
4327
4328 /* all schemes are followed by at least a colon */
4329 *lpszUrl = ':';
4330 lpszUrl++;
4331
4332 if (!scheme_is_opaque(nScheme) || lpUrlComponents->lpszHostName)
4333 {
4334 memcpy(lpszUrl, slashSlashW, sizeof(slashSlashW));
4335 lpszUrl += sizeof(slashSlashW)/sizeof(slashSlashW[0]);
4336 }
4337
4338 if (lpUrlComponents->lpszUserName)
4339 {
4340 dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UserName);
4341 memcpy(lpszUrl, lpUrlComponents->lpszUserName, dwLen * sizeof(WCHAR));
4342 lpszUrl += dwLen;
4343
4344 if (lpUrlComponents->lpszPassword)
4345 {
4346 *lpszUrl = ':';
4347 lpszUrl++;
4348
4349 dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, Password);
4350 memcpy(lpszUrl, lpUrlComponents->lpszPassword, dwLen * sizeof(WCHAR));
4351 lpszUrl += dwLen;
4352 }
4353
4354 *lpszUrl = '@';
4355 lpszUrl++;
4356 }
4357
4358 if (lpUrlComponents->lpszHostName)
4359 {
4360 dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, HostName);
4361 memcpy(lpszUrl, lpUrlComponents->lpszHostName, dwLen * sizeof(WCHAR));
4362 lpszUrl += dwLen;
4363
4364 if (!url_uses_default_port(nScheme, lpUrlComponents->nPort))
4365 {
4366 WCHAR szPort[MAX_WORD_DIGITS+1];
4367
4368 sprintfW(szPort, fmtW, lpUrlComponents->nPort);
4369 *lpszUrl = ':';
4370 lpszUrl++;
4371 dwLen = strlenW(szPort);
4372 memcpy(lpszUrl, szPort, dwLen * sizeof(WCHAR));
4373 lpszUrl += dwLen;
4374 }
4375
4376 /* add slash between hostname and path if necessary */
4377 if (lpUrlComponents->lpszUrlPath && *lpUrlComponents->lpszUrlPath != '/')
4378 {
4379 *lpszUrl = '/';
4380 lpszUrl++;
4381 }
4382 }
4383
4384 if (lpUrlComponents->lpszUrlPath)
4385 {
4386 dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, UrlPath);
4387 memcpy(lpszUrl, lpUrlComponents->lpszUrlPath, dwLen * sizeof(WCHAR));
4388 lpszUrl += dwLen;
4389 }
4390
4391 if (lpUrlComponents->lpszExtraInfo)
4392 {
4393 dwLen = URL_GET_COMP_LENGTH(lpUrlComponents, ExtraInfo);
4394 memcpy(lpszUrl, lpUrlComponents->lpszExtraInfo, dwLen * sizeof(WCHAR));
4395 lpszUrl += dwLen;
4396 }
4397
4398 *lpszUrl = '\0';
4399
4400 return TRUE;
4401 }
4402
4403 /***********************************************************************
4404 * InternetConfirmZoneCrossingA (WININET.@)
4405 *
4406 */
4407 DWORD WINAPI InternetConfirmZoneCrossingA( HWND hWnd, LPSTR szUrlPrev, LPSTR szUrlNew, BOOL bPost )
4408 {
4409 FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_a(szUrlPrev), debugstr_a(szUrlNew), bPost);
4410 return ERROR_SUCCESS;
4411 }
4412
4413 /***********************************************************************
4414 * InternetConfirmZoneCrossingW (WININET.@)
4415 *
4416 */
4417 DWORD WINAPI InternetConfirmZoneCrossingW( HWND hWnd, LPWSTR szUrlPrev, LPWSTR szUrlNew, BOOL bPost )
4418 {
4419 FIXME("(%p, %s, %s, %x) stub\n", hWnd, debugstr_w(szUrlPrev), debugstr_w(szUrlNew), bPost);
4420 return ERROR_SUCCESS;
4421 }
4422
4423 static DWORD zone_preference = 3;
4424
4425 /***********************************************************************
4426 * PrivacySetZonePreferenceW (WININET.@)
4427 */
4428 DWORD WINAPI PrivacySetZonePreferenceW( DWORD zone, DWORD type, DWORD template, LPCWSTR preference )
4429 {
4430 FIXME( "%x %x %x %s: stub\n", zone, type, template, debugstr_w(preference) );
4431
4432 zone_preference = template;
4433 return 0;
4434 }
4435
4436 /***********************************************************************
4437 * PrivacyGetZonePreferenceW (WININET.@)
4438 */
4439 DWORD WINAPI PrivacyGetZonePreferenceW( DWORD zone, DWORD type, LPDWORD template,
4440 LPWSTR preference, LPDWORD length )
4441 {
4442 FIXME( "%x %x %p %p %p: stub\n", zone, type, template, preference, length );
4443
4444 if (template) *template = zone_preference;
4445 return 0;
4446 }
4447
4448 /***********************************************************************
4449 * InternetGetSecurityInfoByURLA (WININET.@)
4450 */
4451 BOOL WINAPI InternetGetSecurityInfoByURLA(LPSTR lpszURL, PCCERT_CHAIN_CONTEXT *ppCertChain, DWORD *pdwSecureFlags)
4452 {
4453 WCHAR *url;
4454 BOOL res;
4455
4456 TRACE("(%s %p %p)\n", debugstr_a(lpszURL), ppCertChain, pdwSecureFlags);
4457
4458 url = heap_strdupAtoW(lpszURL);
4459 if(!url)
4460 return FALSE;
4461
4462 res = InternetGetSecurityInfoByURLW(url, ppCertChain, pdwSecureFlags);
4463 heap_free(url);
4464 return res;
4465 }
4466
4467 /***********************************************************************
4468 * InternetGetSecurityInfoByURLW (WININET.@)
4469 */
4470 BOOL WINAPI InternetGetSecurityInfoByURLW(LPCWSTR lpszURL, PCCERT_CHAIN_CONTEXT *ppCertChain, DWORD *pdwSecureFlags)
4471 {
4472 WCHAR hostname[INTERNET_MAX_HOST_NAME_LENGTH];
4473 URL_COMPONENTSW url = {sizeof(url)};
4474 server_t *server;
4475 BOOL res = FALSE;
4476
4477 TRACE("(%s %p %p)\n", debugstr_w(lpszURL), ppCertChain, pdwSecureFlags);
4478
4479 url.lpszHostName = hostname;
4480 url.dwHostNameLength = sizeof(hostname)/sizeof(WCHAR);
4481
4482 res = InternetCrackUrlW(lpszURL, 0, 0, &url);
4483 if(!res || url.nScheme != INTERNET_SCHEME_HTTPS) {
4484 SetLastError(ERROR_INTERNET_ITEM_NOT_FOUND);
4485 return FALSE;
4486 }
4487
4488 server = get_server(hostname, url.nPort, TRUE, FALSE);
4489 if(!server) {
4490 SetLastError(ERROR_INTERNET_ITEM_NOT_FOUND);
4491 return FALSE;
4492 }
4493
4494 if(server->cert_chain) {
4495 const CERT_CHAIN_CONTEXT *chain_dup;
4496
4497 chain_dup = CertDuplicateCertificateChain(server->cert_chain);
4498 if(chain_dup) {
4499 *ppCertChain = chain_dup;
4500 *pdwSecureFlags = server->security_flags & _SECURITY_ERROR_FLAGS_MASK;
4501 }else {
4502 res = FALSE;
4503 }
4504 }else {
4505 SetLastError(ERROR_INTERNET_ITEM_NOT_FOUND);
4506 res = FALSE;
4507 }
4508
4509 server_release(server);
4510 return res;
4511 }
4512
4513 DWORD WINAPI InternetDialA( HWND hwndParent, LPSTR lpszConnectoid, DWORD dwFlags,
4514 DWORD_PTR* lpdwConnection, DWORD dwReserved )
4515 {
4516 FIXME("(%p, %p, 0x%08x, %p, 0x%08x) stub\n", hwndParent, lpszConnectoid, dwFlags,
4517 lpdwConnection, dwReserved);
4518 return ERROR_SUCCESS;
4519 }
4520
4521 DWORD WINAPI InternetDialW( HWND hwndParent, LPWSTR lpszConnectoid, DWORD dwFlags,
4522 DWORD_PTR* lpdwConnection, DWORD dwReserved )
4523 {
4524 FIXME("(%p, %p, 0x%08x, %p, 0x%08x) stub\n", hwndParent, lpszConnectoid, dwFlags,
4525 lpdwConnection, dwReserved);
4526 return ERROR_SUCCESS;
4527 }
4528
4529 BOOL WINAPI InternetGoOnlineA( LPSTR lpszURL, HWND hwndParent, DWORD dwReserved )
4530 {
4531 FIXME("(%s, %p, 0x%08x) stub\n", debugstr_a(lpszURL), hwndParent, dwReserved);
4532 return TRUE;
4533 }
4534
4535 BOOL WINAPI InternetGoOnlineW( LPWSTR lpszURL, HWND hwndParent, DWORD dwReserved )
4536 {
4537 FIXME("(%s, %p, 0x%08x) stub\n", debugstr_w(lpszURL), hwndParent, dwReserved);
4538 return TRUE;
4539 }
4540
4541 DWORD WINAPI InternetHangUp( DWORD_PTR dwConnection, DWORD dwReserved )
4542 {
4543 FIXME("(0x%08lx, 0x%08x) stub\n", dwConnection, dwReserved);
4544 return ERROR_SUCCESS;
4545 }
4546
4547 BOOL WINAPI CreateMD5SSOHash( PWSTR pszChallengeInfo, PWSTR pwszRealm, PWSTR pwszTarget,
4548 PBYTE pbHexHash )
4549 {
4550 FIXME("(%s, %s, %s, %p) stub\n", debugstr_w(pszChallengeInfo), debugstr_w(pwszRealm),
4551 debugstr_w(pwszTarget), pbHexHash);
4552 return FALSE;
4553 }
4554
4555 BOOL WINAPI ResumeSuspendedDownload( HINTERNET hInternet, DWORD dwError )
4556 {
4557 FIXME("(%p, 0x%08x) stub\n", hInternet, dwError);
4558 return FALSE;
4559 }
4560
4561 BOOL WINAPI InternetQueryFortezzaStatus(DWORD *a, DWORD_PTR b)
4562 {
4563 FIXME("(%p, %08lx) stub\n", a, b);
4564 return 0;
4565 }
4566
4567 DWORD WINAPI ShowClientAuthCerts(HWND parent)
4568 {
4569 FIXME("%p: stub\n", parent);
4570 return 0;
4571 }
Windows API implementation