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 }