ntdll: Add test cases for the returned frame value in RtlVirtualUnwind.
[wine] / dlls / wininet / cookie.c
1 /*
2  * Wininet - cookie handling stuff
3  *
4  * Copyright 2002 TransGaming Technologies Inc.
5  *
6  * David Hammerton
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #if defined(__MINGW32__) || defined (_MSC_VER)
27 #include <ws2tcpip.h>
28 #endif
29
30 #include <stdarg.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "wininet.h"
41 #include "winerror.h"
42
43 #include "wine/debug.h"
44 #include "internet.h"
45
46 #define RESPONSE_TIMEOUT        30            /* FROM internet.c */
47
48
49 WINE_DEFAULT_DEBUG_CHANNEL(wininet);
50
51 /* FIXME
52  *     Cookies are currently memory only.
53  *     Cookies are NOT THREAD SAFE
54  *     Cookies could use A LOT OF MEMORY. We need some kind of memory management here!
55  */
56
57 typedef struct _cookie_domain cookie_domain;
58 typedef struct _cookie cookie;
59
60 struct _cookie
61 {
62     struct list entry;
63
64     struct _cookie_domain *parent;
65
66     LPWSTR lpCookieName;
67     LPWSTR lpCookieData;
68     FILETIME expiry;
69 };
70
71 struct _cookie_domain
72 {
73     struct list entry;
74
75     LPWSTR lpCookieDomain;
76     LPWSTR lpCookiePath;
77     struct list cookie_list;
78 };
79
80 static struct list domain_list = LIST_INIT(domain_list);
81
82 static cookie *COOKIE_addCookie(cookie_domain *domain, LPCWSTR name, LPCWSTR data, FILETIME expiry);
83 static cookie *COOKIE_findCookie(cookie_domain *domain, LPCWSTR lpszCookieName);
84 static void COOKIE_deleteCookie(cookie *deadCookie, BOOL deleteDomain);
85 static cookie_domain *COOKIE_addDomain(LPCWSTR domain, LPCWSTR path);
86 static void COOKIE_deleteDomain(cookie_domain *deadDomain);
87
88
89 /* adds a cookie to the domain */
90 static cookie *COOKIE_addCookie(cookie_domain *domain, LPCWSTR name, LPCWSTR data, FILETIME expiry)
91 {
92     cookie *newCookie = HeapAlloc(GetProcessHeap(), 0, sizeof(cookie));
93
94     list_init(&newCookie->entry);
95     newCookie->lpCookieName = NULL;
96     newCookie->lpCookieData = NULL;
97     newCookie->expiry = expiry;
98
99     if (name)
100     {
101         newCookie->lpCookieName = HeapAlloc(GetProcessHeap(), 0, (strlenW(name) + 1)*sizeof(WCHAR));
102         lstrcpyW(newCookie->lpCookieName, name);
103     }
104     if (data)
105     {
106         newCookie->lpCookieData = HeapAlloc(GetProcessHeap(), 0, (strlenW(data) + 1)*sizeof(WCHAR));
107         lstrcpyW(newCookie->lpCookieData, data);
108     }
109
110     TRACE("added cookie %p (data is %s)\n", newCookie, debugstr_w(data) );
111
112     list_add_tail(&domain->cookie_list, &newCookie->entry);
113     newCookie->parent = domain;
114     return newCookie;
115 }
116
117
118 /* finds a cookie in the domain matching the cookie name */
119 static cookie *COOKIE_findCookie(cookie_domain *domain, LPCWSTR lpszCookieName)
120 {
121     struct list * cursor;
122     TRACE("(%p, %s)\n", domain, debugstr_w(lpszCookieName));
123
124     LIST_FOR_EACH(cursor, &domain->cookie_list)
125     {
126         cookie *searchCookie = LIST_ENTRY(cursor, cookie, entry);
127         BOOL candidate = TRUE;
128         if (candidate && lpszCookieName)
129         {
130             if (candidate && !searchCookie->lpCookieName)
131                 candidate = FALSE;
132             if (candidate && strcmpW(lpszCookieName, searchCookie->lpCookieName) != 0)
133                 candidate = FALSE;
134         }
135         if (candidate)
136             return searchCookie;
137     }
138     return NULL;
139 }
140
141 /* removes a cookie from the list, if its the last cookie we also remove the domain */
142 static void COOKIE_deleteCookie(cookie *deadCookie, BOOL deleteDomain)
143 {
144     HeapFree(GetProcessHeap(), 0, deadCookie->lpCookieName);
145     HeapFree(GetProcessHeap(), 0, deadCookie->lpCookieData);
146     list_remove(&deadCookie->entry);
147
148     /* special case: last cookie, lets remove the domain to save memory */
149     if (list_empty(&deadCookie->parent->cookie_list) && deleteDomain)
150         COOKIE_deleteDomain(deadCookie->parent);
151     HeapFree(GetProcessHeap(), 0, deadCookie);
152 }
153
154 /* allocates a domain and adds it to the end */
155 static cookie_domain *COOKIE_addDomain(LPCWSTR domain, LPCWSTR path)
156 {
157     cookie_domain *newDomain = HeapAlloc(GetProcessHeap(), 0, sizeof(cookie_domain));
158
159     list_init(&newDomain->entry);
160     list_init(&newDomain->cookie_list);
161     newDomain->lpCookieDomain = NULL;
162     newDomain->lpCookiePath = NULL;
163
164     if (domain)
165     {
166         newDomain->lpCookieDomain = HeapAlloc(GetProcessHeap(), 0, (strlenW(domain) + 1)*sizeof(WCHAR));
167         strcpyW(newDomain->lpCookieDomain, domain);
168     }
169     if (path)
170     {
171         newDomain->lpCookiePath = HeapAlloc(GetProcessHeap(), 0, (strlenW(path) + 1)*sizeof(WCHAR));
172         lstrcpyW(newDomain->lpCookiePath, path);
173     }
174
175     list_add_tail(&domain_list, &newDomain->entry);
176
177     TRACE("Adding domain: %p\n", newDomain);
178     return newDomain;
179 }
180
181 static BOOL COOKIE_crackUrlSimple(LPCWSTR lpszUrl, LPWSTR hostName, int hostNameLen, LPWSTR path, int pathLen)
182 {
183     URL_COMPONENTSW UrlComponents;
184     BOOL rc;
185
186     UrlComponents.lpszExtraInfo = NULL;
187     UrlComponents.lpszPassword = NULL;
188     UrlComponents.lpszScheme = NULL;
189     UrlComponents.lpszUrlPath = path;
190     UrlComponents.lpszUserName = NULL;
191     UrlComponents.lpszHostName = hostName;
192     UrlComponents.dwExtraInfoLength = 0;
193     UrlComponents.dwPasswordLength = 0;
194     UrlComponents.dwSchemeLength = 0;
195     UrlComponents.dwUserNameLength = 0;
196     UrlComponents.dwHostNameLength = hostNameLen;
197     UrlComponents.dwUrlPathLength = pathLen;
198
199     rc = InternetCrackUrlW(lpszUrl, 0, 0, &UrlComponents);
200
201     /* discard the webpage off the end of the path */
202     if (pathLen > 0 && path[pathLen-1] != '/')
203     {
204         LPWSTR ptr;
205         ptr = strrchrW(path,'/');
206         if (ptr)
207             *(++ptr) = 0;
208         else
209         {
210             path[0] = '/';
211             path[1] = 0;
212         }
213     }
214     return rc;
215 }
216
217 /* match a domain. domain must match if the domain is not NULL. path must match if the path is not NULL */
218 static BOOL COOKIE_matchDomain(LPCWSTR lpszCookieDomain, LPCWSTR lpszCookiePath,
219                                cookie_domain *searchDomain, BOOL allow_partial)
220 {
221     TRACE("searching on domain %p\n", searchDomain);
222         if (lpszCookieDomain)
223         {
224             if (!searchDomain->lpCookieDomain)
225             return FALSE;
226
227             TRACE("comparing domain %s with %s\n", 
228             debugstr_w(lpszCookieDomain), 
229             debugstr_w(searchDomain->lpCookieDomain));
230
231         if (allow_partial && !strstrW(lpszCookieDomain, searchDomain->lpCookieDomain))
232             return FALSE;
233         else if (!allow_partial && lstrcmpW(lpszCookieDomain, searchDomain->lpCookieDomain) != 0)
234             return FALSE;
235         }
236     if (lpszCookiePath)
237     {
238         INT len;
239         TRACE("comparing paths: %s with %s\n", debugstr_w(lpszCookiePath), debugstr_w(searchDomain->lpCookiePath));
240         /* paths match at the beginning.  so a path of  /foo would match
241          * /foobar and /foo/bar
242          */
243         if (!searchDomain->lpCookiePath)
244             return FALSE;
245         if (allow_partial)
246         {
247             len = lstrlenW(searchDomain->lpCookiePath);
248             if (strncmpiW(searchDomain->lpCookiePath, lpszCookiePath, len)!=0)
249                 return FALSE;
250         }
251         else if (strcmpW(lpszCookiePath, searchDomain->lpCookiePath))
252             return FALSE;
253
254         }
255         return TRUE;
256 }
257
258 /* remove a domain from the list and delete it */
259 static void COOKIE_deleteDomain(cookie_domain *deadDomain)
260 {
261     struct list * cursor;
262     while ((cursor = list_tail(&deadDomain->cookie_list)))
263     {
264         COOKIE_deleteCookie(LIST_ENTRY(cursor, cookie, entry), FALSE);
265         list_remove(cursor);
266     }
267
268     HeapFree(GetProcessHeap(), 0, deadDomain->lpCookieDomain);
269     HeapFree(GetProcessHeap(), 0, deadDomain->lpCookiePath);
270
271     list_remove(&deadDomain->entry);
272
273     HeapFree(GetProcessHeap(), 0, deadDomain);
274 }
275
276 /***********************************************************************
277  *           InternetGetCookieW (WININET.@)
278  *
279  * Retrieve cookie from the specified url
280  *
281  *  It should be noted that on windows the lpszCookieName parameter is "not implemented".
282  *    So it won't be implemented here.
283  *
284  * RETURNS
285  *    TRUE  on success
286  *    FALSE on failure
287  *
288  */
289 BOOL WINAPI InternetGetCookieW(LPCWSTR lpszUrl, LPCWSTR lpszCookieName,
290     LPWSTR lpCookieData, LPDWORD lpdwSize)
291 {
292     BOOL ret;
293     struct list * cursor;
294     unsigned int cnt = 0, domain_count = 0, cookie_count = 0;
295     WCHAR hostName[2048], path[2048];
296     FILETIME tm;
297
298     TRACE("(%s, %s, %p, %p)\n", debugstr_w(lpszUrl),debugstr_w(lpszCookieName),
299           lpCookieData, lpdwSize);
300
301     if (!lpszUrl)
302     {
303         SetLastError(ERROR_INVALID_PARAMETER);
304         return FALSE;
305     }
306
307     hostName[0] = 0;
308     ret = COOKIE_crackUrlSimple(lpszUrl, hostName, sizeof(hostName)/sizeof(hostName[0]), path, sizeof(path)/sizeof(path[0]));
309     if (!ret || !hostName[0]) return FALSE;
310
311     GetSystemTimeAsFileTime(&tm);
312
313     LIST_FOR_EACH(cursor, &domain_list)
314     {
315         cookie_domain *cookiesDomain = LIST_ENTRY(cursor, cookie_domain, entry);
316         if (COOKIE_matchDomain(hostName, path, cookiesDomain, TRUE))
317         {
318             struct list * cursor;
319             domain_count++;
320             TRACE("found domain %p\n", cookiesDomain);
321     
322             LIST_FOR_EACH(cursor, &cookiesDomain->cookie_list)
323             {
324                 cookie *thisCookie = LIST_ENTRY(cursor, cookie, entry);
325                 /* check for expiry */
326                 if ((thisCookie->expiry.dwLowDateTime != 0 || thisCookie->expiry.dwHighDateTime != 0) && CompareFileTime(&tm,&thisCookie->expiry)  > 0)
327                 {
328                     TRACE("Found expired cookie. deleting\n");
329                     COOKIE_deleteCookie(thisCookie, FALSE);
330                     continue;
331                 }
332
333                 if (lpCookieData == NULL) /* return the size of the buffer required to lpdwSize */
334                 {
335                     unsigned int len;
336
337                     if (cookie_count) cnt += 2; /* '; ' */
338                     cnt += strlenW(thisCookie->lpCookieName);
339                     if ((len = strlenW(thisCookie->lpCookieData)))
340                     {
341                         cnt += 1; /* = */
342                         cnt += len;
343                     }
344                 }
345                 else
346                 {
347                     static const WCHAR szsc[] = { ';',' ',0 };
348                     static const WCHAR szname[] = { '%','s',0 };
349                     static const WCHAR szdata[] = { '=','%','s',0 };
350
351                     if (cookie_count) cnt += snprintfW(lpCookieData + cnt, *lpdwSize - cnt, szsc);
352                     cnt += snprintfW(lpCookieData + cnt, *lpdwSize - cnt, szname, thisCookie->lpCookieName);
353
354                     if (thisCookie->lpCookieData[0])
355                         cnt += snprintfW(lpCookieData + cnt, *lpdwSize - cnt, szdata, thisCookie->lpCookieData);
356
357                     TRACE("Cookie: %s\n", debugstr_w(lpCookieData));
358                 }
359                 cookie_count++;
360             }
361         }
362     }
363
364     if (!domain_count)
365     {
366         TRACE("no cookies found for %s\n", debugstr_w(hostName));
367         SetLastError(ERROR_NO_MORE_ITEMS);
368         return FALSE;
369     }
370
371     if (lpCookieData == NULL)
372     {
373         *lpdwSize = (cnt + 1) * sizeof(WCHAR);
374         TRACE("returning %u\n", *lpdwSize);
375         return TRUE;
376     }
377
378     *lpdwSize = cnt + 1;
379
380     TRACE("Returning %u (from %u domains): %s\n", cnt, domain_count,
381            debugstr_w(lpCookieData));
382
383     return (cnt ? TRUE : FALSE);
384 }
385
386
387 /***********************************************************************
388  *           InternetGetCookieA (WININET.@)
389  *
390  * Retrieve cookie from the specified url
391  *
392  * RETURNS
393  *    TRUE  on success
394  *    FALSE on failure
395  *
396  */
397 BOOL WINAPI InternetGetCookieA(LPCSTR lpszUrl, LPCSTR lpszCookieName,
398     LPSTR lpCookieData, LPDWORD lpdwSize)
399 {
400     DWORD len;
401     LPWSTR szCookieData = NULL, szUrl = NULL, szCookieName = NULL;
402     BOOL r;
403
404     TRACE("(%s,%s,%p)\n", debugstr_a(lpszUrl), debugstr_a(lpszCookieName),
405         lpCookieData);
406
407     if( lpszUrl )
408     {
409         len = MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, NULL, 0 );
410         szUrl = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
411         MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, szUrl, len );
412     }
413
414     if( lpszCookieName )
415     {
416         len = MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, NULL, 0 );
417         szCookieName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
418         MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, szCookieName, len );
419     }
420
421     r = InternetGetCookieW( szUrl, szCookieName, NULL, &len );
422     if( r )
423     {
424         szCookieData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
425         if( !szCookieData )
426         {
427             r = FALSE;
428         }
429         else
430         {
431             r = InternetGetCookieW( szUrl, szCookieName, szCookieData, &len );
432
433             *lpdwSize = WideCharToMultiByte( CP_ACP, 0, szCookieData, len,
434                                     lpCookieData, *lpdwSize, NULL, NULL );
435         }
436     }
437
438     HeapFree( GetProcessHeap(), 0, szCookieData );
439     HeapFree( GetProcessHeap(), 0, szCookieName );
440     HeapFree( GetProcessHeap(), 0, szUrl );
441
442     return r;
443 }
444
445 static BOOL set_cookie(LPCWSTR domain, LPCWSTR path, LPCWSTR cookie_name, LPCWSTR cookie_data)
446 {
447     cookie_domain *thisCookieDomain = NULL;
448     cookie *thisCookie;
449     struct list *cursor;
450     LPWSTR data, value;
451     WCHAR *ptr;
452     FILETIME expiry;
453     BOOL expired = FALSE;
454
455     value = data = HeapAlloc(GetProcessHeap(), 0, (strlenW(cookie_data) + 1) * sizeof(WCHAR));
456     strcpyW(data,cookie_data);
457     memset(&expiry,0,sizeof(expiry));
458
459     /* lots of information can be parsed out of the cookie value */
460
461     ptr = data;
462     for (;;)
463     {
464         static const WCHAR szDomain[] = {'d','o','m','a','i','n','=',0};
465         static const WCHAR szPath[] = {'p','a','t','h','=',0};
466         static const WCHAR szExpires[] = {'e','x','p','i','r','e','s','=',0};
467         static const WCHAR szSecure[] = {'s','e','c','u','r','e',0};
468         static const WCHAR szHttpOnly[] = {'h','t','t','p','o','n','l','y',0};
469
470         if (!(ptr = strchrW(ptr,';'))) break;
471         *ptr++ = 0;
472
473         value = HeapAlloc(GetProcessHeap(), 0, (ptr - data) * sizeof(WCHAR));
474         strcpyW(value, data);
475
476         while (*ptr == ' ') ptr++; /* whitespace */
477
478         if (strncmpiW(ptr, szDomain, 7) == 0)
479         {
480             ptr+=strlenW(szDomain);
481             domain = ptr;
482             TRACE("Parsing new domain %s\n",debugstr_w(domain));
483         }
484         else if (strncmpiW(ptr, szPath, 5) == 0)
485         {
486             ptr+=strlenW(szPath);
487             path = ptr;
488             TRACE("Parsing new path %s\n",debugstr_w(path));
489         }
490         else if (strncmpiW(ptr, szExpires, 8) == 0)
491         {
492             FILETIME ft;
493             SYSTEMTIME st;
494             FIXME("persistent cookies not handled (%s)\n",debugstr_w(ptr));
495             ptr+=strlenW(szExpires);
496             if (InternetTimeToSystemTimeW(ptr, &st, 0))
497             {
498                 SystemTimeToFileTime(&st, &expiry);
499                 GetSystemTimeAsFileTime(&ft);
500
501                 if (CompareFileTime(&ft,&expiry) > 0)
502                 {
503                     TRACE("Cookie already expired.\n");
504                     expired = TRUE;
505                 }
506             }
507         }
508         else if (strncmpiW(ptr, szSecure, 6) == 0)
509         {
510             FIXME("secure not handled (%s)\n",debugstr_w(ptr));
511             ptr += strlenW(szSecure);
512         }
513         else if (strncmpiW(ptr, szHttpOnly, 8) == 0)
514         {
515             FIXME("httponly not handled (%s)\n",debugstr_w(ptr));
516             ptr += strlenW(szHttpOnly);
517         }
518         else if (*ptr)
519         {
520             FIXME("Unknown additional option %s\n",debugstr_w(ptr));
521             break;
522         }
523     }
524
525     LIST_FOR_EACH(cursor, &domain_list)
526     {
527         thisCookieDomain = LIST_ENTRY(cursor, cookie_domain, entry);
528         if (COOKIE_matchDomain(domain, path, thisCookieDomain, FALSE))
529             break;
530         thisCookieDomain = NULL;
531     }
532
533     if (!thisCookieDomain)
534     {
535         if (!expired)
536             thisCookieDomain = COOKIE_addDomain(domain, path);
537         else
538         {
539             HeapFree(GetProcessHeap(),0,data);
540             if (value != data) HeapFree(GetProcessHeap(), 0, value);
541             return TRUE;
542         }
543     }
544
545     if ((thisCookie = COOKIE_findCookie(thisCookieDomain, cookie_name)))
546         COOKIE_deleteCookie(thisCookie, FALSE);
547
548     TRACE("setting cookie %s=%s for domain %s path %s\n", debugstr_w(cookie_name),
549           debugstr_w(value), debugstr_w(thisCookieDomain->lpCookieDomain),debugstr_w(thisCookieDomain->lpCookiePath));
550
551     if (!expired && !COOKIE_addCookie(thisCookieDomain, cookie_name, value, expiry))
552     {
553         HeapFree(GetProcessHeap(),0,data);
554         if (value != data) HeapFree(GetProcessHeap(), 0, value);
555         return FALSE;
556     }
557
558     HeapFree(GetProcessHeap(),0,data);
559     if (value != data) HeapFree(GetProcessHeap(), 0, value);
560     return TRUE;
561 }
562
563 /***********************************************************************
564  *           InternetSetCookieW (WININET.@)
565  *
566  * Sets cookie for the specified url
567  *
568  * RETURNS
569  *    TRUE  on success
570  *    FALSE on failure
571  *
572  */
573 BOOL WINAPI InternetSetCookieW(LPCWSTR lpszUrl, LPCWSTR lpszCookieName,
574     LPCWSTR lpCookieData)
575 {
576     BOOL ret;
577     WCHAR hostName[2048], path[2048];
578
579     TRACE("(%s,%s,%s)\n", debugstr_w(lpszUrl),
580         debugstr_w(lpszCookieName), debugstr_w(lpCookieData));
581
582     if (!lpszUrl || !lpCookieData)
583     {
584         SetLastError(ERROR_INVALID_PARAMETER);
585         return FALSE;
586     }
587
588     hostName[0] = path[0] = 0;
589     ret = COOKIE_crackUrlSimple(lpszUrl, hostName, sizeof(hostName)/sizeof(hostName[0]), path, sizeof(path)/sizeof(path[0]));
590     if (!ret || !hostName[0]) return FALSE;
591
592     if (!lpszCookieName)
593     {
594         unsigned int len;
595         WCHAR *cookie, *data;
596
597         len = strlenW(lpCookieData);
598         if (!(cookie = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR))))
599         {
600             SetLastError(ERROR_OUTOFMEMORY);
601             return FALSE;
602         }
603         strcpyW(cookie, lpCookieData);
604
605         /* some apps (or is it us??) try to add a cookie with no cookie name, but
606          * the cookie data in the form of name[=data].
607          */
608         if (!(data = strchrW(cookie, '='))) data = cookie + len;
609         else *data++ = 0;
610
611         ret = set_cookie(hostName, path, cookie, data);
612
613         HeapFree(GetProcessHeap(), 0, cookie);
614         return ret;
615     }
616     return set_cookie(hostName, path, lpszCookieName, lpCookieData);
617 }
618
619
620 /***********************************************************************
621  *           InternetSetCookieA (WININET.@)
622  *
623  * Sets cookie for the specified url
624  *
625  * RETURNS
626  *    TRUE  on success
627  *    FALSE on failure
628  *
629  */
630 BOOL WINAPI InternetSetCookieA(LPCSTR lpszUrl, LPCSTR lpszCookieName,
631     LPCSTR lpCookieData)
632 {
633     DWORD len;
634     LPWSTR szCookieData = NULL, szUrl = NULL, szCookieName = NULL;
635     BOOL r;
636
637     TRACE("(%s,%s,%s)\n", debugstr_a(lpszUrl),
638         debugstr_a(lpszCookieName), debugstr_a(lpCookieData));
639
640     if( lpszUrl )
641     {
642         len = MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, NULL, 0 );
643         szUrl = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
644         MultiByteToWideChar( CP_ACP, 0, lpszUrl, -1, szUrl, len );
645     }
646
647     if( lpszCookieName )
648     {
649         len = MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, NULL, 0 );
650         szCookieName = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
651         MultiByteToWideChar( CP_ACP, 0, lpszCookieName, -1, szCookieName, len );
652     }
653
654     if( lpCookieData )
655     {
656         len = MultiByteToWideChar( CP_ACP, 0, lpCookieData, -1, NULL, 0 );
657         szCookieData = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
658         MultiByteToWideChar( CP_ACP, 0, lpCookieData, -1, szCookieData, len );
659     }
660
661     r = InternetSetCookieW( szUrl, szCookieName, szCookieData );
662
663     HeapFree( GetProcessHeap(), 0, szCookieData );
664     HeapFree( GetProcessHeap(), 0, szCookieName );
665     HeapFree( GetProcessHeap(), 0, szUrl );
666
667     return r;
668 }
669
670 /***********************************************************************
671  *           InternetSetCookieExA (WININET.@)
672  *
673  * See InternetSetCookieExW.
674  */
675 DWORD WINAPI InternetSetCookieExA( LPCSTR lpszURL, LPCSTR lpszCookieName, LPCSTR lpszCookieData,
676                                    DWORD dwFlags, DWORD_PTR dwReserved)
677 {
678     TRACE("(%s, %s, %s, 0x%08x, 0x%08lx)\n",
679           debugstr_a(lpszURL), debugstr_a(lpszCookieName), debugstr_a(lpszCookieData),
680           dwFlags, dwReserved);
681
682     if (dwFlags) FIXME("flags 0x%08x not supported\n", dwFlags);
683     return InternetSetCookieA(lpszURL, lpszCookieName, lpszCookieData);
684 }
685
686 /***********************************************************************
687  *           InternetSetCookieExW (WININET.@)
688  *
689  * Sets a cookie for the specified URL.
690  *
691  * RETURNS
692  *    TRUE  on success
693  *    FALSE on failure
694  *
695  */
696 DWORD WINAPI InternetSetCookieExW( LPCWSTR lpszURL, LPCWSTR lpszCookieName, LPCWSTR lpszCookieData,
697                                    DWORD dwFlags, DWORD_PTR dwReserved)
698 {
699     TRACE("(%s, %s, %s, 0x%08x, 0x%08lx)\n",
700           debugstr_w(lpszURL), debugstr_w(lpszCookieName), debugstr_w(lpszCookieData),
701           dwFlags, dwReserved);
702
703     if (dwFlags) FIXME("flags 0x%08x not supported\n", dwFlags);
704     return InternetSetCookieW(lpszURL, lpszCookieName, lpszCookieData);
705 }
706
707 /***********************************************************************
708  *           InternetGetCookieExA (WININET.@)
709  *
710  * See InternetGetCookieExW.
711  */
712 BOOL WINAPI InternetGetCookieExA( LPCSTR pchURL, LPCSTR pchCookieName, LPSTR pchCookieData,
713                                   LPDWORD pcchCookieData, DWORD dwFlags, LPVOID lpReserved)
714 {
715     TRACE("(%s, %s, %s, %p, 0x%08x, %p)\n",
716           debugstr_a(pchURL), debugstr_a(pchCookieName), debugstr_a(pchCookieData),
717           pcchCookieData, dwFlags, lpReserved);
718
719     if (dwFlags) FIXME("flags 0x%08x not supported\n", dwFlags);
720     return InternetGetCookieA(pchURL, pchCookieName, pchCookieData, pcchCookieData);
721 }
722
723 /***********************************************************************
724  *           InternetGetCookieExW (WININET.@)
725  *
726  * Retrieve cookie for the specified URL.
727  *
728  * RETURNS
729  *    TRUE  on success
730  *    FALSE on failure
731  *
732  */
733 BOOL WINAPI InternetGetCookieExW( LPCWSTR pchURL, LPCWSTR pchCookieName, LPWSTR pchCookieData,
734                                   LPDWORD pcchCookieData, DWORD dwFlags, LPVOID lpReserved)
735 {
736     TRACE("(%s, %s, %s, %p, 0x%08x, %p)\n",
737           debugstr_w(pchURL), debugstr_w(pchCookieName), debugstr_w(pchCookieData),
738           pcchCookieData, dwFlags, lpReserved);
739
740     if (dwFlags) FIXME("flags 0x%08x not supported\n", dwFlags);
741     return InternetGetCookieW(pchURL, pchCookieName, pchCookieData, pcchCookieData);
742 }
743
744 /***********************************************************************
745  *           InternetClearAllPerSiteCookieDecisions (WININET.@)
746  *
747  * Clears all per-site decisions about cookies.
748  *
749  * RETURNS
750  *    TRUE  on success
751  *    FALSE on failure
752  *
753  */
754 BOOL WINAPI InternetClearAllPerSiteCookieDecisions( VOID )
755 {
756     FIXME("stub\n");
757     return TRUE;
758 }
759
760 /***********************************************************************
761  *           InternetEnumPerSiteCookieDecisionA (WININET.@)
762  *
763  * See InternetEnumPerSiteCookieDecisionW.
764  */
765 BOOL WINAPI InternetEnumPerSiteCookieDecisionA( LPSTR pszSiteName, ULONG *pcSiteNameSize,
766                                                 ULONG *pdwDecision, ULONG dwIndex )
767 {
768     FIXME("(%s, %p, %p, 0x%08x) stub\n",
769           debugstr_a(pszSiteName), pcSiteNameSize, pdwDecision, dwIndex);
770     return FALSE;
771 }
772
773 /***********************************************************************
774  *           InternetEnumPerSiteCookieDecisionW (WININET.@)
775  *
776  * Enumerates all per-site decisions about cookies.
777  *
778  * RETURNS
779  *    TRUE  on success
780  *    FALSE on failure
781  *
782  */
783 BOOL WINAPI InternetEnumPerSiteCookieDecisionW( LPWSTR pszSiteName, ULONG *pcSiteNameSize,
784                                                 ULONG *pdwDecision, ULONG dwIndex )
785 {
786     FIXME("(%s, %p, %p, 0x%08x) stub\n",
787           debugstr_w(pszSiteName), pcSiteNameSize, pdwDecision, dwIndex);
788     return FALSE;
789 }
790
791 /***********************************************************************
792  *           InternetGetPerSiteCookieDecisionA (WININET.@)
793  */
794 BOOL WINAPI InternetGetPerSiteCookieDecisionA( LPCSTR pwchHostName, ULONG *pResult )
795 {
796     FIXME("(%s, %p) stub\n", debugstr_a(pwchHostName), pResult);
797     return FALSE;
798 }
799
800 /***********************************************************************
801  *           InternetGetPerSiteCookieDecisionW (WININET.@)
802  */
803 BOOL WINAPI InternetGetPerSiteCookieDecisionW( LPCWSTR pwchHostName, ULONG *pResult )
804 {
805     FIXME("(%s, %p) stub\n", debugstr_w(pwchHostName), pResult);
806     return FALSE;
807 }
808
809 /***********************************************************************
810  *           InternetSetPerSiteCookieDecisionA (WININET.@)
811  */
812 BOOL WINAPI InternetSetPerSiteCookieDecisionA( LPCSTR pchHostName, DWORD dwDecision )
813 {
814     FIXME("(%s, 0x%08x) stub\n", debugstr_a(pchHostName), dwDecision);
815     return FALSE;
816 }
817
818 /***********************************************************************
819  *           InternetSetPerSiteCookieDecisionW (WININET.@)
820  */
821 BOOL WINAPI InternetSetPerSiteCookieDecisionW( LPCWSTR pchHostName, DWORD dwDecision )
822 {
823     FIXME("(%s, 0x%08x) stub\n", debugstr_w(pchHostName), dwDecision);
824     return FALSE;
825 }
826
827 /***********************************************************************
828  *           IsDomainLegalCookieDomainW (WININET.@)
829  */
830 BOOL WINAPI IsDomainLegalCookieDomainW( LPCWSTR s1, LPCWSTR s2 )
831 {
832     const WCHAR *p;
833
834     FIXME("(%s, %s)\n", debugstr_w(s1), debugstr_w(s2));
835
836     if (!s1 || !s2)
837     {
838         SetLastError(ERROR_INVALID_PARAMETER);
839         return FALSE;
840     }
841     if (s1[0] == '.' || !s1[0] || s2[0] == '.' || !s2[0])
842     {
843         SetLastError(ERROR_INVALID_NAME);
844         return FALSE;
845     }
846     if (!(p = strchrW(s2, '.'))) return FALSE;
847     if (strchrW(p + 1, '.') && !strcmpW(p + 1, s1)) return TRUE;
848     else if (!strcmpW(s1, s2)) return TRUE;
849     return FALSE;
850 }