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