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