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