vbscript: Added support for sub local variables.
[wine] / dlls / winhttp / url.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
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winreg.h"
27 #include "winhttp.h"
28 #include "shlwapi.h"
29
30 #include "winhttp_private.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(winhttp);
33
34 static const WCHAR scheme_http[] = {'h','t','t','p',0};
35 static const WCHAR scheme_https[] = {'h','t','t','p','s',0};
36
37 static BOOL set_component( WCHAR **str, DWORD *str_len, WCHAR *value, DWORD len, DWORD flags )
38 {
39     if (!*str)
40     {
41         if (len && (flags & ICU_DECODE))
42         {
43             set_last_error( ERROR_INVALID_PARAMETER );
44             return FALSE;
45         }
46         *str = value;
47         *str_len = len;
48     }
49     else
50     {
51         if (len > (*str_len) - 1)
52         {
53             *str_len = len + 1;
54             set_last_error( ERROR_INSUFFICIENT_BUFFER );
55             return FALSE;
56         }
57         memcpy( *str, value, len * sizeof(WCHAR) );
58         (*str)[len] = 0;
59         *str_len = len;
60     }
61     return TRUE;
62 }
63
64 static WCHAR *decode_url( LPCWSTR url, DWORD *len )
65 {
66     const WCHAR *p = url;
67     WCHAR hex[3], *q, *ret;
68
69     if (!(ret = heap_alloc( *len * sizeof(WCHAR) ))) return NULL;
70     q = ret;
71     while (*len > 0)
72     {
73         if (p[0] == '%' && isxdigitW( p[1] ) && isxdigitW( p[2] ))
74         {
75             hex[0] = p[1];
76             hex[1] = p[2];
77             hex[2] = 0;
78             *q++ = strtolW( hex, NULL, 16 );
79             p += 3;
80             *len -= 3;
81         }
82         else
83         {
84             *q++ = *p++;
85             *len -= 1;
86         }
87     }
88     *len = q - ret;
89     return ret;
90 }
91
92 /***********************************************************************
93  *          WinHttpCrackUrl (winhttp.@)
94  */
95 BOOL WINAPI WinHttpCrackUrl( LPCWSTR url, DWORD len, DWORD flags, LPURL_COMPONENTSW uc )
96 {
97     BOOL ret = FALSE;
98     WCHAR *p, *q, *r, *url_decoded = NULL;
99
100     TRACE("%s, %d, %x, %p\n", debugstr_w(url), len, flags, uc);
101
102     if (flags & ICU_ESCAPE) FIXME("flag ICU_ESCAPE not supported\n");
103
104     if (!url || !uc || uc->dwStructSize != sizeof(URL_COMPONENTS))
105     {
106         set_last_error( ERROR_INVALID_PARAMETER );
107         return FALSE;
108     }
109     if (!len) len = strlenW( url );
110
111     if (flags & ICU_DECODE)
112     {
113         if (!(url_decoded = decode_url( url, &len )))
114         {
115             set_last_error( ERROR_OUTOFMEMORY );
116             return FALSE;
117         }
118         url = url_decoded;
119     }
120     if (!(p = strchrW( url, ':' )))
121     {
122         set_last_error( ERROR_WINHTTP_UNRECOGNIZED_SCHEME );
123         return FALSE;
124     }
125     if (p - url == 4 && !strncmpiW( url, scheme_http, 4 )) uc->nScheme = INTERNET_SCHEME_HTTP;
126     else if (p - url == 5 && !strncmpiW( url, scheme_https, 5 )) uc->nScheme = INTERNET_SCHEME_HTTPS;
127     else
128     {
129         set_last_error( ERROR_WINHTTP_UNRECOGNIZED_SCHEME );
130         goto exit;
131     }
132     if (!(set_component( &uc->lpszScheme, &uc->dwSchemeLength, (WCHAR *)url, p - url, flags ))) goto exit;
133
134     p++; /* skip ':' */
135     if (!p[0] || p[0] != '/' || p[1] != '/') goto exit;
136     p += 2;
137
138     if (!p[0]) goto exit;
139     if ((q = memchrW( p, '@', len - (p - url) )) && !(memchrW( p, '/', q - p )))
140     {
141         if ((r = memchrW( p, ':', q - p )))
142         {
143             if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength, p, r - p, flags ))) goto exit;
144             r++;
145             if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength, r, q - r, flags ))) goto exit;
146         }
147         else
148         {
149             if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength, p, q - p, flags ))) goto exit;
150             if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength, NULL, 0, flags ))) goto exit;
151         }
152         p = q + 1;
153     }
154     else
155     {
156         if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength, NULL, 0, flags ))) goto exit;
157         if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength, NULL, 0, flags ))) goto exit;
158     }
159     if ((q = memchrW( p, '/', len - (p - url) )))
160     {
161         if ((r = memchrW( p, ':', q - p )))
162         {
163             if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength, p, r - p, flags ))) goto exit;
164             r++;
165             uc->nPort = atoiW( r );
166         }
167         else
168         {
169             if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength, p, q - p, flags ))) goto exit;
170             if (uc->nScheme == INTERNET_SCHEME_HTTP) uc->nPort = INTERNET_DEFAULT_HTTP_PORT;
171             if (uc->nScheme == INTERNET_SCHEME_HTTPS) uc->nPort = INTERNET_DEFAULT_HTTPS_PORT;
172         }
173
174         if ((r = memchrW( q, '?', len - (q - url) )))
175         {
176             if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, q, r - q, flags ))) goto exit;
177             if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength, r, len - (r - url), flags ))) goto exit;
178         }
179         else
180         {
181             if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, q, len - (q - url), flags ))) goto exit;
182             if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength, (WCHAR *)url + len, 0, flags ))) goto exit;
183         }
184     }
185     else
186     {
187         if ((r = memchrW( p, ':', len - (p - url) )))
188         {
189             if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength, p, r - p, flags ))) goto exit;
190             r++;
191             uc->nPort = atoiW( r );
192         }
193         else
194         {
195             if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength, p, len - (p - url), flags ))) goto exit;
196             if (uc->nScheme == INTERNET_SCHEME_HTTP) uc->nPort = INTERNET_DEFAULT_HTTP_PORT;
197             if (uc->nScheme == INTERNET_SCHEME_HTTPS) uc->nPort = INTERNET_DEFAULT_HTTPS_PORT;
198         }
199         if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, (WCHAR *)url + len, 0, flags ))) goto exit;
200         if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength, (WCHAR *)url + len, 0, flags ))) goto exit;
201     }
202
203     ret = TRUE;
204
205     TRACE("scheme(%s) host(%s) port(%d) path(%s) extra(%s)\n",
206           debugstr_wn( uc->lpszScheme, uc->dwSchemeLength ),
207           debugstr_wn( uc->lpszHostName, uc->dwHostNameLength ),
208           uc->nPort,
209           debugstr_wn( uc->lpszUrlPath, uc->dwUrlPathLength ),
210           debugstr_wn( uc->lpszExtraInfo, uc->dwExtraInfoLength ));
211
212 exit:
213     HeapFree( GetProcessHeap(), 0, url_decoded );
214     return ret;
215 }
216
217 static INTERNET_SCHEME get_scheme( const WCHAR *scheme, DWORD len )
218 {
219     if (!strncmpW( scheme, scheme_http, len )) return INTERNET_SCHEME_HTTP;
220     if (!strncmpW( scheme, scheme_https, len )) return INTERNET_SCHEME_HTTPS;
221     return 0;
222 }
223
224 static const WCHAR *get_scheme_string( INTERNET_SCHEME scheme )
225 {
226     if (scheme == INTERNET_SCHEME_HTTP) return scheme_http;
227     if (scheme == INTERNET_SCHEME_HTTPS) return scheme_https;
228     return NULL;
229 }
230
231 static BOOL uses_default_port( INTERNET_SCHEME scheme, INTERNET_PORT port )
232 {
233     if ((scheme == INTERNET_SCHEME_HTTP) && (port == INTERNET_DEFAULT_HTTP_PORT)) return TRUE;
234     if ((scheme == INTERNET_SCHEME_HTTPS) && (port == INTERNET_DEFAULT_HTTPS_PORT)) return TRUE;
235     return FALSE;
236 }
237
238 static BOOL need_escape( WCHAR c )
239 {
240     if (isalnumW( c )) return FALSE;
241
242     if (c <= 31 || c >= 127) return TRUE;
243     else
244     {
245         switch (c)
246         {
247         case ' ':
248         case '"':
249         case '#':
250         case '%':
251         case '<':
252         case '>':
253         case ']':
254         case '\\':
255         case '[':
256         case '^':
257         case '`':
258         case '{':
259         case '|':
260         case '}':
261         case '~':
262             return TRUE;
263         default:
264             return FALSE;
265         }
266     }
267 }
268
269 static DWORD copy_escape( WCHAR *dst, const WCHAR *src, DWORD len )
270 {
271     static const WCHAR hex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
272     DWORD ret = len;
273     unsigned int i;
274     WCHAR *p = dst;
275
276     for (i = 0; i < len; i++, p++)
277     {
278         if (need_escape( src[i] ))
279         {
280             p[0] = '%';
281             p[1] = hex[(src[i] >> 4) & 0xf];
282             p[2] = hex[src[i] & 0xf];
283             ret += 2;
284             p += 2;
285         }
286         else *p = src[i];
287     }
288     dst[ret] = 0;
289     return ret;
290 }
291
292 static DWORD comp_length( DWORD len, DWORD flags, WCHAR *comp )
293 {
294     DWORD ret;
295     unsigned int i;
296
297     ret = len ? len : strlenW( comp );
298     if (!(flags & ICU_ESCAPE)) return ret;
299     for (i = 0; i < len; i++) if (need_escape( comp[i] )) ret += 2;
300     return ret;
301 }
302
303 static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len )
304 {
305     static const WCHAR formatW[] = {'%','u',0};
306     INTERNET_SCHEME scheme;
307
308     *len = 0;
309     if (uc->lpszScheme)
310     {
311         DWORD scheme_len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme );
312         *len += scheme_len;
313         scheme = get_scheme( uc->lpszScheme, scheme_len );
314     }
315     else
316     {
317         scheme = uc->nScheme;
318         if (!scheme) scheme = INTERNET_SCHEME_HTTP;
319         *len += strlenW( get_scheme_string( scheme ) );
320     }
321     *len += 1; /* ':' */
322     if (uc->lpszHostName) *len += 2; /* "//" */
323
324     if (uc->lpszUserName)
325     {
326         *len += comp_length( uc->dwUserNameLength, 0, uc->lpszUserName );
327         *len += 1; /* "@" */
328     }
329     else
330     {
331         if (uc->lpszPassword)
332         {
333             set_last_error( ERROR_INVALID_PARAMETER );
334             return FALSE;
335         }
336     }
337     if (uc->lpszPassword)
338     {
339         *len += 1; /* ":" */
340         *len += comp_length( uc->dwPasswordLength, 0, uc->lpszPassword );
341     }
342     if (uc->lpszHostName)
343     {
344         *len += comp_length( uc->dwHostNameLength, 0, uc->lpszHostName );
345
346         if (!uses_default_port( scheme, uc->nPort ))
347         {
348             WCHAR port[sizeof("65535")];
349
350             sprintfW( port, formatW, uc->nPort );
351             *len += strlenW( port );
352             *len += 1; /* ":" */
353         }
354         if (uc->lpszUrlPath && *uc->lpszUrlPath != '/') *len += 1; /* '/' */
355     }
356     if (uc->lpszUrlPath) *len += comp_length( uc->dwUrlPathLength, flags, uc->lpszUrlPath );
357     if (uc->lpszExtraInfo) *len += comp_length( uc->dwExtraInfoLength, flags, uc->lpszExtraInfo );
358     return TRUE;
359 }
360
361 /***********************************************************************
362  *          WinHttpCreateUrl (winhttp.@)
363  */
364 BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDWORD required )
365 {
366     static const WCHAR formatW[] = {'%','u',0};
367     static const WCHAR twoslashW[] = {'/','/'};
368
369     DWORD len;
370     INTERNET_SCHEME scheme;
371
372     TRACE("%p, 0x%08x, %p, %p\n", uc, flags, url, required);
373
374     if (!uc || uc->dwStructSize != sizeof(URL_COMPONENTS) || !required || !url)
375     {
376         set_last_error( ERROR_INVALID_PARAMETER );
377         return FALSE;
378     }
379
380     if (!calc_length( uc, flags, &len )) return FALSE;
381
382     if (*required < len)
383     {
384         *required = len + 1;
385         set_last_error( ERROR_INSUFFICIENT_BUFFER );
386         return FALSE;
387     }
388
389     url[0] = 0;
390     *required = len;
391     if (uc->lpszScheme)
392     {
393         len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme );
394         memcpy( url, uc->lpszScheme, len * sizeof(WCHAR) );
395         url += len;
396
397         scheme = get_scheme( uc->lpszScheme, len );
398     }
399     else
400     {
401         const WCHAR *schemeW;
402         scheme = uc->nScheme;
403
404         if (!scheme) scheme = INTERNET_SCHEME_HTTP;
405
406         schemeW = get_scheme_string( scheme );
407         len = strlenW( schemeW );
408         memcpy( url, schemeW, len * sizeof(WCHAR) );
409         url += len;
410     }
411
412     /* all schemes are followed by at least a colon */
413     *url = ':';
414     url++;
415
416     if (uc->lpszHostName)
417     {
418         memcpy( url, twoslashW, sizeof(twoslashW) );
419         url += sizeof(twoslashW) / sizeof(twoslashW[0]);
420     }
421     if (uc->lpszUserName)
422     {
423         len = comp_length( uc->dwUserNameLength, 0, uc->lpszUserName );
424         memcpy( url, uc->lpszUserName, len * sizeof(WCHAR) );
425         url += len;
426
427         if (uc->lpszPassword)
428         {
429             *url = ':';
430             url++;
431
432             len = comp_length( uc->dwPasswordLength, 0, uc->lpszPassword );
433             memcpy( url, uc->lpszPassword, len * sizeof(WCHAR) );
434             url += len;
435         }
436         *url = '@';
437         url++;
438     }
439     if (uc->lpszHostName)
440     {
441         len = comp_length( uc->dwHostNameLength, 0, uc->lpszHostName );
442         memcpy( url, uc->lpszHostName, len * sizeof(WCHAR) );
443         url += len;
444
445         if (!uses_default_port( scheme, uc->nPort ))
446         {
447             WCHAR port[sizeof("65535")];
448
449             sprintfW( port, formatW, uc->nPort );
450             *url = ':';
451             url++;
452
453             len = strlenW( port );
454             memcpy( url, port, len * sizeof(WCHAR) );
455             url += len;
456         }
457
458         /* add slash between hostname and path if necessary */
459         if (uc->lpszUrlPath && *uc->lpszUrlPath != '/')
460         {
461             *url = '/';
462             url++;
463         }
464     }
465     if (uc->lpszUrlPath)
466     {
467         len = comp_length( uc->dwUrlPathLength, 0, uc->lpszUrlPath );
468         if (flags & ICU_ESCAPE) url += copy_escape( url, uc->lpszUrlPath, len );
469         else
470         {
471             memcpy( url, uc->lpszUrlPath, len * sizeof(WCHAR) );
472             url += len;
473         }
474     }
475     if (uc->lpszExtraInfo)
476     {
477         len = comp_length( uc->dwExtraInfoLength, 0, uc->lpszExtraInfo );
478         if (flags & ICU_ESCAPE) url += copy_escape( url, uc->lpszExtraInfo, len );
479         else
480         {
481             memcpy( url, uc->lpszExtraInfo, len * sizeof(WCHAR) );
482             url += len;
483         }
484     }
485     *url = 0;
486     return TRUE;
487 }