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