dlls/webservices/url.c

   1 /*
   2  * Copyright 2016 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 <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "winuser.h"
  24 #include "webservices.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/heap.h"
  28 #include "wine/list.h"
  29 #include "wine/unicode.h"
  30 #include "webservices_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
  33
  34 static const WCHAR http[] = {'h','t','t','p'};
  35 static const WCHAR https[] = {'h','t','t','p','s'};
  36 static const WCHAR nettcp[] = {'n','e','t','.','t','c','p'};
  37 static const WCHAR soapudp[] = {'s','o','a','p','.','u','d','p'};
  38 static const WCHAR netpipe[] = {'n','e','t','.','p','i','p','e'};
  39
  40 static WS_URL_SCHEME_TYPE scheme_type( const WCHAR *str, ULONG len )
  41 {
  42     if (len == sizeof(http)/sizeof(http[0]) && !memicmpW( str, http, sizeof(http)/sizeof(http[0]) ))
  43         return WS_URL_HTTP_SCHEME_TYPE;
  44
  45     if (len == sizeof(https)/sizeof(https[0]) && !memicmpW( str, https, sizeof(https)/sizeof(https[0]) ))
  46         return WS_URL_HTTPS_SCHEME_TYPE;
  47
  48     if (len == sizeof(nettcp)/sizeof(nettcp[0]) && !memicmpW( str, nettcp, sizeof(nettcp)/sizeof(nettcp[0]) ))
  49         return WS_URL_NETTCP_SCHEME_TYPE;
  50
  51     if (len == sizeof(soapudp)/sizeof(soapudp[0]) && !memicmpW( str, soapudp, sizeof(soapudp)/sizeof(soapudp[0]) ))
  52         return WS_URL_SOAPUDP_SCHEME_TYPE;
  53
  54     if (len == sizeof(netpipe)/sizeof(netpipe[0]) && !memicmpW( str, netpipe, sizeof(netpipe)/sizeof(netpipe[0]) ))
  55         return WS_URL_NETPIPE_SCHEME_TYPE;
  56
  57     return ~0u;
  58 }
  59
  60 static USHORT default_port( WS_URL_SCHEME_TYPE scheme )
  61 {
  62     switch (scheme)
  63     {
  64     case WS_URL_HTTP_SCHEME_TYPE:    return 80;
  65     case WS_URL_HTTPS_SCHEME_TYPE:   return 443;
  66     case WS_URL_NETTCP_SCHEME_TYPE:  return 808;
  67     case WS_URL_SOAPUDP_SCHEME_TYPE:
  68     case WS_URL_NETPIPE_SCHEME_TYPE: return 65535;
  69     default:
  70         ERR( "unhandled scheme %u\n", scheme );
  71         return 0;
  72     }
  73 }
  74
  75 static unsigned char *strdup_utf8( const WCHAR *str, ULONG len, ULONG *ret_len )
  76 {
  77     unsigned char *ret;
  78     *ret_len = WideCharToMultiByte( CP_UTF8, 0, str, len, NULL, 0, NULL, NULL );
  79     if ((ret = heap_alloc( *ret_len )))
  80         WideCharToMultiByte( CP_UTF8, 0, str, len, (char *)ret, *ret_len, NULL, NULL );
  81     return ret;
  82 }
  83
  84 static inline int url_decode_byte( char c1, char c2 )
  85 {
  86     int ret;
  87
  88     if (c1 >= '0' && c1 <= '9') ret = (c1 - '0') * 16;
  89     else if (c1 >= 'a' && c1 <= 'f') ret = (c1 - 'a' + 10) * 16;
  90     else ret = (c1 - 'A' + 10) * 16;
  91
  92     if (c2 >= '0' && c2 <= '9') ret += c2 - '0';
  93     else if (c2 >= 'a' && c2 <= 'f') ret += c2 - 'a' + 10;
  94     else ret += c2 - 'A' + 10;
  95
  96     return ret;
  97 }
  98
  99 static WCHAR *url_decode( WCHAR *str, ULONG len, WS_HEAP *heap, ULONG *ret_len )
 100 {
 101     WCHAR *p = str, *q, *ret;
 102     BOOL decode = FALSE, convert = FALSE;
 103     ULONG i, len_utf8, len_left;
 104     unsigned char *utf8, *r;
 105
 106     *ret_len = len;
 107     for (i = 0; i < len; i++, p++)
 108     {
 109         if ((len - i) < 3) break;
 110         if (p[0] == '%' && isxdigitW( p[1] ) && isxdigitW( p[2] ))
 111         {
 112             decode = TRUE;
 113             if (url_decode_byte( p[1], p[2] ) > 159)
 114             {
 115                 convert = TRUE;
 116                 break;
 117             }
 118             *ret_len -= 2;
 119         }
 120     }
 121     if (!decode) return str;
 122     if (!convert)
 123     {
 124         if (!(q = ret = ws_alloc( heap, *ret_len * sizeof(WCHAR) ))) return NULL;
 125         p = str;
 126         while (len)
 127         {
 128             if (len >= 3 && p[0] == '%' && isxdigitW( p[1] ) && isxdigitW( p[2] ))
 129             {
 130                 *q++ = url_decode_byte( p[1], p[2] );
 131                 p += 3;
 132                 len -= 3;
 133             }
 134             else
 135             {
 136                 *q++ = *p++;
 137                 len -= 1;
 138             }
 139         }
 140         return ret;
 141     }
 142
 143     if (!(r = utf8 = strdup_utf8( str, len, &len_utf8 ))) return NULL;
 144     len_left = len_utf8;
 145     while (len_left)
 146     {
 147         if (len_left >= 3 && r[0] == '%' && isxdigit( r[1] ) && isxdigit( r[2] ))
 148         {
 149             r[0] = url_decode_byte( r[1], r[2] );
 150             len_left -= 3;
 151             memmove( r + 1, r + 3, len_left );
 152             len_utf8 -= 2;
 153         }
 154         else len_left -= 1;
 155         r++;
 156     }
 157
 158     if (!(*ret_len = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, (char *)utf8,
 159                                           len_utf8, NULL, 0 )))
 160     {
 161         WARN( "invalid UTF-8 sequence\n" );
 162         heap_free( utf8 );
 163         return NULL;
 164     }
 165     if ((ret = ws_alloc( heap, *ret_len * sizeof(WCHAR) )))
 166         MultiByteToWideChar( CP_UTF8, 0, (char *)utf8, len_utf8, ret, *ret_len );
 167
 168     heap_free( utf8 );
 169     return ret;
 170 }
 171
 172 /**************************************************************************
 173  *          WsDecodeUrl         [webservices.@]
 174  */
 175 HRESULT WINAPI WsDecodeUrl( const WS_STRING *str, ULONG flags, WS_HEAP *heap, WS_URL **ret,
 176                             WS_ERROR *error )
 177 {
 178     HRESULT hr = WS_E_QUOTA_EXCEEDED;
 179     WCHAR *p, *q, *decoded = NULL;
 180     WS_HTTP_URL *url = NULL;
 181     ULONG len, len_decoded, port = 0;
 182
 183     TRACE( "%s %08x %p %p %p\n", str ? debugstr_wn(str->chars, str->length) : "null", flags,
 184            heap, ret, error );
 185     if (error) FIXME( "ignoring error parameter\n" );
 186
 187     if (!str || !heap) return E_INVALIDARG;
 188     if (!str->length) return WS_E_INVALID_FORMAT;
 189     if (flags)
 190     {
 191         FIXME( "unimplemented flags %08x\n", flags );
 192         return E_NOTIMPL;
 193     }
 194     if (!(decoded = url_decode( str->chars, str->length, heap, &len_decoded )) ||
 195         !(url = ws_alloc( heap, sizeof(*url) ))) goto error;
 196
 197     hr = WS_E_INVALID_FORMAT;
 198
 199     p = q = decoded;
 200     len = len_decoded;
 201     while (len && *q != ':') { q++; len--; };
 202     if (*q != ':') goto error;
 203     if ((url->url.scheme = scheme_type( p, q - p )) == ~0u) goto error;
 204
 205     if (!--len || *++q != '/') goto error;
 206     if (!--len || *++q != '/') goto error;
 207
 208     p = ++q; len--;
 209     while (len && *q != '/' && *q != ':' && *q != '?' && *q != '#') { q++; len--; };
 210     if (q == p) goto error;
 211     url->host.length = q - p;
 212     url->host.chars  = p;
 213
 214     if (len && *q == ':')
 215     {
 216         p = ++q; len--;
 217         while (len && isdigitW( *q ))
 218         {
 219             if ((port = port * 10 + *q - '0') > 65535) goto error;
 220             q++; len--;
 221         };
 222         url->port = port;
 223         url->portAsString.length = q - p;
 224         url->portAsString.chars  = p;
 225     }
 226     if (!port)
 227     {
 228         url->port = default_port( url->url.scheme );
 229         url->portAsString.length = 0;
 230         url->portAsString.chars  = NULL;
 231     }
 232
 233     if (len && *q == '/')
 234     {
 235         p = q;
 236         while (len && *q != '?') { q++; len--; };
 237         url->path.length = q - p;
 238         url->path.chars  = p;
 239     }
 240     else url->path.length = 0;
 241
 242     if (len && *q == '?')
 243     {
 244         p = ++q; len--;
 245         while (len && *q != '#') { q++; len--; };
 246         url->query.length = q - p;
 247         url->query.chars  = p;
 248     }
 249     else url->query.length = 0;
 250
 251     if (len && *q == '#')
 252     {
 253         p = ++q; len--;
 254         while (len && *q != '#') { q++; len--; };
 255         url->fragment.length = q - p;
 256         url->fragment.chars  = p;
 257     }
 258     else url->fragment.length = 0;
 259
 260     *ret = (WS_URL *)url;
 261     return S_OK;
 262
 263 error:
 264     if (decoded != str->chars) ws_free( heap, decoded, len_decoded );
 265     ws_free( heap, url, sizeof(*url) );
 266     return hr;
 267 }
 268
 269 static const WCHAR *scheme_str( WS_URL_SCHEME_TYPE scheme, ULONG *len )
 270 {
 271     switch (scheme)
 272     {
 273     case WS_URL_HTTP_SCHEME_TYPE:
 274         *len = sizeof(http)/sizeof(http[0]);
 275         return http;
 276
 277     case WS_URL_HTTPS_SCHEME_TYPE:
 278         *len = sizeof(https)/sizeof(https[0]);
 279         return https;
 280
 281     case WS_URL_NETTCP_SCHEME_TYPE:
 282         *len = sizeof(nettcp)/sizeof(nettcp[0]);
 283         return nettcp;
 284
 285     case WS_URL_SOAPUDP_SCHEME_TYPE:
 286         *len = sizeof(soapudp)/sizeof(soapudp[0]);
 287         return soapudp;
 288
 289     case WS_URL_NETPIPE_SCHEME_TYPE:
 290         *len = sizeof(netpipe)/sizeof(netpipe[0]);
 291         return netpipe;
 292
 293     default:
 294         ERR( "unhandled scheme %u\n", scheme );
 295         return NULL;
 296     }
 297 }
 298
 299 static inline ULONG escape_size( unsigned char ch, const char *except )
 300 {
 301     const char *p = except;
 302     while (*p)
 303     {
 304         if (*p == ch) return 1;
 305         p++;
 306     }
 307     if ((ch >= 'a' && ch <= 'z' ) || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')) return 1;
 308     if (ch < 33 || ch > 126) return 3;
 309     switch (ch)
 310     {
 311     case '/':
 312     case '?':
 313     case '"':
 314     case '#':
 315     case '%':
 316     case '<':
 317     case '>':
 318     case '\\':
 319     case '[':
 320     case ']':
 321     case '^':
 322     case '`':
 323     case '{':
 324     case '|':
 325     case '}':
 326         return 3;
 327     default:
 328         return 1;
 329     }
 330 }
 331
 332 static HRESULT url_encode_size( const WCHAR *str, ULONG len, const char *except, ULONG *ret_len )
 333 {
 334     ULONG i, len_utf8;
 335     BOOL convert = FALSE;
 336     unsigned char *utf8;
 337
 338     *ret_len = 0;
 339     for (i = 0; i < len; i++)
 340     {
 341         if (str[i] > 159)
 342         {
 343             convert = TRUE;
 344             break;
 345         }
 346         *ret_len += escape_size( str[i], except );
 347     }
 348     if (!convert) return S_OK;
 349
 350     *ret_len = 0;
 351     if (!(utf8 = strdup_utf8( str, len, &len_utf8 ))) return E_OUTOFMEMORY;
 352     for (i = 0; i < len_utf8; i++) *ret_len += escape_size( utf8[i], except );
 353     heap_free( utf8 );
 354
 355     return S_OK;
 356 }
 357
 358 static ULONG url_encode_byte( unsigned char byte, const char *except, WCHAR *buf )
 359 {
 360     static const WCHAR hex[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 361     switch (escape_size( byte, except ))
 362     {
 363     case 3:
 364         buf[0] = '%';
 365         buf[1] = hex[(byte >> 4) & 0xf];
 366         buf[2] = hex[byte & 0xf];
 367         return 3;
 368
 369     case 1:
 370         buf[0] = byte;
 371         return 1;
 372
 373     default:
 374         ERR( "unhandled escape size\n" );
 375         return 0;
 376     }
 377
 378 }
 379
 380 static HRESULT url_encode( const WCHAR *str, ULONG len, WCHAR *buf, const char *except, ULONG *ret_len )
 381 {
 382     HRESULT hr = S_OK;
 383     ULONG i, len_utf8, len_enc;
 384     BOOL convert = FALSE;
 385     WCHAR *p = buf;
 386     unsigned char *utf8;
 387
 388     *ret_len = 0;
 389     for (i = 0; i < len; i++)
 390     {
 391         if (str[i] > 159)
 392         {
 393             convert = TRUE;
 394             break;
 395         }
 396         len_enc = url_encode_byte( str[i], except, p );
 397         *ret_len += len_enc;
 398         p += len_enc;
 399     }
 400     if (!convert) return S_OK;
 401
 402     p = buf;
 403     *ret_len = 0;
 404     if (!(utf8 = strdup_utf8( str, len, &len_utf8 ))) return E_OUTOFMEMORY;
 405     for (i = 0; i < len_utf8; i++)
 406     {
 407         len_enc = url_encode_byte( utf8[i], except, p );
 408         *ret_len += len_enc;
 409         p += len_enc;
 410     }
 411
 412     heap_free( utf8 );
 413     return hr;
 414 }
 415
 416 /**************************************************************************
 417  *          WsEncodeUrl         [webservices.@]
 418  */
 419 HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_STRING *ret,
 420                             WS_ERROR *error )
 421 {
 422     static const WCHAR fmtW[] = {':','%','u',0};
 423     ULONG len = 0, len_scheme, len_enc, ret_size;
 424     const WS_HTTP_URL *url = (const WS_HTTP_URL *)base;
 425     const WCHAR *scheme;
 426     WCHAR *str, *p, *q;
 427     ULONG port = 0;
 428     HRESULT hr;
 429
 430     TRACE( "%p %08x %p %p %p\n", base, flags, heap, ret, error );
 431     if (error) FIXME( "ignoring error parameter\n" );
 432
 433     if (!url || !heap || !ret) return E_INVALIDARG;
 434     if (flags)
 435     {
 436         FIXME( "unimplemented flags %08x\n", flags );
 437         return E_NOTIMPL;
 438     }
 439     if (!(scheme = scheme_str( url->url.scheme, &len_scheme ))) return WS_E_INVALID_FORMAT;
 440     len = len_scheme + 3; /* '://' */
 441     len += 6; /* ':65535' */
 442
 443     if ((hr = url_encode_size( url->host.chars, url->host.length, "", &len_enc )) != S_OK)
 444         return hr;
 445     len += len_enc;
 446
 447     if ((hr = url_encode_size( url->path.chars, url->path.length, "/", &len_enc )) != S_OK)
 448         return hr;
 449     len += len_enc;
 450
 451     if ((hr = url_encode_size( url->query.chars, url->query.length, "/?", &len_enc )) != S_OK)
 452         return hr;
 453     len += len_enc + 1; /* '?' */
 454
 455     if ((hr = url_encode_size( url->fragment.chars, url->fragment.length, "/?", &len_enc )) != S_OK)
 456         return hr;
 457     len += len_enc + 1; /* '#' */
 458
 459     ret_size = len * sizeof(WCHAR);
 460     if (!(str = ws_alloc( heap, ret_size ))) return WS_E_QUOTA_EXCEEDED;
 461
 462     memcpy( str, scheme, len_scheme * sizeof(WCHAR) );
 463     p = str + len_scheme;
 464     p[0] = ':';
 465     p[1] = p[2] = '/';
 466     p += 3;
 467
 468     if ((hr = url_encode( url->host.chars, url->host.length, p, "", &len_enc )) != S_OK)
 469         goto error;
 470     p += len_enc;
 471
 472     if (url->portAsString.length)
 473     {
 474         q = url->portAsString.chars;
 475         len = url->portAsString.length;
 476         while (len && isdigitW( *q ))
 477         {
 478             if ((port = port * 10 + *q - '0') > 65535)
 479             {
 480                 hr = WS_E_INVALID_FORMAT;
 481                 goto error;
 482             }
 483             q++; len--;
 484         }
 485         if (url->port && port != url->port)
 486         {
 487             hr = E_INVALIDARG;
 488             goto error;
 489         }
 490     } else port = url->port;
 491
 492     if (port == default_port( url->url.scheme )) port = 0;
 493     if (port)
 494     {
 495         WCHAR buf[7];
 496         len = sprintfW( buf, fmtW, port );
 497         memcpy( p, buf, len * sizeof(WCHAR) );
 498         p += len;
 499     }
 500
 501     if ((hr = url_encode( url->path.chars, url->path.length, p, "/", &len_enc )) != S_OK)
 502         goto error;
 503     p += len_enc;
 504
 505     if (url->query.length)
 506     {
 507         *p++ = '?';
 508         if ((hr = url_encode( url->query.chars, url->query.length, p, "/?", &len_enc )) != S_OK)
 509             goto error;
 510         p += len_enc;
 511     }
 512
 513     if (url->fragment.length)
 514     {
 515         *p++ = '#';
 516         if ((hr = url_encode( url->fragment.chars, url->fragment.length, p, "/?", &len_enc )) != S_OK)
 517             goto error;
 518         p += len_enc;
 519     }
 520
 521     ret->length = p - str;
 522     ret->chars  = str;
 523     return S_OK;
 524
 525 error:
 526     ws_free( heap, str, ret_size );
 527     return hr;
 528 }