wined3d: Use shader_sm1_read_opcode() in shader_get_registers_used().
[wine] / dlls / winhttp / cookie.c
1 /*
2  * Copyright 2008 Hans Leidekker for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20 #include <stdarg.h>
21
22 #include "wine/debug.h"
23 #include "wine/list.h"
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winhttp.h"
28
29 #include "winhttp_private.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
32
33 static domain_t *add_domain( session_t *session, WCHAR *name )
34 {
35     domain_t *domain;
36
37     if (!(domain = heap_alloc_zero( sizeof(domain_t) ))) return NULL;
38
39     list_init( &domain->entry );
40     list_init( &domain->cookies );
41
42     domain->name = name;
43     list_add_tail( &session->cookie_cache, &domain->entry );
44
45     TRACE("%s\n", debugstr_w(domain->name));
46     return domain;
47 }
48
49 static cookie_t *find_cookie( domain_t *domain, const WCHAR *path, const WCHAR *name )
50 {
51     struct list *item;
52     cookie_t *cookie;
53
54     LIST_FOR_EACH( item, &domain->cookies )
55     {
56         cookie = LIST_ENTRY( item, cookie_t, entry );
57         if (!strcmpW( cookie->path, path ) && !strcmpiW( cookie->name, name ))
58         {
59             TRACE("found %s=%s\n", debugstr_w(cookie->name), debugstr_w(cookie->value));
60             return cookie;
61          }
62     }
63     return NULL;
64 }
65
66 static BOOL domain_match( const WCHAR *name, domain_t *domain, BOOL partial )
67 {
68     TRACE("comparing %s with %s\n", debugstr_w(name), debugstr_w(domain->name));
69
70     if (partial && !strstrW( name, domain->name )) return FALSE;
71     else if (!partial && strcmpW( name, domain->name )) return FALSE;
72     return TRUE;
73 }
74
75 static void free_cookie( cookie_t *cookie )
76 {
77     heap_free( cookie->name );
78     heap_free( cookie->value );
79     heap_free( cookie->path );
80     heap_free( cookie );
81 }
82
83 static void delete_cookie( cookie_t *cookie )
84 {
85     list_remove( &cookie->entry );
86     free_cookie( cookie );
87 }
88
89 void delete_domain( domain_t *domain )
90 {
91     cookie_t *cookie;
92     struct list *item, *next;
93
94     LIST_FOR_EACH_SAFE( item, next, &domain->cookies )
95     {
96         cookie = LIST_ENTRY( item, cookie_t, entry );
97         delete_cookie( cookie );
98     }
99
100     list_remove( &domain->entry );
101     heap_free( domain->name );
102     heap_free( domain );
103 }
104
105 static BOOL add_cookie( session_t *session, cookie_t *cookie, WCHAR *domain_name, WCHAR *path )
106 {
107     domain_t *domain = NULL;
108     cookie_t *old_cookie;
109     struct list *item;
110
111     LIST_FOR_EACH( item, &session->cookie_cache )
112     {
113         domain = LIST_ENTRY( item, domain_t, entry );
114         if (domain_match( domain_name, domain, FALSE )) break;
115         domain = NULL;
116     }
117     if (!domain)
118     {
119         if (!(domain = add_domain( session, domain_name ))) return FALSE;
120     }
121     else if ((old_cookie = find_cookie( domain, path, cookie->name ))) delete_cookie( old_cookie );
122
123     cookie->path = path;
124     list_add_tail( &domain->cookies, &cookie->entry );
125
126     TRACE("domain %s path %s <- %s=%s\n", debugstr_w(domain_name), debugstr_w(cookie->path),
127           debugstr_w(cookie->name), debugstr_w(cookie->value));
128     return TRUE;
129 }
130
131 static cookie_t *parse_cookie( const WCHAR *string )
132 {
133     cookie_t *cookie;
134     const WCHAR *p;
135     int len;
136
137     if (!(cookie = heap_alloc_zero( sizeof(cookie_t) ))) return NULL;
138
139     list_init( &cookie->entry );
140
141     if (!(p = strchrW( string, '=' )))
142     {
143         WARN("no '=' in %s\n", debugstr_w(string));
144         return NULL;
145     }
146     if (p == string)
147     {
148         WARN("empty cookie name in %s\n", debugstr_w(string));
149         return NULL;
150     }
151     len = p - string;
152     if (!(cookie->name = heap_alloc( (len + 1) * sizeof(WCHAR) )))
153     {
154         heap_free( cookie );
155         return NULL;
156     }
157     memcpy( cookie->name, string, len * sizeof(WCHAR) );
158     cookie->name[len] = 0;
159
160     p++; /* skip '=' */
161     while (*p == ' ') p++;
162
163     len = strlenW( p );
164     if (!(cookie->value = heap_alloc( (len + 1) * sizeof(WCHAR) )))
165     {
166         free_cookie( cookie );
167         return NULL;
168     }
169     memcpy( cookie->value, p, len * sizeof(WCHAR) );
170     cookie->value[len] = 0;
171
172     return cookie;
173 }
174
175 BOOL set_cookies( request_t *request, const WCHAR *cookies )
176 {
177     static const WCHAR pathW[] = {'p','a','t','h',0};
178     static const WCHAR domainW[] = {'d','o','m','a','i','n',0};
179
180     BOOL ret = FALSE;
181     WCHAR *buffer, *p, *q, *r;
182     WCHAR *cookie_domain = NULL, *cookie_path = NULL;
183     session_t *session = request->connect->session;
184     cookie_t *cookie;
185     int len;
186
187     len = strlenW( cookies );
188     if (!(buffer = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
189     strcpyW( buffer, cookies );
190
191     p = buffer;
192     while (*p && *p != ';') p++;
193     if (*p == ';') *p++ = 0;
194     if (!(cookie = parse_cookie( buffer )))
195     {
196         heap_free( buffer );
197         return FALSE;
198     }
199     if ((q = strstrW( p, domainW ))) /* FIXME: do real attribute parsing */
200     {
201         while (*q && *q != '=') q++;
202         if (!*q) goto end;
203
204         r = ++q;
205         while (*r && *r != ';') r++;
206         len = r - q;
207
208         if (!(cookie_domain = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
209         memcpy( cookie_domain, q, len * sizeof(WCHAR) );
210         cookie_domain[len] = 0;
211
212     }
213     if ((q = strstrW( p, pathW )))
214     {
215         while (*q && *q != '=') q++;
216         if (!*q) goto end;
217
218         r = ++q;
219         while (*r && *r != ';') r++;
220         len = r - q;
221
222         if (!(cookie_path = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto end;
223         memcpy( cookie_path, q, len * sizeof(WCHAR) );
224         cookie_path[len] = 0;
225     }
226     if (!cookie_domain && !(cookie_domain = strdupW( request->connect->servername ))) goto end;
227     if (!cookie_path && !(cookie_path = strdupW( request->path ))) goto end;
228
229     if ((p = strrchrW( cookie_path, '/' )) && p != cookie_path) *p = 0;
230     ret = add_cookie( session, cookie, cookie_domain, cookie_path );
231
232 end:
233     if (!ret)
234     {
235         free_cookie( cookie );
236         heap_free( cookie_domain );
237         heap_free( cookie_path );
238     }
239     heap_free( buffer );
240     return ret;
241 }
242
243 BOOL add_cookie_headers( request_t *request )
244 {
245     struct list *domain_cursor;
246     session_t *session = request->connect->session;
247
248     LIST_FOR_EACH( domain_cursor, &session->cookie_cache )
249     {
250         domain_t *domain = LIST_ENTRY( domain_cursor, domain_t, entry );
251         if (domain_match( request->connect->servername, domain, TRUE ))
252         {
253             struct list *cookie_cursor;
254             TRACE("found domain %s\n", debugstr_w(domain->name));
255
256             LIST_FOR_EACH( cookie_cursor, &domain->cookies )
257             {
258                 cookie_t *cookie = LIST_ENTRY( cookie_cursor, cookie_t, entry );
259
260                 TRACE("comparing path %s with %s\n", debugstr_w(request->path), debugstr_w(cookie->path));
261
262                 if (strstrW( request->path, cookie->path ) == request->path)
263                 {
264                     const WCHAR format[] = {'C','o','o','k','i','e',':',' ','%','s','=','%','s',0};
265                     int len;
266                     WCHAR *header;
267
268                     len = strlenW( cookie->name ) + strlenW( format ) + strlenW( cookie->value );
269                     if (!(header = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return FALSE;
270
271                     sprintfW( header, format, cookie->name, cookie->value );
272
273                     TRACE("%s\n", debugstr_w(header));
274                     add_request_headers( request, header, len, WINHTTP_ADDREQ_FLAG_ADD );
275                     heap_free( header );
276                 }
277             }
278         }
279     }
280     return TRUE;
281 }