git.oblomov.eu Git - wine/blob - 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 || !url[0] || !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, ':' ))) return FALSE;
 118
 119     if (p - url == 4 && !strncmpiW( url, scheme_http, 4 )) uc->nScheme = INTERNET_SCHEME_HTTP;
 120     else if (p - url == 5 && !strncmpiW( url, scheme_https, 5 )) uc->nScheme = INTERNET_SCHEME_HTTPS;
 121     else goto exit;
 122
 123     if (!(set_component( &uc->lpszScheme, &uc->dwSchemeLength, (WCHAR *)url, p - url, flags ))) goto exit;
 124
 125     p++; /* skip ':' */
 126     if (!p[0] || p[0] != '/' || p[1] != '/') goto exit;
 127     p += 2;
 128
 129     if (!p[0]) goto exit;
 130     if ((q = memchrW( p, '@', len - (p - url) )))
 131     {
 132         if ((r = memchrW( p, ':', q - p )))
 133         {
 134             if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength, p, r - p, flags ))) goto exit;
 135             r++;
 136             if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength, r, q - r, flags ))) goto exit;
 137         }
 138         else
 139         {
 140             if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength, p, q - p, flags ))) goto exit;
 141             if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength, NULL, 0, flags ))) goto exit;
 142         }
 143         p = q + 1;
 144     }
 145     else
 146     {
 147         if (!(set_component( &uc->lpszUserName, &uc->dwUserNameLength, NULL, 0, flags ))) goto exit;
 148         if (!(set_component( &uc->lpszPassword, &uc->dwPasswordLength, NULL, 0, flags ))) goto exit;
 149     }
 150     if ((q = memchrW( p, '/', len - (p - url) )))
 151     {
 152         if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength, p, q - p, flags ))) goto exit;
 153
 154         if ((r = memchrW( q, '?', len - (q - url) )))
 155         {
 156             if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, q, r - q, flags ))) goto exit;
 157             if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength, r, len - (r - url), flags ))) goto exit;
 158         }
 159         else
 160         {
 161             if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, q, len - (q - url), flags ))) goto exit;
 162             if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength, (WCHAR *)url + len, 0, flags ))) goto exit;
 163         }
 164     }
 165     else
 166     {
 167         if (!(set_component( &uc->lpszHostName, &uc->dwHostNameLength, p, len - (p - url), flags ))) goto exit;
 168         if (!(set_component( &uc->lpszUrlPath, &uc->dwUrlPathLength, (WCHAR *)url + len, 0, flags ))) goto exit;
 169         if (!(set_component( &uc->lpszExtraInfo, &uc->dwExtraInfoLength, (WCHAR *)url + len, 0, flags ))) goto exit;
 170     }
 171
 172     ret = TRUE;
 173
 174     TRACE("scheme(%s) host(%s) path(%s) extra(%s)\n",
 175           debugstr_wn( uc->lpszScheme, uc->dwSchemeLength ),
 176           debugstr_wn( uc->lpszHostName, uc->dwHostNameLength ),
 177           debugstr_wn( uc->lpszUrlPath, uc->dwUrlPathLength ),
 178           debugstr_wn( uc->lpszExtraInfo, uc->dwExtraInfoLength ));
 179
 180 exit:
 181     HeapFree( GetProcessHeap(), 0, url_decoded );
 182     return ret;
 183 }
 184
 185 static INTERNET_SCHEME get_scheme( const WCHAR *scheme, DWORD len )
 186 {
 187     if (!strncmpW( scheme, scheme_http, len )) return INTERNET_SCHEME_HTTP;
 188     if (!strncmpW( scheme, scheme_https, len )) return INTERNET_SCHEME_HTTPS;
 189     return 0;
 190 }
 191
 192 static const WCHAR *get_scheme_string( INTERNET_SCHEME scheme )
 193 {
 194     if (scheme == INTERNET_SCHEME_HTTP) return scheme_http;
 195     if (scheme == INTERNET_SCHEME_HTTPS) return scheme_https;
 196     return NULL;
 197 }
 198
 199 static BOOL uses_default_port( INTERNET_SCHEME scheme, INTERNET_PORT port )
 200 {
 201     if ((scheme == INTERNET_SCHEME_HTTP) && (port == INTERNET_DEFAULT_HTTP_PORT)) return TRUE;
 202     if ((scheme == INTERNET_SCHEME_HTTPS) && (port == INTERNET_DEFAULT_HTTPS_PORT)) return TRUE;
 203     return FALSE;
 204 }
 205
 206 static BOOL need_escape( WCHAR c )
 207 {
 208     if (isalnumW( c )) return FALSE;
 209
 210     if (c <= 31 || c >= 127) return TRUE;
 211     else
 212     {
 213         switch (c)
 214         {
 215         case ' ':
 216         case '"':
 217         case '#':
 218         case '%':
 219         case '<':
 220         case '>':
 221         case ']':
 222         case '\\':
 223         case '[':
 224         case '^':
 225         case '`':
 226         case '{':
 227         case '|':
 228         case '}':
 229         case '~':
 230             return TRUE;
 231         default:
 232             return FALSE;
 233         }
 234     }
 235 }
 236
 237 static DWORD copy_escape( WCHAR *dst, const WCHAR *src, DWORD len )
 238 {
 239     static const WCHAR hex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 240     DWORD ret = len;
 241     unsigned int i;
 242     WCHAR *p = dst;
 243
 244     for (i = 0; i < len; i++, p++)
 245     {
 246         if (need_escape( src[i] ))
 247         {
 248             p[0] = '%';
 249             p[1] = hex[(src[i] >> 4) & 0xf];
 250             p[2] = hex[src[i] & 0xf];
 251             ret += 2;
 252             p += 2;
 253         }
 254         else *p = src[i];
 255     }
 256     dst[ret] = 0;
 257     return ret;
 258 }
 259
 260 static DWORD comp_length( DWORD len, DWORD flags, WCHAR *comp )
 261 {
 262     DWORD ret;
 263     unsigned int i;
 264
 265     ret = len ? len : strlenW( comp );
 266     if (!(flags & ICU_ESCAPE)) return ret;
 267     for (i = 0; i < len; i++) if (need_escape( comp[i] )) ret += 2;
 268     return ret;
 269 }
 270
 271 static BOOL calc_length( URL_COMPONENTS *uc, DWORD flags, LPDWORD len )
 272 {
 273     static const WCHAR formatW[] = {'%','d',0};
 274     INTERNET_SCHEME scheme;
 275
 276     *len = 0;
 277     if (uc->lpszScheme)
 278     {
 279         DWORD scheme_len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme );
 280         *len += scheme_len;
 281         scheme = get_scheme( uc->lpszScheme, scheme_len );
 282     }
 283     else
 284     {
 285         scheme = uc->nScheme;
 286         if (!scheme) scheme = INTERNET_SCHEME_HTTP;
 287         *len += strlenW( get_scheme_string( scheme ) );
 288     }
 289     *len += 1; /* ':' */
 290     if (uc->lpszHostName) *len += 2; /* "//" */
 291
 292     if (uc->lpszUserName)
 293     {
 294         *len += comp_length( uc->dwUserNameLength, 0, uc->lpszUserName );
 295         *len += 1; /* "@" */
 296     }
 297     else
 298     {
 299         if (uc->lpszPassword)
 300         {
 301             set_last_error( ERROR_INVALID_PARAMETER );
 302             return FALSE;
 303         }
 304     }
 305     if (uc->lpszPassword)
 306     {
 307         *len += 1; /* ":" */
 308         *len += comp_length( uc->dwPasswordLength, 0, uc->lpszPassword );
 309     }
 310     if (uc->lpszHostName)
 311     {
 312         *len += comp_length( uc->dwHostNameLength, 0, uc->lpszHostName );
 313
 314         if (!uses_default_port( scheme, uc->nPort ))
 315         {
 316             WCHAR port[sizeof("65535")];
 317
 318             sprintfW( port, formatW, uc->nPort );
 319             *len += strlenW( port );
 320             *len += 1; /* ":" */
 321         }
 322         if (uc->lpszUrlPath && *uc->lpszUrlPath != '/') *len += 1; /* '/' */
 323     }
 324     if (uc->lpszUrlPath) *len += comp_length( uc->dwUrlPathLength, flags, uc->lpszUrlPath );
 325     if (uc->lpszExtraInfo) *len += comp_length( uc->dwExtraInfoLength, flags, uc->lpszExtraInfo );
 326     return TRUE;
 327 }
 328
 329 /***********************************************************************
 330  *          WinHttpCreateUrl (winhttp.@)
 331  */
 332 BOOL WINAPI WinHttpCreateUrl( LPURL_COMPONENTS uc, DWORD flags, LPWSTR url, LPDWORD required )
 333 {
 334     static const WCHAR formatW[] = {'%','d',0};
 335     static const WCHAR twoslashW[] = {'/','/'};
 336
 337     DWORD len;
 338     INTERNET_SCHEME scheme;
 339
 340     TRACE("%p, 0x%08x, %p, %p\n", uc, flags, url, required);
 341
 342     if (!uc || uc->dwStructSize != sizeof(URL_COMPONENTS) || !required)
 343     {
 344         set_last_error( ERROR_INVALID_PARAMETER );
 345         return FALSE;
 346     }
 347
 348     if (!calc_length( uc, flags, &len )) return FALSE;
 349
 350     if (!url || *required < len)
 351     {
 352         *required = len + 1;
 353         set_last_error( ERROR_INSUFFICIENT_BUFFER );
 354         return FALSE;
 355     }
 356
 357     url[0] = 0;
 358     *required = len;
 359     if (uc->lpszScheme)
 360     {
 361         len = comp_length( uc->dwSchemeLength, 0, uc->lpszScheme );
 362         memcpy( url, uc->lpszScheme, len * sizeof(WCHAR) );
 363         url += len;
 364
 365         scheme = get_scheme( uc->lpszScheme, len );
 366     }
 367     else
 368     {
 369         const WCHAR *schemeW;
 370         scheme = uc->nScheme;
 371
 372         if (!scheme) scheme = INTERNET_SCHEME_HTTP;
 373
 374         schemeW = get_scheme_string( scheme );
 375         len = strlenW( schemeW );
 376         memcpy( url, schemeW, len * sizeof(WCHAR) );
 377         url += len;
 378     }
 379
 380     /* all schemes are followed by at least a colon */
 381     *url = ':';
 382     url++;
 383
 384     if (uc->lpszHostName)
 385     {
 386         memcpy( url, twoslashW, sizeof(twoslashW) );
 387         url += sizeof(twoslashW) / sizeof(twoslashW[0]);
 388     }
 389     if (uc->lpszUserName)
 390     {
 391         len = comp_length( uc->dwUserNameLength, 0, uc->lpszUserName );
 392         memcpy( url, uc->lpszUserName, len * sizeof(WCHAR) );
 393         url += len;
 394
 395         if (uc->lpszPassword)
 396         {
 397             *url = ':';
 398             url++;
 399
 400             len = comp_length( uc->dwPasswordLength, 0, uc->lpszPassword );
 401             memcpy( url, uc->lpszPassword, len * sizeof(WCHAR) );
 402             url += len;
 403         }
 404         *url = '@';
 405         url++;
 406     }
 407     if (uc->lpszHostName)
 408     {
 409         len = comp_length( uc->dwHostNameLength, 0, uc->lpszHostName );
 410         memcpy( url, uc->lpszHostName, len * sizeof(WCHAR) );
 411         url += len;
 412
 413         if (!uses_default_port( scheme, uc->nPort ))
 414         {
 415             WCHAR port[sizeof("65535")];
 416
 417             sprintfW( port, formatW, uc->nPort );
 418             *url = ':';
 419             url++;
 420
 421             len = strlenW( port );
 422             memcpy( url, port, len * sizeof(WCHAR) );
 423             url += len;
 424         }
 425
 426         /* add slash between hostname and path if necessary */
 427         if (uc->lpszUrlPath && *uc->lpszUrlPath != '/')
 428         {
 429             *url = '/';
 430             url++;
 431         }
 432     }
 433     if (uc->lpszUrlPath)
 434     {
 435         len = comp_length( uc->dwUrlPathLength, 0, uc->lpszUrlPath );
 436         if (flags & ICU_ESCAPE) url += copy_escape( url, uc->lpszUrlPath, len );
 437         else
 438         {
 439             memcpy( url, uc->lpszUrlPath, len * sizeof(WCHAR) );
 440             url += len;
 441         }
 442     }
 443     if (uc->lpszExtraInfo)
 444     {
 445         len = comp_length( uc->dwExtraInfoLength, 0, uc->lpszExtraInfo );
 446         if (flags & ICU_ESCAPE) url += copy_escape( url, uc->lpszExtraInfo, len );
 447         else
 448         {
 449             memcpy( url, uc->lpszExtraInfo, len * sizeof(WCHAR) );
 450             url += len;
 451         }
 452     }
 453     *url = 0;
 454     return TRUE;
 455 }