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 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 }