git.oblomov.eu Git - wine/blob - dlls/shlwapi/url.c

   1 /*
   2  * Url functions
   3  *
   4  * Copyright 2000 Huw D M Davies for CodeWeavers.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "winerror.h"
  30 #include "wine/unicode.h"
  31 #include "wininet.h"
  32 #include "winreg.h"
  33 #include "winternl.h"
  34 #define NO_SHLWAPI_STREAM
  35 #include "shlwapi.h"
  36 #include "intshcut.h"
  37 #include "wine/debug.h"
  38
  39 HMODULE WINAPI MLLoadLibraryW(LPCWSTR,HMODULE,DWORD);
  40 BOOL    WINAPI MLFreeLibrary(HMODULE);
  41 HRESULT WINAPI MLBuildResURLW(LPCWSTR,HMODULE,DWORD,LPCWSTR,LPWSTR,DWORD);
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  44
  45 /* The following schemes were identified in the native version of
  46  * SHLWAPI.DLL version 5.50
  47  */
  48 static const struct {
  49     URL_SCHEME  scheme_number;
  50     WCHAR scheme_name[12];
  51 } shlwapi_schemes[] = {
  52   {URL_SCHEME_FTP,        {'f','t','p',0}},
  53   {URL_SCHEME_HTTP,       {'h','t','t','p',0}},
  54   {URL_SCHEME_GOPHER,     {'g','o','p','h','e','r',0}},
  55   {URL_SCHEME_MAILTO,     {'m','a','i','l','t','o',0}},
  56   {URL_SCHEME_NEWS,       {'n','e','w','s',0}},
  57   {URL_SCHEME_NNTP,       {'n','n','t','p',0}},
  58   {URL_SCHEME_TELNET,     {'t','e','l','n','e','t',0}},
  59   {URL_SCHEME_WAIS,       {'w','a','i','s',0}},
  60   {URL_SCHEME_FILE,       {'f','i','l','e',0}},
  61   {URL_SCHEME_MK,         {'m','k',0}},
  62   {URL_SCHEME_HTTPS,      {'h','t','t','p','s',0}},
  63   {URL_SCHEME_SHELL,      {'s','h','e','l','l',0}},
  64   {URL_SCHEME_SNEWS,      {'s','n','e','w','s',0}},
  65   {URL_SCHEME_LOCAL,      {'l','o','c','a','l',0}},
  66   {URL_SCHEME_JAVASCRIPT, {'j','a','v','a','s','c','r','i','p','t',0}},
  67   {URL_SCHEME_VBSCRIPT,   {'v','b','s','c','r','i','p','t',0}},
  68   {URL_SCHEME_ABOUT,      {'a','b','o','u','t',0}},
  69   {URL_SCHEME_RES,        {'r','e','s',0}},
  70 };
  71
  72 typedef struct {
  73     LPCWSTR pScheme;      /* [out] start of scheme                     */
  74     DWORD   szScheme;     /* [out] size of scheme (until colon)        */
  75     LPCWSTR pUserName;    /* [out] start of Username                   */
  76     DWORD   szUserName;   /* [out] size of Username (until ":" or "@") */
  77     LPCWSTR pPassword;    /* [out] start of Password                   */
  78     DWORD   szPassword;   /* [out] size of Password (until "@")        */
  79     LPCWSTR pHostName;    /* [out] start of Hostname                   */
  80     DWORD   szHostName;   /* [out] size of Hostname (until ":" or "/") */
  81     LPCWSTR pPort;        /* [out] start of Port                       */
  82     DWORD   szPort;       /* [out] size of Port (until "/" or eos)     */
  83     LPCWSTR pQuery;       /* [out] start of Query                      */
  84     DWORD   szQuery;      /* [out] size of Query (until eos)           */
  85 } WINE_PARSE_URL;
  86
  87 typedef enum {
  88     SCHEME,
  89     HOST,
  90     PORT,
  91     USERPASS,
  92 } WINE_URL_SCAN_TYPE;
  93
  94 static const CHAR hexDigits[] = "0123456789ABCDEF";
  95
  96 static const WCHAR fileW[] = {'f','i','l','e','\0'};
  97
  98 static const unsigned char HashDataLookup[256] = {
  99  0x01, 0x0E, 0x6E, 0x19, 0x61, 0xAE, 0x84, 0x77, 0x8A, 0xAA, 0x7D, 0x76, 0x1B,
 100  0xE9, 0x8C, 0x33, 0x57, 0xC5, 0xB1, 0x6B, 0xEA, 0xA9, 0x38, 0x44, 0x1E, 0x07,
 101  0xAD, 0x49, 0xBC, 0x28, 0x24, 0x41, 0x31, 0xD5, 0x68, 0xBE, 0x39, 0xD3, 0x94,
 102  0xDF, 0x30, 0x73, 0x0F, 0x02, 0x43, 0xBA, 0xD2, 0x1C, 0x0C, 0xB5, 0x67, 0x46,
 103  0x16, 0x3A, 0x4B, 0x4E, 0xB7, 0xA7, 0xEE, 0x9D, 0x7C, 0x93, 0xAC, 0x90, 0xB0,
 104  0xA1, 0x8D, 0x56, 0x3C, 0x42, 0x80, 0x53, 0x9C, 0xF1, 0x4F, 0x2E, 0xA8, 0xC6,
 105  0x29, 0xFE, 0xB2, 0x55, 0xFD, 0xED, 0xFA, 0x9A, 0x85, 0x58, 0x23, 0xCE, 0x5F,
 106  0x74, 0xFC, 0xC0, 0x36, 0xDD, 0x66, 0xDA, 0xFF, 0xF0, 0x52, 0x6A, 0x9E, 0xC9,
 107  0x3D, 0x03, 0x59, 0x09, 0x2A, 0x9B, 0x9F, 0x5D, 0xA6, 0x50, 0x32, 0x22, 0xAF,
 108  0xC3, 0x64, 0x63, 0x1A, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xBD, 0x79, 0x40,
 109  0x4D, 0x48, 0xD0, 0xF5, 0x82, 0x7A, 0x8F, 0x37, 0x69, 0x86, 0x1D, 0xA4, 0xB9,
 110  0xC2, 0xC1, 0xEF, 0x65, 0xF2, 0x05, 0xAB, 0x7E, 0x0B, 0x4A, 0x3B, 0x89, 0xE4,
 111  0x6C, 0xBF, 0xE8, 0x8B, 0x06, 0x18, 0x51, 0x14, 0x7F, 0x11, 0x5B, 0x5C, 0xFB,
 112  0x97, 0xE1, 0xCF, 0x15, 0x62, 0x71, 0x70, 0x54, 0xE2, 0x12, 0xD6, 0xC7, 0xBB,
 113  0x0D, 0x20, 0x5E, 0xDC, 0xE0, 0xD4, 0xF7, 0xCC, 0xC4, 0x2B, 0xF9, 0xEC, 0x2D,
 114  0xF4, 0x6F, 0xB6, 0x99, 0x88, 0x81, 0x5A, 0xD9, 0xCA, 0x13, 0xA5, 0xE7, 0x47,
 115  0xE6, 0x8E, 0x60, 0xE3, 0x3E, 0xB3, 0xF6, 0x72, 0xA2, 0x35, 0xA0, 0xD7, 0xCD,
 116  0xB4, 0x2F, 0x6D, 0x2C, 0x26, 0x1F, 0x95, 0x87, 0x00, 0xD8, 0x34, 0x3F, 0x17,
 117  0x25, 0x45, 0x27, 0x75, 0x92, 0xB8, 0xA3, 0xC8, 0xDE, 0xEB, 0xF8, 0xF3, 0xDB,
 118  0x0A, 0x98, 0x83, 0x7B, 0xE5, 0xCB, 0x4C, 0x78, 0xD1 };
 119
 120 static DWORD get_scheme_code(LPCWSTR scheme, DWORD scheme_len)
 121 {
 122     unsigned int i;
 123
 124     for(i=0; i < sizeof(shlwapi_schemes)/sizeof(shlwapi_schemes[0]); i++) {
 125         if(scheme_len == strlenW(shlwapi_schemes[i].scheme_name)
 126            && !memcmp(scheme, shlwapi_schemes[i].scheme_name, scheme_len*sizeof(WCHAR)))
 127             return shlwapi_schemes[i].scheme_number;
 128     }
 129
 130     return URL_SCHEME_UNKNOWN;
 131 }
 132
 133 /*************************************************************************
 134  *      @       [SHLWAPI.1]
 135  *
 136  * Parse a Url into its constituent parts.
 137  *
 138  * PARAMS
 139  *  x [I] Url to parse
 140  *  y [O] Undocumented structure holding the parsed information
 141  *
 142  * RETURNS
 143  *  Success: S_OK. y contains the parsed Url details.
 144  *  Failure: An HRESULT error code.
 145  */
 146 HRESULT WINAPI ParseURLA(LPCSTR x, PARSEDURLA *y)
 147 {
 148     WCHAR scheme[INTERNET_MAX_SCHEME_LENGTH];
 149     const char *ptr = x;
 150     int len;
 151
 152     TRACE("%s %p\n", debugstr_a(x), y);
 153
 154     if(y->cbSize != sizeof(*y))
 155         return E_INVALIDARG;
 156
 157     while(*ptr && (isalnum(*ptr) || *ptr == '-'))
 158         ptr++;
 159
 160     if (*ptr != ':' || ptr <= x+1) {
 161         y->pszProtocol = NULL;
 162         return URL_E_INVALID_SYNTAX;
 163     }
 164
 165     y->pszProtocol = x;
 166     y->cchProtocol = ptr-x;
 167     y->pszSuffix = ptr+1;
 168     y->cchSuffix = strlen(y->pszSuffix);
 169
 170     len = MultiByteToWideChar(CP_ACP, 0, x, ptr-x,
 171             scheme, sizeof(scheme)/sizeof(WCHAR));
 172     y->nScheme = get_scheme_code(scheme, len);
 173
 174     return S_OK;
 175 }
 176
 177 /*************************************************************************
 178  *      @       [SHLWAPI.2]
 179  *
 180  * Unicode version of ParseURLA.
 181  */
 182 HRESULT WINAPI ParseURLW(LPCWSTR x, PARSEDURLW *y)
 183 {
 184     const WCHAR *ptr = x;
 185
 186     TRACE("%s %p\n", debugstr_w(x), y);
 187
 188     if(y->cbSize != sizeof(*y))
 189         return E_INVALIDARG;
 190
 191     while(*ptr && (isalnumW(*ptr) || *ptr == '-'))
 192         ptr++;
 193
 194     if (*ptr != ':' || ptr <= x+1) {
 195         y->pszProtocol = NULL;
 196         return URL_E_INVALID_SYNTAX;
 197     }
 198
 199     y->pszProtocol = x;
 200     y->cchProtocol = ptr-x;
 201     y->pszSuffix = ptr+1;
 202     y->cchSuffix = strlenW(y->pszSuffix);
 203     y->nScheme = get_scheme_code(x, ptr-x);
 204
 205     return S_OK;
 206 }
 207
 208 /*************************************************************************
 209  *        UrlCanonicalizeA     [SHLWAPI.@]
 210  *
 211  * Canonicalize a Url.
 212  *
 213  * PARAMS
 214  *  pszUrl            [I]   Url to cCanonicalize
 215  *  pszCanonicalized  [O]   Destination for converted Url.
 216  *  pcchCanonicalized [I/O] Length of pszUrl, destination for length of pszCanonicalized
 217  *  dwFlags           [I]   Flags controlling the conversion.
 218  *
 219  * RETURNS
 220  *  Success: S_OK. The pszCanonicalized contains the converted Url.
 221  *  Failure: E_POINTER, if *pcchCanonicalized is too small.
 222  *
 223  * MSDN incorrectly describes the flags for this function. They should be:
 224  *|    URL_DONT_ESCAPE_EXTRA_INFO    0x02000000
 225  *|    URL_ESCAPE_SPACES_ONLY        0x04000000
 226  *|    URL_ESCAPE_PERCENT            0x00001000
 227  *|    URL_ESCAPE_UNSAFE             0x10000000
 228  *|    URL_UNESCAPE                  0x10000000
 229  *|    URL_DONT_SIMPLIFY             0x08000000
 230  *|    URL_ESCAPE_SEGMENT_ONLY       0x00002000
 231  */
 232 HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized,
 233         LPDWORD pcchCanonicalized, DWORD dwFlags)
 234 {
 235     LPWSTR url, canonical;
 236     HRESULT ret;
 237     DWORD   len;
 238
 239     TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_a(pszUrl), pszCanonicalized,
 240         pcchCanonicalized, dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
 241
 242     if(!pszUrl || !pszCanonicalized || !pcchCanonicalized || !*pcchCanonicalized)
 243         return E_INVALIDARG;
 244
 245     len = strlen(pszUrl)+1;
 246     url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 247     canonical = HeapAlloc(GetProcessHeap(), 0, *pcchCanonicalized*sizeof(WCHAR));
 248     if(!url || !canonical) {
 249         HeapFree(GetProcessHeap(), 0, url);
 250         HeapFree(GetProcessHeap(), 0, canonical);
 251         return E_OUTOFMEMORY;
 252     }
 253
 254     MultiByteToWideChar(0, 0, pszUrl, -1, url, len);
 255
 256     ret = UrlCanonicalizeW(url, canonical, pcchCanonicalized, dwFlags);
 257     if(ret == S_OK)
 258         WideCharToMultiByte(0, 0, canonical, -1, pszCanonicalized,
 259                 *pcchCanonicalized+1, 0, 0);
 260
 261     HeapFree(GetProcessHeap(), 0, canonical);
 262     return ret;
 263 }
 264
 265 /*************************************************************************
 266  *        UrlCanonicalizeW     [SHLWAPI.@]
 267  *
 268  * See UrlCanonicalizeA.
 269  */
 270 HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
 271                                 LPDWORD pcchCanonicalized, DWORD dwFlags)
 272 {
 273     HRESULT hr = S_OK;
 274     DWORD EscapeFlags;
 275     LPCWSTR wk1, root;
 276     LPWSTR lpszUrlCpy, wk2, mp, mp2;
 277     INT state;
 278     DWORD nByteLen, nLen, nWkLen;
 279     WCHAR slash = '\0';
 280
 281     static const WCHAR wszFile[] = {'f','i','l','e',':'};
 282     static const WCHAR wszRes[] = {'r','e','s',':'};
 283     static const WCHAR wszHttp[] = {'h','t','t','p',':'};
 284     static const WCHAR wszLocalhost[] = {'l','o','c','a','l','h','o','s','t'};
 285     static const WCHAR wszFilePrefix[] = {'f','i','l','e',':','/','/','/'};
 286
 287     TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_w(pszUrl), pszCanonicalized,
 288         pcchCanonicalized, dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
 289
 290     if(!pszUrl || !pszCanonicalized || !pcchCanonicalized || !*pcchCanonicalized)
 291         return E_INVALIDARG;
 292
 293     if(!*pszUrl) {
 294         *pszCanonicalized = 0;
 295         return S_OK;
 296     }
 297
 298     nByteLen = (strlenW(pszUrl) + 1) * sizeof(WCHAR); /* length in bytes */
 299     /* Allocate memory for simplified URL (before escaping) */
 300     lpszUrlCpy = HeapAlloc(GetProcessHeap(), 0,
 301             nByteLen+sizeof(wszFilePrefix)+sizeof(WCHAR));
 302
 303     if ((nByteLen >= sizeof(wszHttp) &&
 304          !memcmp(wszHttp, pszUrl, sizeof(wszHttp))) ||
 305         (nByteLen >= sizeof(wszFile) &&
 306          !memcmp(wszFile, pszUrl, sizeof(wszFile))))
 307         slash = '/';
 308
 309     if((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszFile)
 310             && !memcmp(wszFile, pszUrl, sizeof(wszFile)))
 311         slash = '\\';
 312
 313     if(nByteLen >= sizeof(wszRes) && !memcmp(wszRes, pszUrl, sizeof(wszRes))) {
 314         dwFlags &= ~URL_FILE_USE_PATHURL;
 315         slash = '\0';
 316     }
 317
 318     /*
 319      * state =
 320      *         0   initial  1,3
 321      *         1   have 2[+] alnum  2,3
 322      *         2   have scheme (found :)  4,6,3
 323      *         3   failed (no location)
 324      *         4   have //  5,3
 325      *         5   have 1[+] alnum  6,3
 326      *         6   have location (found /) save root location
 327      */
 328
 329     wk1 = pszUrl;
 330     wk2 = lpszUrlCpy;
 331     state = 0;
 332
 333     if(pszUrl[1] == ':') { /* Assume path */
 334         memcpy(wk2, wszFilePrefix, sizeof(wszFilePrefix));
 335         wk2 += sizeof(wszFilePrefix)/sizeof(WCHAR);
 336         if (dwFlags & URL_FILE_USE_PATHURL)
 337         {
 338             slash = '\\';
 339             --wk2;
 340         }
 341         else
 342             dwFlags |= URL_ESCAPE_UNSAFE;
 343         state = 5;
 344     }
 345
 346     while (*wk1) {
 347         switch (state) {
 348         case 0:
 349             if (!isalnumW(*wk1)) {state = 3; break;}
 350             *wk2++ = *wk1++;
 351             if (!isalnumW(*wk1)) {state = 3; break;}
 352             *wk2++ = *wk1++;
 353             state = 1;
 354             break;
 355         case 1:
 356             *wk2++ = *wk1;
 357             if (*wk1++ == ':') state = 2;
 358             break;
 359         case 2:
 360             *wk2++ = *wk1++;
 361             if (*wk1 != '/') {state = 6; break;}
 362             *wk2++ = *wk1++;
 363             if((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszLocalhost)
 364                         && !strncmpW(wszFile, pszUrl, sizeof(wszFile)/sizeof(WCHAR))
 365                         && !memcmp(wszLocalhost, wk1, sizeof(wszLocalhost))){
 366                 wk1 += sizeof(wszLocalhost)/sizeof(WCHAR);
 367                 while(*wk1 == '\\' && (dwFlags & URL_FILE_USE_PATHURL))
 368                     wk1++;
 369             }
 370             if(*wk1 == '/' && (dwFlags & URL_FILE_USE_PATHURL))
 371                 wk1++;
 372             state = 4;
 373             break;
 374         case 3:
 375             nWkLen = strlenW(wk1);
 376             memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
 377             mp = wk2;
 378             wk1 += nWkLen;
 379             wk2 += nWkLen;
 380
 381             if(slash) {
 382                 while(mp < wk2) {
 383                     if(*mp == '/' || *mp == '\\')
 384                         *mp = slash;
 385                     mp++;
 386                 }
 387             }
 388             break;
 389         case 4:
 390             if (!isalnumW(*wk1) && (*wk1 != '-') && (*wk1 != '.') && (*wk1 != ':'))
 391                 {state = 3; break;}
 392             while(isalnumW(*wk1) || (*wk1 == '-') || (*wk1 == '.') || (*wk1 == ':'))
 393                 *wk2++ = *wk1++;
 394             state = 5;
 395             if (!*wk1) {
 396                 if(slash)
 397                     *wk2++ = slash;
 398                 else
 399                     *wk2++ = '/';
 400             }
 401             break;
 402         case 5:
 403             if (*wk1 != '/' && *wk1 != '\\') {state = 3; break;}
 404             while(*wk1 == '/' || *wk1 == '\\') {
 405                 if(slash)
 406                     *wk2++ = slash;
 407                 else
 408                     *wk2++ = *wk1;
 409                 wk1++;
 410             }
 411             state = 6;
 412             break;
 413         case 6:
 414             if(dwFlags & URL_DONT_SIMPLIFY) {
 415                 state = 3;
 416                 break;
 417             }
 418
 419             /* Now at root location, cannot back up any more. */
 420             /* "root" will point at the '/' */
 421
 422             root = wk2-1;
 423             while (*wk1) {
 424                 mp = strchrW(wk1, '/');
 425                 mp2 = strchrW(wk1, '\\');
 426                 if(mp2 && (!mp || mp2 < mp))
 427                     mp = mp2;
 428                 if (!mp) {
 429                     nWkLen = strlenW(wk1);
 430                     memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
 431                     wk1 += nWkLen;
 432                     wk2 += nWkLen;
 433                     continue;
 434                 }
 435                 nLen = mp - wk1;
 436                 if(nLen) {
 437                     memcpy(wk2, wk1, nLen * sizeof(WCHAR));
 438                     wk2 += nLen;
 439                     wk1 += nLen;
 440                 }
 441                 if(slash)
 442                     *wk2++ = slash;
 443                 else
 444                     *wk2++ = *wk1;
 445                 wk1++;
 446
 447                 while (*wk1 == '.') {
 448                     TRACE("found '/.'\n");
 449                     if (wk1[1] == '/' || wk1[1] == '\\') {
 450                         /* case of /./ -> skip the ./ */
 451                         wk1 += 2;
 452                     }
 453                     else if (wk1[1] == '.' && (wk1[2] == '/'
 454                             || wk1[2] == '\\' || wk1[2] == '?'
 455                             || wk1[2] == '#' || !wk1[2])) {
 456                         /* case /../ -> need to backup wk2 */
 457                         TRACE("found '/../'\n");
 458                         *(wk2-1) = '\0';  /* set end of string */
 459                         mp = strrchrW(root, '/');
 460                         mp2 = strrchrW(root, '\\');
 461                         if(mp2 && (!mp || mp2 < mp))
 462                             mp = mp2;
 463                         if (mp && (mp >= root)) {
 464                             /* found valid backup point */
 465                             wk2 = mp + 1;
 466                             if(wk1[2] != '/' && wk1[2] != '\\')
 467                                 wk1 += 2;
 468                             else
 469                                 wk1 += 3;
 470                         }
 471                         else {
 472                             /* did not find point, restore '/' */
 473                             *(wk2-1) = slash;
 474                             break;
 475                         }
 476                     }
 477                     else
 478                         break;
 479                 }
 480             }
 481             *wk2 = '\0';
 482             break;
 483         default:
 484             FIXME("how did we get here - state=%d\n", state);
 485             HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
 486             return E_INVALIDARG;
 487         }
 488         *wk2 = '\0';
 489         TRACE("Simplified, orig <%s>, simple <%s>\n",
 490               debugstr_w(pszUrl), debugstr_w(lpszUrlCpy));
 491     }
 492     nLen = lstrlenW(lpszUrlCpy);
 493     while ((nLen > 0) && ((lpszUrlCpy[nLen-1] <= ' ')))
 494         lpszUrlCpy[--nLen]=0;
 495
 496     if((dwFlags & URL_UNESCAPE) ||
 497        ((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszFile)
 498                 && !memcmp(wszFile, pszUrl, sizeof(wszFile))))
 499         UrlUnescapeW(lpszUrlCpy, NULL, &nLen, URL_UNESCAPE_INPLACE);
 500
 501     if((EscapeFlags = dwFlags & (URL_ESCAPE_UNSAFE |
 502                                  URL_ESCAPE_SPACES_ONLY |
 503                                  URL_ESCAPE_PERCENT |
 504                                  URL_DONT_ESCAPE_EXTRA_INFO |
 505                                  URL_ESCAPE_SEGMENT_ONLY ))) {
 506         EscapeFlags &= ~URL_ESCAPE_UNSAFE;
 507         hr = UrlEscapeW(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
 508                         EscapeFlags);
 509     } else { /* No escaping needed, just copy the string */
 510         nLen = lstrlenW(lpszUrlCpy);
 511         if(nLen < *pcchCanonicalized)
 512             memcpy(pszCanonicalized, lpszUrlCpy, (nLen + 1)*sizeof(WCHAR));
 513         else {
 514             hr = E_POINTER;
 515             nLen++;
 516         }
 517         *pcchCanonicalized = nLen;
 518     }
 519
 520     HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
 521
 522     if (hr == S_OK)
 523         TRACE("result %s\n", debugstr_w(pszCanonicalized));
 524
 525     return hr;
 526 }
 527
 528 /*************************************************************************
 529  *        UrlCombineA     [SHLWAPI.@]
 530  *
 531  * Combine two Urls.
 532  *
 533  * PARAMS
 534  *  pszBase      [I] Base Url
 535  *  pszRelative  [I] Url to combine with pszBase
 536  *  pszCombined  [O] Destination for combined Url
 537  *  pcchCombined [O] Destination for length of pszCombined
 538  *  dwFlags      [I] URL_ flags from "shlwapi.h"
 539  *
 540  * RETURNS
 541  *  Success: S_OK. pszCombined contains the combined Url, pcchCombined
 542  *           contains its length.
 543  *  Failure: An HRESULT error code indicating the error.
 544  */
 545 HRESULT WINAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative,
 546                            LPSTR pszCombined, LPDWORD pcchCombined,
 547                            DWORD dwFlags)
 548 {
 549     LPWSTR base, relative, combined;
 550     DWORD ret, len, len2;
 551
 552     TRACE("(base %s, Relative %s, Combine size %d, flags %08x) using W version\n",
 553           debugstr_a(pszBase),debugstr_a(pszRelative),
 554           pcchCombined?*pcchCombined:0,dwFlags);
 555
 556     if(!pszBase || !pszRelative || !pcchCombined)
 557         return E_INVALIDARG;
 558
 559     base = HeapAlloc(GetProcessHeap(), 0,
 560                               (3*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
 561     relative = base + INTERNET_MAX_URL_LENGTH;
 562     combined = relative + INTERNET_MAX_URL_LENGTH;
 563
 564     MultiByteToWideChar(0, 0, pszBase, -1, base, INTERNET_MAX_URL_LENGTH);
 565     MultiByteToWideChar(0, 0, pszRelative, -1, relative, INTERNET_MAX_URL_LENGTH);
 566     len = *pcchCombined;
 567
 568     ret = UrlCombineW(base, relative, pszCombined?combined:NULL, &len, dwFlags);
 569     if (ret != S_OK) {
 570         *pcchCombined = len;
 571         HeapFree(GetProcessHeap(), 0, base);
 572         return ret;
 573     }
 574
 575     len2 = WideCharToMultiByte(0, 0, combined, len, 0, 0, 0, 0);
 576     if (len2 > *pcchCombined) {
 577         *pcchCombined = len2;
 578         HeapFree(GetProcessHeap(), 0, base);
 579         return E_POINTER;
 580     }
 581     WideCharToMultiByte(0, 0, combined, len+1, pszCombined, (*pcchCombined)+1,
 582                         0, 0);
 583     *pcchCombined = len2;
 584     HeapFree(GetProcessHeap(), 0, base);
 585     return S_OK;
 586 }
 587
 588 /*************************************************************************
 589  *        UrlCombineW     [SHLWAPI.@]
 590  *
 591  * See UrlCombineA.
 592  */
 593 HRESULT WINAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative,
 594                            LPWSTR pszCombined, LPDWORD pcchCombined,
 595                            DWORD dwFlags)
 596 {
 597     PARSEDURLW base, relative;
 598     DWORD myflags, sizeloc = 0;
 599     DWORD len, res1, res2, process_case = 0;
 600     LPWSTR work, preliminary, mbase, mrelative;
 601     static const WCHAR myfilestr[] = {'f','i','l','e',':','/','/','/','\0'};
 602     HRESULT ret;
 603
 604     TRACE("(base %s, Relative %s, Combine size %d, flags %08x)\n",
 605           debugstr_w(pszBase),debugstr_w(pszRelative),
 606           pcchCombined?*pcchCombined:0,dwFlags);
 607
 608     if(!pszBase || !pszRelative || !pcchCombined)
 609         return E_INVALIDARG;
 610
 611     base.cbSize = sizeof(base);
 612     relative.cbSize = sizeof(relative);
 613
 614     /* Get space for duplicates of the input and the output */
 615     preliminary = HeapAlloc(GetProcessHeap(), 0, (3*INTERNET_MAX_URL_LENGTH) *
 616                             sizeof(WCHAR));
 617     mbase = preliminary + INTERNET_MAX_URL_LENGTH;
 618     mrelative = mbase + INTERNET_MAX_URL_LENGTH;
 619     *preliminary = '\0';
 620
 621     /* Canonicalize the base input prior to looking for the scheme */
 622     myflags = dwFlags & (URL_DONT_SIMPLIFY | URL_UNESCAPE);
 623     len = INTERNET_MAX_URL_LENGTH;
 624     ret = UrlCanonicalizeW(pszBase, mbase, &len, myflags);
 625
 626     /* Canonicalize the relative input prior to looking for the scheme */
 627     len = INTERNET_MAX_URL_LENGTH;
 628     ret = UrlCanonicalizeW(pszRelative, mrelative, &len, myflags);
 629
 630     /* See if the base has a scheme */
 631     res1 = ParseURLW(mbase, &base);
 632     if (res1) {
 633         /* if pszBase has no scheme, then return pszRelative */
 634         TRACE("no scheme detected in Base\n");
 635         process_case = 1;
 636     }
 637     else do {
 638         BOOL manual_search = FALSE;
 639
 640         /* mk is a special case */
 641         if(base.nScheme == URL_SCHEME_MK) {
 642             static const WCHAR wsz[] = {':',':',0};
 643
 644             WCHAR *ptr = strstrW(base.pszSuffix, wsz);
 645             if(ptr) {
 646                 int delta;
 647
 648                 ptr += 2;
 649                 delta = ptr-base.pszSuffix;
 650                 base.cchProtocol += delta;
 651                 base.pszSuffix += delta;
 652                 base.cchSuffix -= delta;
 653             }
 654         }else {
 655             /* get size of location field (if it exists) */
 656             work = (LPWSTR)base.pszSuffix;
 657             sizeloc = 0;
 658             if (*work++ == '/') {
 659                 if (*work++ == '/') {
 660                     /* At this point have start of location and
 661                      * it ends at next '/' or end of string.
 662                      */
 663                     while(*work && (*work != '/')) work++;
 664                     sizeloc = (DWORD)(work - base.pszSuffix);
 665                 }
 666             }
 667         }
 668
 669         /* If there is a '#' and the characters immediately preceding it are
 670          * ".htm[l]", then begin looking for the last leaf starting from
 671          * the '#'. Otherwise the '#' is not meaningful and just start
 672          * looking from the end. */
 673         if ((work = strchrW(base.pszSuffix + sizeloc, '#'))) {
 674             const WCHAR htmlW[] = {'.','h','t','m','l',0};
 675             const int len_htmlW = 5;
 676             const WCHAR htmW[] = {'.','h','t','m',0};
 677             const int len_htmW = 4;
 678
 679             if (work - base.pszSuffix > len_htmW * sizeof(WCHAR)) {
 680                 work -= len_htmW;
 681                 if (strncmpiW(work, htmW, len_htmW) == 0)
 682                     manual_search = TRUE;
 683                 work += len_htmW;
 684             }
 685
 686             if (!manual_search &&
 687                     work - base.pszSuffix > len_htmlW * sizeof(WCHAR)) {
 688                 work -= len_htmlW;
 689                 if (strncmpiW(work, htmlW, len_htmlW) == 0)
 690                     manual_search = TRUE;
 691                 work += len_htmlW;
 692             }
 693         }
 694
 695         if (manual_search) {
 696             /* search backwards starting from the current position */
 697             while (*work != '/' && work > base.pszSuffix + sizeloc)
 698                 --work;
 699             if (work > base.pszSuffix + sizeloc)
 700                 base.cchSuffix = work - base.pszSuffix + 1;
 701         }else {
 702             /* search backwards starting from the end of the string */
 703             work = strrchrW((base.pszSuffix+sizeloc), '/');
 704             if (work) {
 705                 len = (DWORD)(work - base.pszSuffix + 1);
 706                 base.cchSuffix = len;
 707             }
 708         }
 709
 710         /*
 711          * At this point:
 712          *    .pszSuffix   points to location (starting with '//')
 713          *    .cchSuffix   length of location (above) and rest less the last
 714          *                 leaf (if any)
 715          *    sizeloc   length of location (above) up to but not including
 716          *              the last '/'
 717          */
 718
 719         res2 = ParseURLW(mrelative, &relative);
 720         if (res2) {
 721             /* no scheme in pszRelative */
 722             TRACE("no scheme detected in Relative\n");
 723             relative.pszSuffix = mrelative;  /* case 3,4,5 depends on this */
 724             relative.cchSuffix = strlenW(mrelative);
 725             if (*pszRelative  == ':') {
 726                 /* case that is either left alone or uses pszBase */
 727                 if (dwFlags & URL_PLUGGABLE_PROTOCOL) {
 728                     process_case = 5;
 729                     break;
 730                 }
 731                 process_case = 1;
 732                 break;
 733             }
 734             if (isalnum(*mrelative) && (*(mrelative + 1) == ':')) {
 735                 /* case that becomes "file:///" */
 736                 strcpyW(preliminary, myfilestr);
 737                 process_case = 1;
 738                 break;
 739             }
 740             if ((*mrelative == '/') && (*(mrelative+1) == '/')) {
 741                 /* pszRelative has location and rest */
 742                 process_case = 3;
 743                 break;
 744             }
 745             if (*mrelative == '/') {
 746                 /* case where pszRelative is root to location */
 747                 process_case = 4;
 748                 break;
 749             }
 750             process_case = (*base.pszSuffix == '/' || base.nScheme == URL_SCHEME_MK) ? 5 : 3;
 751             break;
 752         }
 753
 754         /* handle cases where pszRelative has scheme */
 755         if ((base.cchProtocol == relative.cchProtocol) &&
 756             (strncmpW(base.pszProtocol, relative.pszProtocol, base.cchProtocol) == 0)) {
 757
 758             /* since the schemes are the same */
 759             if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
 760                 /* case where pszRelative replaces location and following */
 761                 process_case = 3;
 762                 break;
 763             }
 764             if (*relative.pszSuffix == '/') {
 765                 /* case where pszRelative is root to location */
 766                 process_case = 4;
 767                 break;
 768             }
 769             /* replace either just location if base's location starts with a
 770              * slash or otherwise everything */
 771             process_case = (*base.pszSuffix == '/') ? 5 : 1;
 772             break;
 773         }
 774         if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
 775             /* case where pszRelative replaces scheme, location,
 776              * and following and handles PLUGGABLE
 777              */
 778             process_case = 2;
 779             break;
 780         }
 781         process_case = 1;
 782         break;
 783     } while(FALSE); /* a little trick to allow easy exit from nested if's */
 784
 785     ret = S_OK;
 786     switch (process_case) {
 787
 788     case 1:  /*
 789               * Return pszRelative appended to what ever is in pszCombined,
 790               * (which may the string "file:///"
 791               */
 792         strcatW(preliminary, mrelative);
 793         break;
 794
 795     case 2:  /* case where pszRelative replaces scheme, and location */
 796         strcpyW(preliminary, mrelative);
 797         break;
 798
 799     case 3:  /*
 800               * Return the pszBase scheme with pszRelative. Basically
 801               * keeps the scheme and replaces the domain and following.
 802               */
 803         memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1)*sizeof(WCHAR));
 804         work = preliminary + base.cchProtocol + 1;
 805         strcpyW(work, relative.pszSuffix);
 806         break;
 807
 808     case 4:  /*
 809               * Return the pszBase scheme and location but everything
 810               * after the location is pszRelative. (Replace document
 811               * from root on.)
 812               */
 813         memcpy(preliminary, base.pszProtocol, (base.cchProtocol+1+sizeloc)*sizeof(WCHAR));
 814         work = preliminary + base.cchProtocol + 1 + sizeloc;
 815         if (dwFlags & URL_PLUGGABLE_PROTOCOL)
 816             *(work++) = '/';
 817         strcpyW(work, relative.pszSuffix);
 818         break;
 819
 820     case 5:  /*
 821               * Return the pszBase without its document (if any) and
 822               * append pszRelative after its scheme.
 823               */
 824         memcpy(preliminary, base.pszProtocol,
 825                (base.cchProtocol+1+base.cchSuffix)*sizeof(WCHAR));
 826         work = preliminary + base.cchProtocol+1+base.cchSuffix - 1;
 827         if (*work++ != '/')
 828             *(work++) = '/';
 829         strcpyW(work, relative.pszSuffix);
 830         break;
 831
 832     default:
 833         FIXME("How did we get here????? process_case=%d\n", process_case);
 834         ret = E_INVALIDARG;
 835     }
 836
 837     if (ret == S_OK) {
 838         /* Reuse mrelative as temp storage as its already allocated and not needed anymore */
 839         if(*pcchCombined == 0)
 840             *pcchCombined = 1;
 841         ret = UrlCanonicalizeW(preliminary, mrelative, pcchCombined, (dwFlags & ~URL_FILE_USE_PATHURL));
 842         if(SUCCEEDED(ret) && pszCombined) {
 843             lstrcpyW(pszCombined, mrelative);
 844         }
 845         TRACE("return-%d len=%d, %s\n",
 846               process_case, *pcchCombined, debugstr_w(pszCombined));
 847     }
 848     HeapFree(GetProcessHeap(), 0, preliminary);
 849     return ret;
 850 }
 851
 852 /*************************************************************************
 853  *      UrlEscapeA      [SHLWAPI.@]
 854  */
 855
 856 HRESULT WINAPI UrlEscapeA(
 857         LPCSTR pszUrl,
 858         LPSTR pszEscaped,
 859         LPDWORD pcchEscaped,
 860         DWORD dwFlags)
 861 {
 862     WCHAR bufW[INTERNET_MAX_URL_LENGTH];
 863     WCHAR *escapedW = bufW;
 864     UNICODE_STRING urlW;
 865     HRESULT ret;
 866     DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
 867
 868     if (!pszEscaped || !pcchEscaped || !*pcchEscaped)
 869         return E_INVALIDARG;
 870
 871     if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
 872         return E_INVALIDARG;
 873     if((ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags)) == E_POINTER) {
 874         escapedW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
 875         ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags);
 876     }
 877     if(ret == S_OK) {
 878         RtlUnicodeToMultiByteSize(&lenA, escapedW, lenW * sizeof(WCHAR));
 879         if(*pcchEscaped > lenA) {
 880             RtlUnicodeToMultiByteN(pszEscaped, *pcchEscaped - 1, &lenA, escapedW, lenW * sizeof(WCHAR));
 881             pszEscaped[lenA] = 0;
 882             *pcchEscaped = lenA;
 883         } else {
 884             *pcchEscaped = lenA + 1;
 885             ret = E_POINTER;
 886         }
 887     }
 888     if(escapedW != bufW) HeapFree(GetProcessHeap(), 0, escapedW);
 889     RtlFreeUnicodeString(&urlW);
 890     return ret;
 891 }
 892
 893 #define WINE_URL_BASH_AS_SLASH    0x01
 894 #define WINE_URL_COLLAPSE_SLASHES 0x02
 895 #define WINE_URL_ESCAPE_SLASH     0x04
 896 #define WINE_URL_ESCAPE_HASH      0x08
 897 #define WINE_URL_ESCAPE_QUESTION  0x10
 898 #define WINE_URL_STOP_ON_HASH     0x20
 899 #define WINE_URL_STOP_ON_QUESTION 0x40
 900
 901 static inline BOOL URL_NeedEscapeW(WCHAR ch, DWORD dwFlags, DWORD int_flags)
 902 {
 903
 904     if (isalnumW(ch))
 905         return FALSE;
 906
 907     if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
 908         if(ch == ' ')
 909             return TRUE;
 910         else
 911             return FALSE;
 912     }
 913
 914     if ((dwFlags & URL_ESCAPE_PERCENT) && (ch == '%'))
 915         return TRUE;
 916
 917     if (ch <= 31 || ch >= 127)
 918         return TRUE;
 919
 920     else {
 921         switch (ch) {
 922         case ' ':
 923         case '<':
 924         case '>':
 925         case '\"':
 926         case '{':
 927         case '}':
 928         case '|':
 929         case '\\':
 930         case '^':
 931         case ']':
 932         case '[':
 933         case '`':
 934         case '&':
 935             return TRUE;
 936
 937         case '/':
 938             if (int_flags & WINE_URL_ESCAPE_SLASH) return TRUE;
 939             return FALSE;
 940
 941         case '?':
 942             if (int_flags & WINE_URL_ESCAPE_QUESTION) return TRUE;
 943             return FALSE;
 944
 945         case '#':
 946             if (int_flags & WINE_URL_ESCAPE_HASH) return TRUE;
 947             return FALSE;
 948
 949         default:
 950             return FALSE;
 951         }
 952     }
 953 }
 954
 955
 956 /*************************************************************************
 957  *      UrlEscapeW      [SHLWAPI.@]
 958  *
 959  * Converts unsafe characters in a Url into escape sequences.
 960  *
 961  * PARAMS
 962  *  pszUrl      [I]   Url to modify
 963  *  pszEscaped  [O]   Destination for modified Url
 964  *  pcchEscaped [I/O] Length of pszUrl, destination for length of pszEscaped
 965  *  dwFlags     [I]   URL_ flags from "shlwapi.h"
 966  *
 967  * RETURNS
 968  *  Success: S_OK. pszEscaped contains the escaped Url, pcchEscaped
 969  *           contains its length.
 970  *  Failure: E_POINTER, if pszEscaped is not large enough. In this case
 971  *           pcchEscaped is set to the required length.
 972  *
 973  * Converts unsafe characters into their escape sequences.
 974  *
 975  * NOTES
 976  * - By default this function stops converting at the first '?' or
 977  *  '#' character.
 978  * - If dwFlags contains URL_ESCAPE_SPACES_ONLY then only spaces are
 979  *   converted, but the conversion continues past a '?' or '#'.
 980  * - Note that this function did not work well (or at all) in shlwapi version 4.
 981  *
 982  * BUGS
 983  *  Only the following flags are implemented:
 984  *|     URL_ESCAPE_SPACES_ONLY
 985  *|     URL_DONT_ESCAPE_EXTRA_INFO
 986  *|     URL_ESCAPE_SEGMENT_ONLY
 987  *|     URL_ESCAPE_PERCENT
 988  */
 989 HRESULT WINAPI UrlEscapeW(
 990         LPCWSTR pszUrl,
 991         LPWSTR pszEscaped,
 992         LPDWORD pcchEscaped,
 993         DWORD dwFlags)
 994 {
 995     LPCWSTR src;
 996     DWORD needed = 0, ret;
 997     BOOL stop_escaping = FALSE;
 998     WCHAR next[5], *dst = pszEscaped;
 999     INT len;
1000     PARSEDURLW parsed_url;
1001     DWORD int_flags;
1002     DWORD slashes = 0;
1003     static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
1004
1005     TRACE("(%s %p %p 0x%08x)\n", debugstr_w(pszUrl), pszEscaped,
1006           pcchEscaped, dwFlags);
1007
1008     if(!pszUrl || !pcchEscaped)
1009         return E_INVALIDARG;
1010
1011     if(dwFlags & ~(URL_ESCAPE_SPACES_ONLY |
1012                    URL_ESCAPE_SEGMENT_ONLY |
1013                    URL_DONT_ESCAPE_EXTRA_INFO |
1014                    URL_ESCAPE_PERCENT))
1015         FIXME("Unimplemented flags: %08x\n", dwFlags);
1016
1017     /* fix up flags */
1018     if (dwFlags & URL_ESCAPE_SPACES_ONLY)
1019         /* if SPACES_ONLY specified, reset the other controls */
1020         dwFlags &= ~(URL_DONT_ESCAPE_EXTRA_INFO |
1021                      URL_ESCAPE_PERCENT |
1022                      URL_ESCAPE_SEGMENT_ONLY);
1023
1024     else
1025         /* if SPACES_ONLY *not* specified the assume DONT_ESCAPE_EXTRA_INFO */
1026         dwFlags |= URL_DONT_ESCAPE_EXTRA_INFO;
1027
1028
1029     int_flags = 0;
1030     if(dwFlags & URL_ESCAPE_SEGMENT_ONLY) {
1031         int_flags = WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH | WINE_URL_ESCAPE_SLASH;
1032     } else {
1033         parsed_url.cbSize = sizeof(parsed_url);
1034         if(ParseURLW(pszUrl, &parsed_url) != S_OK)
1035             parsed_url.nScheme = URL_SCHEME_INVALID;
1036
1037         TRACE("scheme = %d (%s)\n", parsed_url.nScheme, debugstr_wn(parsed_url.pszProtocol, parsed_url.cchProtocol));
1038
1039         if(dwFlags & URL_DONT_ESCAPE_EXTRA_INFO)
1040             int_flags = WINE_URL_STOP_ON_HASH | WINE_URL_STOP_ON_QUESTION;
1041
1042         switch(parsed_url.nScheme) {
1043         case URL_SCHEME_FILE:
1044             int_flags |= WINE_URL_BASH_AS_SLASH | WINE_URL_COLLAPSE_SLASHES | WINE_URL_ESCAPE_HASH;
1045             int_flags &= ~WINE_URL_STOP_ON_HASH;
1046             break;
1047
1048         case URL_SCHEME_HTTP:
1049         case URL_SCHEME_HTTPS:
1050             int_flags |= WINE_URL_BASH_AS_SLASH;
1051             if(parsed_url.pszSuffix[0] != '/' && parsed_url.pszSuffix[0] != '\\')
1052                 int_flags |= WINE_URL_ESCAPE_SLASH;
1053             break;
1054
1055         case URL_SCHEME_MAILTO:
1056             int_flags |= WINE_URL_ESCAPE_SLASH | WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH;
1057             int_flags &= ~(WINE_URL_STOP_ON_QUESTION | WINE_URL_STOP_ON_HASH);
1058             break;
1059
1060         case URL_SCHEME_INVALID:
1061             break;
1062
1063         case URL_SCHEME_FTP:
1064         default:
1065             if(parsed_url.pszSuffix[0] != '/')
1066                 int_flags |= WINE_URL_ESCAPE_SLASH;
1067             break;
1068         }
1069     }
1070
1071     for(src = pszUrl; *src; ) {
1072         WCHAR cur = *src;
1073         len = 0;
1074
1075         if((int_flags & WINE_URL_COLLAPSE_SLASHES) && src == pszUrl + parsed_url.cchProtocol + 1) {
1076             int localhost_len = sizeof(localhost)/sizeof(WCHAR) - 1;
1077             while(cur == '/' || cur == '\\') {
1078                 slashes++;
1079                 cur = *++src;
1080             }
1081             if(slashes == 2 && !strncmpiW(src, localhost, localhost_len)) { /* file://localhost/ -> file:/// */
1082                 if(*(src + localhost_len) == '/' || *(src + localhost_len) == '\\')
1083                 src += localhost_len + 1;
1084                 slashes = 3;
1085             }
1086
1087             switch(slashes) {
1088             case 1:
1089             case 3:
1090                 next[0] = next[1] = next[2] = '/';
1091                 len = 3;
1092                 break;
1093             case 0:
1094                 len = 0;
1095                 break;
1096             default:
1097                 next[0] = next[1] = '/';
1098                 len = 2;
1099                 break;
1100             }
1101         }
1102         if(len == 0) {
1103
1104             if(cur == '#' && (int_flags & WINE_URL_STOP_ON_HASH))
1105                 stop_escaping = TRUE;
1106
1107             if(cur == '?' && (int_flags & WINE_URL_STOP_ON_QUESTION))
1108                 stop_escaping = TRUE;
1109
1110             if(cur == '\\' && (int_flags & WINE_URL_BASH_AS_SLASH) && !stop_escaping) cur = '/';
1111
1112             if(URL_NeedEscapeW(cur, dwFlags, int_flags) && stop_escaping == FALSE) {
1113                 next[0] = '%';
1114                 next[1] = hexDigits[(cur >> 4) & 0xf];
1115                 next[2] = hexDigits[cur & 0xf];
1116                 len = 3;
1117             } else {
1118                 next[0] = cur;
1119                 len = 1;
1120             }
1121             src++;
1122         }
1123
1124         if(needed + len <= *pcchEscaped) {
1125             memcpy(dst, next, len*sizeof(WCHAR));
1126             dst += len;
1127         }
1128         needed += len;
1129     }
1130
1131     if(needed < *pcchEscaped) {
1132         *dst = '\0';
1133         ret = S_OK;
1134     } else {
1135         needed++; /* add one for the '\0' */
1136         ret = E_POINTER;
1137     }
1138     *pcchEscaped = needed;
1139     return ret;
1140 }
1141
1142
1143 /*************************************************************************
1144  *      UrlUnescapeA    [SHLWAPI.@]
1145  *
1146  * Converts Url escape sequences back to ordinary characters.
1147  *
1148  * PARAMS
1149  *  pszUrl        [I/O]  Url to convert
1150  *  pszUnescaped  [O]    Destination for converted Url
1151  *  pcchUnescaped [I/O]  Size of output string
1152  *  dwFlags       [I]    URL_ESCAPE_ Flags from "shlwapi.h"
1153  *
1154  * RETURNS
1155  *  Success: S_OK. The converted value is in pszUnescaped, or in pszUrl if
1156  *           dwFlags includes URL_ESCAPE_INPLACE.
1157  *  Failure: E_POINTER if the converted Url is bigger than pcchUnescaped. In
1158  *           this case pcchUnescaped is set to the size required.
1159  * NOTES
1160  *  If dwFlags includes URL_DONT_ESCAPE_EXTRA_INFO, the conversion stops at
1161  *  the first occurrence of either a '?' or '#' character.
1162  */
1163 HRESULT WINAPI UrlUnescapeA(
1164         LPSTR pszUrl,
1165         LPSTR pszUnescaped,
1166         LPDWORD pcchUnescaped,
1167         DWORD dwFlags)
1168 {
1169     char *dst, next;
1170     LPCSTR src;
1171     HRESULT ret;
1172     DWORD needed;
1173     BOOL stop_unescaping = FALSE;
1174
1175     TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_a(pszUrl), pszUnescaped,
1176           pcchUnescaped, dwFlags);
1177
1178     if (!pszUrl) return E_INVALIDARG;
1179
1180     if(dwFlags & URL_UNESCAPE_INPLACE)
1181         dst = pszUrl;
1182     else
1183     {
1184         if (!pszUnescaped || !pcchUnescaped) return E_INVALIDARG;
1185         dst = pszUnescaped;
1186     }
1187
1188     for(src = pszUrl, needed = 0; *src; src++, needed++) {
1189         if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1190            (*src == '#' || *src == '?')) {
1191             stop_unescaping = TRUE;
1192             next = *src;
1193         } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
1194                   && stop_unescaping == FALSE) {
1195             INT ih;
1196             char buf[3];
1197             memcpy(buf, src + 1, 2);
1198             buf[2] = '\0';
1199             ih = strtol(buf, NULL, 16);
1200             next = (CHAR) ih;
1201             src += 2; /* Advance to end of escape */
1202         } else
1203             next = *src;
1204
1205         if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1206             *dst++ = next;
1207     }
1208
1209     if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1210         *dst = '\0';
1211         ret = S_OK;
1212     } else {
1213         needed++; /* add one for the '\0' */
1214         ret = E_POINTER;
1215     }
1216     if(!(dwFlags & URL_UNESCAPE_INPLACE))
1217         *pcchUnescaped = needed;
1218
1219     if (ret == S_OK) {
1220         TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1221               debugstr_a(pszUrl) : debugstr_a(pszUnescaped));
1222     }
1223
1224     return ret;
1225 }
1226
1227 /*************************************************************************
1228  *      UrlUnescapeW    [SHLWAPI.@]
1229  *
1230  * See UrlUnescapeA.
1231  */
1232 HRESULT WINAPI UrlUnescapeW(
1233         LPWSTR pszUrl,
1234         LPWSTR pszUnescaped,
1235         LPDWORD pcchUnescaped,
1236         DWORD dwFlags)
1237 {
1238     WCHAR *dst, next;
1239     LPCWSTR src;
1240     HRESULT ret;
1241     DWORD needed;
1242     BOOL stop_unescaping = FALSE;
1243
1244     TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszUrl), pszUnescaped,
1245           pcchUnescaped, dwFlags);
1246
1247     if(!pszUrl) return E_INVALIDARG;
1248
1249     if(dwFlags & URL_UNESCAPE_INPLACE)
1250         dst = pszUrl;
1251     else
1252     {
1253         if (!pszUnescaped || !pcchUnescaped) return E_INVALIDARG;
1254         dst = pszUnescaped;
1255     }
1256
1257     for(src = pszUrl, needed = 0; *src; src++, needed++) {
1258         if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1259            (*src == '#' || *src == '?')) {
1260             stop_unescaping = TRUE;
1261             next = *src;
1262         } else if(*src == '%' && isxdigitW(*(src + 1)) && isxdigitW(*(src + 2))
1263                   && stop_unescaping == FALSE) {
1264             INT ih;
1265             WCHAR buf[5] = {'0','x',0};
1266             memcpy(buf + 2, src + 1, 2*sizeof(WCHAR));
1267             buf[4] = 0;
1268             StrToIntExW(buf, STIF_SUPPORT_HEX, &ih);
1269             next = (WCHAR) ih;
1270             src += 2; /* Advance to end of escape */
1271         } else
1272             next = *src;
1273
1274         if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1275             *dst++ = next;
1276     }
1277
1278     if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1279         *dst = '\0';
1280         ret = S_OK;
1281     } else {
1282         needed++; /* add one for the '\0' */
1283         ret = E_POINTER;
1284     }
1285     if(!(dwFlags & URL_UNESCAPE_INPLACE))
1286         *pcchUnescaped = needed;
1287
1288     if (ret == S_OK) {
1289         TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1290               debugstr_w(pszUrl) : debugstr_w(pszUnescaped));
1291     }
1292
1293     return ret;
1294 }
1295
1296 /*************************************************************************
1297  *      UrlGetLocationA         [SHLWAPI.@]
1298  *
1299  * Get the location from a Url.
1300  *
1301  * PARAMS
1302  *  pszUrl [I] Url to get the location from
1303  *
1304  * RETURNS
1305  *  A pointer to the start of the location in pszUrl, or NULL if there is
1306  *  no location.
1307  *
1308  * NOTES
1309  *  - MSDN erroneously states that "The location is the segment of the Url
1310  *    starting with a '?' or '#' character". Neither V4 nor V5 of shlwapi.dll
1311  *    stop at '?' and always return a NULL in this case.
1312  *  - MSDN also erroneously states that "If a file URL has a query string,
1313  *    the returned string is the query string". In all tested cases, if the
1314  *    Url starts with "fi" then a NULL is returned. V5 gives the following results:
1315  *|       Result   Url
1316  *|       ------   ---
1317  *|       NULL     file://aa/b/cd#hohoh
1318  *|       #hohoh   http://aa/b/cd#hohoh
1319  *|       NULL     fi://aa/b/cd#hohoh
1320  *|       #hohoh   ff://aa/b/cd#hohoh
1321  */
1322 LPCSTR WINAPI UrlGetLocationA(
1323         LPCSTR pszUrl)
1324 {
1325     PARSEDURLA base;
1326     DWORD res1;
1327
1328     base.cbSize = sizeof(base);
1329     res1 = ParseURLA(pszUrl, &base);
1330     if (res1) return NULL;  /* invalid scheme */
1331
1332     /* if scheme is file: then never return pointer */
1333     if (strncmp(base.pszProtocol, "file", min(4,base.cchProtocol)) == 0) return NULL;
1334
1335     /* Look for '#' and return its addr */
1336     return strchr(base.pszSuffix, '#');
1337 }
1338
1339 /*************************************************************************
1340  *      UrlGetLocationW         [SHLWAPI.@]
1341  *
1342  * See UrlGetLocationA.
1343  */
1344 LPCWSTR WINAPI UrlGetLocationW(
1345         LPCWSTR pszUrl)
1346 {
1347     PARSEDURLW base;
1348     DWORD res1;
1349
1350     base.cbSize = sizeof(base);
1351     res1 = ParseURLW(pszUrl, &base);
1352     if (res1) return NULL;  /* invalid scheme */
1353
1354     /* if scheme is file: then never return pointer */
1355     if (strncmpW(base.pszProtocol, fileW, min(4,base.cchProtocol)) == 0) return NULL;
1356
1357     /* Look for '#' and return its addr */
1358     return strchrW(base.pszSuffix, '#');
1359 }
1360
1361 /*************************************************************************
1362  *      UrlCompareA     [SHLWAPI.@]
1363  *
1364  * Compare two Urls.
1365  *
1366  * PARAMS
1367  *  pszUrl1      [I] First Url to compare
1368  *  pszUrl2      [I] Url to compare to pszUrl1
1369  *  fIgnoreSlash [I] TRUE = compare only up to a final slash
1370  *
1371  * RETURNS
1372  *  less than zero, zero, or greater than zero indicating pszUrl2 is greater
1373  *  than, equal to, or less than pszUrl1 respectively.
1374  */
1375 INT WINAPI UrlCompareA(
1376         LPCSTR pszUrl1,
1377         LPCSTR pszUrl2,
1378         BOOL fIgnoreSlash)
1379 {
1380     INT ret, len, len1, len2;
1381
1382     if (!fIgnoreSlash)
1383         return strcmp(pszUrl1, pszUrl2);
1384     len1 = strlen(pszUrl1);
1385     if (pszUrl1[len1-1] == '/') len1--;
1386     len2 = strlen(pszUrl2);
1387     if (pszUrl2[len2-1] == '/') len2--;
1388     if (len1 == len2)
1389         return strncmp(pszUrl1, pszUrl2, len1);
1390     len = min(len1, len2);
1391     ret = strncmp(pszUrl1, pszUrl2, len);
1392     if (ret) return ret;
1393     if (len1 > len2) return 1;
1394     return -1;
1395 }
1396
1397 /*************************************************************************
1398  *      UrlCompareW     [SHLWAPI.@]
1399  *
1400  * See UrlCompareA.
1401  */
1402 INT WINAPI UrlCompareW(
1403         LPCWSTR pszUrl1,
1404         LPCWSTR pszUrl2,
1405         BOOL fIgnoreSlash)
1406 {
1407     INT ret;
1408     size_t len, len1, len2;
1409
1410     if (!fIgnoreSlash)
1411         return strcmpW(pszUrl1, pszUrl2);
1412     len1 = strlenW(pszUrl1);
1413     if (pszUrl1[len1-1] == '/') len1--;
1414     len2 = strlenW(pszUrl2);
1415     if (pszUrl2[len2-1] == '/') len2--;
1416     if (len1 == len2)
1417         return strncmpW(pszUrl1, pszUrl2, len1);
1418     len = min(len1, len2);
1419     ret = strncmpW(pszUrl1, pszUrl2, len);
1420     if (ret) return ret;
1421     if (len1 > len2) return 1;
1422     return -1;
1423 }
1424
1425 /*************************************************************************
1426  *      HashData        [SHLWAPI.@]
1427  *
1428  * Hash an input block into a variable sized digest.
1429  *
1430  * PARAMS
1431  *  lpSrc    [I] Input block
1432  *  nSrcLen  [I] Length of lpSrc
1433  *  lpDest   [I] Output for hash digest
1434  *  nDestLen [I] Length of lpDest
1435  *
1436  * RETURNS
1437  *  Success: TRUE. lpDest is filled with the computed hash value.
1438  *  Failure: FALSE, if any argument is invalid.
1439  */
1440 HRESULT WINAPI HashData(const unsigned char *lpSrc, DWORD nSrcLen,
1441                      unsigned char *lpDest, DWORD nDestLen)
1442 {
1443   INT srcCount = nSrcLen - 1, destCount = nDestLen - 1;
1444
1445   if (!lpSrc || !lpDest)
1446     return E_INVALIDARG;
1447
1448   while (destCount >= 0)
1449   {
1450     lpDest[destCount] = (destCount & 0xff);
1451     destCount--;
1452   }
1453
1454   while (srcCount >= 0)
1455   {
1456     destCount = nDestLen - 1;
1457     while (destCount >= 0)
1458     {
1459       lpDest[destCount] = HashDataLookup[lpSrc[srcCount] ^ lpDest[destCount]];
1460       destCount--;
1461     }
1462     srcCount--;
1463   }
1464   return S_OK;
1465 }
1466
1467 /*************************************************************************
1468  *      UrlHashA        [SHLWAPI.@]
1469  *
1470  * Produce a Hash from a Url.
1471  *
1472  * PARAMS
1473  *  pszUrl   [I] Url to hash
1474  *  lpDest   [O] Destinationh for hash
1475  *  nDestLen [I] Length of lpDest
1476  *
1477  * RETURNS
1478  *  Success: S_OK. lpDest is filled with the computed hash value.
1479  *  Failure: E_INVALIDARG, if any argument is invalid.
1480  */
1481 HRESULT WINAPI UrlHashA(LPCSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1482 {
1483   if (IsBadStringPtrA(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1484     return E_INVALIDARG;
1485
1486   HashData((const BYTE*)pszUrl, (int)strlen(pszUrl), lpDest, nDestLen);
1487   return S_OK;
1488 }
1489
1490 /*************************************************************************
1491  * UrlHashW     [SHLWAPI.@]
1492  *
1493  * See UrlHashA.
1494  */
1495 HRESULT WINAPI UrlHashW(LPCWSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1496 {
1497   char szUrl[MAX_PATH];
1498
1499   TRACE("(%s,%p,%d)\n",debugstr_w(pszUrl), lpDest, nDestLen);
1500
1501   if (IsBadStringPtrW(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1502     return E_INVALIDARG;
1503
1504   /* Win32 hashes the data as an ASCII string, presumably so that both A+W
1505    * return the same digests for the same URL.
1506    */
1507   WideCharToMultiByte(0, 0, pszUrl, -1, szUrl, MAX_PATH, 0, 0);
1508   HashData((const BYTE*)szUrl, (int)strlen(szUrl), lpDest, nDestLen);
1509   return S_OK;
1510 }
1511
1512 /*************************************************************************
1513  *      UrlApplySchemeA [SHLWAPI.@]
1514  *
1515  * Apply a scheme to a Url.
1516  *
1517  * PARAMS
1518  *  pszIn   [I]   Url to apply scheme to
1519  *  pszOut  [O]   Destination for modified Url
1520  *  pcchOut [I/O] Length of pszOut/destination for length of pszOut
1521  *  dwFlags [I]   URL_ flags from "shlwapi.h"
1522  *
1523  * RETURNS
1524  *  Success: S_OK: pszOut contains the modified Url, pcchOut contains its length.
1525  *  Failure: An HRESULT error code describing the error.
1526  */
1527 HRESULT WINAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1528 {
1529     LPWSTR in, out;
1530     HRESULT ret;
1531     DWORD len;
1532
1533     TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_a(pszIn),
1534             pszOut, pcchOut, pcchOut ? *pcchOut : 0, dwFlags);
1535
1536     if (!pszIn || !pszOut || !pcchOut) return E_INVALIDARG;
1537
1538     in = HeapAlloc(GetProcessHeap(), 0,
1539                   (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
1540     out = in + INTERNET_MAX_URL_LENGTH;
1541
1542     MultiByteToWideChar(CP_ACP, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
1543     len = INTERNET_MAX_URL_LENGTH;
1544
1545     ret = UrlApplySchemeW(in, out, &len, dwFlags);
1546     if (ret != S_OK) {
1547         HeapFree(GetProcessHeap(), 0, in);
1548         return ret;
1549     }
1550
1551     len = WideCharToMultiByte(CP_ACP, 0, out, -1, NULL, 0, NULL, NULL);
1552     if (len > *pcchOut) {
1553         ret = E_POINTER;
1554         goto cleanup;
1555     }
1556
1557     WideCharToMultiByte(CP_ACP, 0, out, -1, pszOut, *pcchOut, NULL, NULL);
1558     len--;
1559
1560 cleanup:
1561     *pcchOut = len;
1562     HeapFree(GetProcessHeap(), 0, in);
1563     return ret;
1564 }
1565
1566 static HRESULT URL_GuessScheme(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1567 {
1568     HKEY newkey;
1569     BOOL j;
1570     INT index;
1571     DWORD value_len, data_len, dwType, i;
1572     WCHAR reg_path[MAX_PATH];
1573     WCHAR value[MAX_PATH], data[MAX_PATH];
1574     WCHAR Wxx, Wyy;
1575
1576     MultiByteToWideChar(0, 0,
1577               "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes",
1578                         -1, reg_path, MAX_PATH);
1579     RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_path, 0, 1, &newkey);
1580     index = 0;
1581     while(value_len = data_len = MAX_PATH,
1582           RegEnumValueW(newkey, index, value, &value_len,
1583                         0, &dwType, (LPVOID)data, &data_len) == 0) {
1584         TRACE("guess %d %s is %s\n",
1585               index, debugstr_w(value), debugstr_w(data));
1586
1587         j = FALSE;
1588         for(i=0; i<value_len; i++) {
1589             Wxx = pszIn[i];
1590             Wyy = value[i];
1591             /* remember that TRUE is not-equal */
1592             j = ChrCmpIW(Wxx, Wyy);
1593             if (j) break;
1594         }
1595         if ((i == value_len) && !j) {
1596             if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1597                 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1598                 RegCloseKey(newkey);
1599                 return E_POINTER;
1600             }
1601             strcpyW(pszOut, data);
1602             strcatW(pszOut, pszIn);
1603             *pcchOut = strlenW(pszOut);
1604             TRACE("matched and set to %s\n", debugstr_w(pszOut));
1605             RegCloseKey(newkey);
1606             return S_OK;
1607         }
1608         index++;
1609     }
1610     RegCloseKey(newkey);
1611     return E_FAIL;
1612 }
1613
1614 static HRESULT URL_ApplyDefault(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1615 {
1616     HKEY newkey;
1617     DWORD data_len, dwType;
1618     WCHAR data[MAX_PATH];
1619
1620     static const WCHAR prefix_keyW[] =
1621         {'S','o','f','t','w','a','r','e',
1622          '\\','M','i','c','r','o','s','o','f','t',
1623          '\\','W','i','n','d','o','w','s',
1624          '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
1625          '\\','U','R','L',
1626          '\\','D','e','f','a','u','l','t','P','r','e','f','i','x',0};
1627
1628     /* get and prepend default */
1629     RegOpenKeyExW(HKEY_LOCAL_MACHINE, prefix_keyW, 0, 1, &newkey);
1630     data_len = sizeof(data);
1631     RegQueryValueExW(newkey, NULL, 0, &dwType, (LPBYTE)data, &data_len);
1632     RegCloseKey(newkey);
1633     if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1634         *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1635         return E_POINTER;
1636     }
1637     strcpyW(pszOut, data);
1638     strcatW(pszOut, pszIn);
1639     *pcchOut = strlenW(pszOut);
1640     TRACE("used default %s\n", debugstr_w(pszOut));
1641     return S_OK;
1642 }
1643
1644 /*************************************************************************
1645  *      UrlApplySchemeW [SHLWAPI.@]
1646  *
1647  * See UrlApplySchemeA.
1648  */
1649 HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1650 {
1651     PARSEDURLW in_scheme;
1652     DWORD res1;
1653     HRESULT ret;
1654
1655     TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_w(pszIn),
1656             pszOut, pcchOut, pcchOut ? *pcchOut : 0, dwFlags);
1657
1658     if (!pszIn || !pszOut || !pcchOut) return E_INVALIDARG;
1659
1660     if (dwFlags & URL_APPLY_GUESSFILE) {
1661         FIXME("(%s %p %p(%d) 0x%08x): stub URL_APPLY_GUESSFILE not implemented\n",
1662               debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwFlags);
1663         strcpyW(pszOut, pszIn);
1664         *pcchOut = strlenW(pszOut);
1665         return S_FALSE;
1666     }
1667
1668     in_scheme.cbSize = sizeof(in_scheme);
1669     /* See if the base has a scheme */
1670     res1 = ParseURLW(pszIn, &in_scheme);
1671     if (res1) {
1672         /* no scheme in input, need to see if we need to guess */
1673         if (dwFlags & URL_APPLY_GUESSSCHEME) {
1674             if ((ret = URL_GuessScheme(pszIn, pszOut, pcchOut)) != E_FAIL)
1675                 return ret;
1676         }
1677     }
1678     else {
1679         /* we have a scheme, see if valid (known scheme) */
1680         if (in_scheme.nScheme) {
1681             /* have valid scheme, so just copy and exit */
1682             if (strlenW(pszIn) + 1 > *pcchOut) {
1683                 *pcchOut = strlenW(pszIn) + 1;
1684                 return E_POINTER;
1685             }
1686             strcpyW(pszOut, pszIn);
1687             *pcchOut = strlenW(pszOut);
1688             TRACE("valid scheme, returning copy\n");
1689             return S_OK;
1690         }
1691     }
1692
1693     /* If we are here, then either invalid scheme,
1694      * or no scheme and can't/failed guess.
1695      */
1696     if ( ( ((res1 == 0) && (dwFlags & URL_APPLY_FORCEAPPLY)) ||
1697            ((res1 != 0)) ) &&
1698          (dwFlags & URL_APPLY_DEFAULT)) {
1699         /* find and apply default scheme */
1700         return URL_ApplyDefault(pszIn, pszOut, pcchOut);
1701     }
1702
1703     return S_FALSE;
1704 }
1705
1706 /*************************************************************************
1707  *      UrlIsA          [SHLWAPI.@]
1708  *
1709  * Determine if a Url is of a certain class.
1710  *
1711  * PARAMS
1712  *  pszUrl [I] Url to check
1713  *  Urlis  [I] URLIS_ constant from "shlwapi.h"
1714  *
1715  * RETURNS
1716  *  TRUE if pszUrl belongs to the class type in Urlis.
1717  *  FALSE Otherwise.
1718  */
1719 BOOL WINAPI UrlIsA(LPCSTR pszUrl, URLIS Urlis)
1720 {
1721     PARSEDURLA base;
1722     DWORD res1;
1723     LPCSTR last;
1724
1725     TRACE("(%s %d)\n", debugstr_a(pszUrl), Urlis);
1726
1727     if(!pszUrl)
1728         return FALSE;
1729
1730     switch (Urlis) {
1731
1732     case URLIS_OPAQUE:
1733         base.cbSize = sizeof(base);
1734         res1 = ParseURLA(pszUrl, &base);
1735         if (res1) return FALSE;  /* invalid scheme */
1736         switch (base.nScheme)
1737         {
1738         case URL_SCHEME_MAILTO:
1739         case URL_SCHEME_SHELL:
1740         case URL_SCHEME_JAVASCRIPT:
1741         case URL_SCHEME_VBSCRIPT:
1742         case URL_SCHEME_ABOUT:
1743             return TRUE;
1744         }
1745         return FALSE;
1746
1747     case URLIS_FILEURL:
1748         return !StrCmpNA("file:", pszUrl, 5);
1749
1750     case URLIS_DIRECTORY:
1751         last = pszUrl + strlen(pszUrl) - 1;
1752         return (last >= pszUrl && (*last == '/' || *last == '\\' ));
1753
1754     case URLIS_URL:
1755         return PathIsURLA(pszUrl);
1756
1757     case URLIS_NOHISTORY:
1758     case URLIS_APPLIABLE:
1759     case URLIS_HASQUERY:
1760     default:
1761         FIXME("(%s %d): stub\n", debugstr_a(pszUrl), Urlis);
1762     }
1763     return FALSE;
1764 }
1765
1766 /*************************************************************************
1767  *      UrlIsW          [SHLWAPI.@]
1768  *
1769  * See UrlIsA.
1770  */
1771 BOOL WINAPI UrlIsW(LPCWSTR pszUrl, URLIS Urlis)
1772 {
1773     static const WCHAR stemp[] = { 'f','i','l','e',':',0 };
1774     PARSEDURLW base;
1775     DWORD res1;
1776     LPCWSTR last;
1777
1778     TRACE("(%s %d)\n", debugstr_w(pszUrl), Urlis);
1779
1780     if(!pszUrl)
1781         return FALSE;
1782
1783     switch (Urlis) {
1784
1785     case URLIS_OPAQUE:
1786         base.cbSize = sizeof(base);
1787         res1 = ParseURLW(pszUrl, &base);
1788         if (res1) return FALSE;  /* invalid scheme */
1789         switch (base.nScheme)
1790         {
1791         case URL_SCHEME_MAILTO:
1792         case URL_SCHEME_SHELL:
1793         case URL_SCHEME_JAVASCRIPT:
1794         case URL_SCHEME_VBSCRIPT:
1795         case URL_SCHEME_ABOUT:
1796             return TRUE;
1797         }
1798         return FALSE;
1799
1800     case URLIS_FILEURL:
1801         return !strncmpW(stemp, pszUrl, 5);
1802
1803     case URLIS_DIRECTORY:
1804         last = pszUrl + strlenW(pszUrl) - 1;
1805         return (last >= pszUrl && (*last == '/' || *last == '\\'));
1806
1807     case URLIS_URL:
1808         return PathIsURLW(pszUrl);
1809
1810     case URLIS_NOHISTORY:
1811     case URLIS_APPLIABLE:
1812     case URLIS_HASQUERY:
1813     default:
1814         FIXME("(%s %d): stub\n", debugstr_w(pszUrl), Urlis);
1815     }
1816     return FALSE;
1817 }
1818
1819 /*************************************************************************
1820  *      UrlIsNoHistoryA         [SHLWAPI.@]
1821  *
1822  * Determine if a Url should not be stored in the users history list.
1823  *
1824  * PARAMS
1825  *  pszUrl [I] Url to check
1826  *
1827  * RETURNS
1828  *  TRUE, if pszUrl should be excluded from the history list,
1829  *  FALSE otherwise.
1830  */
1831 BOOL WINAPI UrlIsNoHistoryA(LPCSTR pszUrl)
1832 {
1833     return UrlIsA(pszUrl, URLIS_NOHISTORY);
1834 }
1835
1836 /*************************************************************************
1837  *      UrlIsNoHistoryW         [SHLWAPI.@]
1838  *
1839  * See UrlIsNoHistoryA.
1840  */
1841 BOOL WINAPI UrlIsNoHistoryW(LPCWSTR pszUrl)
1842 {
1843     return UrlIsW(pszUrl, URLIS_NOHISTORY);
1844 }
1845
1846 /*************************************************************************
1847  *      UrlIsOpaqueA    [SHLWAPI.@]
1848  *
1849  * Determine if a Url is opaque.
1850  *
1851  * PARAMS
1852  *  pszUrl [I] Url to check
1853  *
1854  * RETURNS
1855  *  TRUE if pszUrl is opaque,
1856  *  FALSE Otherwise.
1857  *
1858  * NOTES
1859  *  An opaque Url is one that does not start with "<protocol>://".
1860  */
1861 BOOL WINAPI UrlIsOpaqueA(LPCSTR pszUrl)
1862 {
1863     return UrlIsA(pszUrl, URLIS_OPAQUE);
1864 }
1865
1866 /*************************************************************************
1867  *      UrlIsOpaqueW    [SHLWAPI.@]
1868  *
1869  * See UrlIsOpaqueA.
1870  */
1871 BOOL WINAPI UrlIsOpaqueW(LPCWSTR pszUrl)
1872 {
1873     return UrlIsW(pszUrl, URLIS_OPAQUE);
1874 }
1875
1876 /*************************************************************************
1877  *  Scans for characters of type "type" and when not matching found,
1878  *  returns pointer to it and length in size.
1879  *
1880  * Characters tested based on RFC 1738
1881  */
1882 static LPCWSTR  URL_ScanID(LPCWSTR start, LPDWORD size, WINE_URL_SCAN_TYPE type)
1883 {
1884     static DWORD alwayszero = 0;
1885     BOOL cont = TRUE;
1886
1887     *size = 0;
1888
1889     switch(type){
1890
1891     case SCHEME:
1892         while (cont) {
1893             if ( (islowerW(*start) && isalphaW(*start)) ||
1894                  isdigitW(*start) ||
1895                  (*start == '+') ||
1896                  (*start == '-') ||
1897                  (*start == '.')) {
1898                 start++;
1899                 (*size)++;
1900             }
1901             else
1902                 cont = FALSE;
1903         }
1904         break;
1905
1906     case USERPASS:
1907         while (cont) {
1908             if ( isalphaW(*start) ||
1909                  isdigitW(*start) ||
1910                  /* user/password only characters */
1911                  (*start == ';') ||
1912                  (*start == '?') ||
1913                  (*start == '&') ||
1914                  (*start == '=') ||
1915                  /* *extra* characters */
1916                  (*start == '!') ||
1917                  (*start == '*') ||
1918                  (*start == '\'') ||
1919                  (*start == '(') ||
1920                  (*start == ')') ||
1921                  (*start == ',') ||
1922                  /* *safe* characters */
1923                  (*start == '$') ||
1924                  (*start == '_') ||
1925                  (*start == '+') ||
1926                  (*start == '-') ||
1927                  (*start == '.') ||
1928                  (*start == ' ')) {
1929                 start++;
1930                 (*size)++;
1931             } else if (*start == '%') {
1932                 if (isxdigitW(*(start+1)) &&
1933                     isxdigitW(*(start+2))) {
1934                     start += 3;
1935                     *size += 3;
1936                 } else
1937                     cont = FALSE;
1938             } else
1939                 cont = FALSE;
1940         }
1941         break;
1942
1943     case PORT:
1944         while (cont) {
1945             if (isdigitW(*start)) {
1946                 start++;
1947                 (*size)++;
1948             }
1949             else
1950                 cont = FALSE;
1951         }
1952         break;
1953
1954     case HOST:
1955         while (cont) {
1956             if (isalnumW(*start) ||
1957                 (*start == '-') ||
1958                 (*start == '.') ||
1959                 (*start == ' ') ) {
1960                 start++;
1961                 (*size)++;
1962             }
1963             else
1964                 cont = FALSE;
1965         }
1966         break;
1967     default:
1968         FIXME("unknown type %d\n", type);
1969         return (LPWSTR)&alwayszero;
1970     }
1971     /* TRACE("scanned %d characters next char %p<%c>\n",
1972      *size, start, *start); */
1973     return start;
1974 }
1975
1976 /*************************************************************************
1977  *  Attempt to parse URL into pieces.
1978  */
1979 static LONG URL_ParseUrl(LPCWSTR pszUrl, WINE_PARSE_URL *pl)
1980 {
1981     LPCWSTR work;
1982
1983     memset(pl, 0, sizeof(WINE_PARSE_URL));
1984     pl->pScheme = pszUrl;
1985     work = URL_ScanID(pl->pScheme, &pl->szScheme, SCHEME);
1986     if (!*work || (*work != ':')) goto ErrorExit;
1987     work++;
1988     if ((*work != '/') || (*(work+1) != '/')) goto SuccessExit;
1989     pl->pUserName = work + 2;
1990     work = URL_ScanID(pl->pUserName, &pl->szUserName, USERPASS);
1991     if (*work == ':' ) {
1992         /* parse password */
1993         work++;
1994         pl->pPassword = work;
1995         work = URL_ScanID(pl->pPassword, &pl->szPassword, USERPASS);
1996         if (*work != '@') {
1997             /* what we just parsed must be the hostname and port
1998              * so reset pointers and clear then let it parse */
1999             pl->szUserName = pl->szPassword = 0;
2000             work = pl->pUserName - 1;
2001             pl->pUserName = pl->pPassword = 0;
2002         }
2003     } else if (*work == '@') {
2004         /* no password */
2005         pl->szPassword = 0;
2006         pl->pPassword = 0;
2007     } else if (!*work || (*work == '/') || (*work == '.')) {
2008         /* what was parsed was hostname, so reset pointers and let it parse */
2009         pl->szUserName = pl->szPassword = 0;
2010         work = pl->pUserName - 1;
2011         pl->pUserName = pl->pPassword = 0;
2012     } else goto ErrorExit;
2013
2014     /* now start parsing hostname or hostnumber */
2015     work++;
2016     pl->pHostName = work;
2017     work = URL_ScanID(pl->pHostName, &pl->szHostName, HOST);
2018     if (*work == ':') {
2019         /* parse port */
2020         work++;
2021         pl->pPort = work;
2022         work = URL_ScanID(pl->pPort, &pl->szPort, PORT);
2023     }
2024     if (*work == '/') {
2025         /* see if query string */
2026         pl->pQuery = strchrW(work, '?');
2027         if (pl->pQuery) pl->szQuery = strlenW(pl->pQuery);
2028     }
2029   SuccessExit:
2030     TRACE("parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
2031           pl->pScheme, pl->szScheme,
2032           pl->pUserName, pl->szUserName,
2033           pl->pPassword, pl->szPassword,
2034           pl->pHostName, pl->szHostName,
2035           pl->pPort, pl->szPort,
2036           pl->pQuery, pl->szQuery);
2037     return S_OK;
2038   ErrorExit:
2039     FIXME("failed to parse %s\n", debugstr_w(pszUrl));
2040     return E_INVALIDARG;
2041 }
2042
2043 /*************************************************************************
2044  *      UrlGetPartA     [SHLWAPI.@]
2045  *
2046  * Retrieve part of a Url.
2047  *
2048  * PARAMS
2049  *  pszIn   [I]   Url to parse
2050  *  pszOut  [O]   Destination for part of pszIn requested
2051  *  pcchOut [I]   Size of pszOut
2052  *          [O]   length of pszOut string EXCLUDING '\0' if S_OK, otherwise
2053  *                needed size of pszOut INCLUDING '\0'.
2054  *  dwPart  [I]   URL_PART_ enum from "shlwapi.h"
2055  *  dwFlags [I]   URL_ flags from "shlwapi.h"
2056  *
2057  * RETURNS
2058  *  Success: S_OK. pszOut contains the part requested, pcchOut contains its length.
2059  *  Failure: An HRESULT error code describing the error.
2060  */
2061 HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut,
2062                            DWORD dwPart, DWORD dwFlags)
2063 {
2064     LPWSTR in, out;
2065     DWORD ret, len, len2;
2066
2067     if(!pszIn || !pszOut || !pcchOut || *pcchOut <= 0)
2068         return E_INVALIDARG;
2069
2070     in = HeapAlloc(GetProcessHeap(), 0,
2071                               (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
2072     out = in + INTERNET_MAX_URL_LENGTH;
2073
2074     MultiByteToWideChar(0, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
2075
2076     len = INTERNET_MAX_URL_LENGTH;
2077     ret = UrlGetPartW(in, out, &len, dwPart, dwFlags);
2078
2079     if (FAILED(ret)) {
2080         HeapFree(GetProcessHeap(), 0, in);
2081         return ret;
2082     }
2083
2084     len2 = WideCharToMultiByte(0, 0, out, len, 0, 0, 0, 0);
2085     if (len2 > *pcchOut) {
2086         *pcchOut = len2+1;
2087         HeapFree(GetProcessHeap(), 0, in);
2088         return E_POINTER;
2089     }
2090     len2 = WideCharToMultiByte(0, 0, out, len+1, pszOut, *pcchOut, 0, 0);
2091     *pcchOut = len2-1;
2092     HeapFree(GetProcessHeap(), 0, in);
2093     return ret;
2094 }
2095
2096 /*************************************************************************
2097  *      UrlGetPartW     [SHLWAPI.@]
2098  *
2099  * See UrlGetPartA.
2100  */
2101 HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut,
2102                            DWORD dwPart, DWORD dwFlags)
2103 {
2104     WINE_PARSE_URL pl;
2105     HRESULT ret;
2106     DWORD scheme, size, schsize;
2107     LPCWSTR addr, schaddr;
2108
2109     TRACE("(%s %p %p(%d) %08x %08x)\n",
2110           debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwPart, dwFlags);
2111
2112     if(!pszIn || !pszOut || !pcchOut || *pcchOut <= 0)
2113         return E_INVALIDARG;
2114
2115     *pszOut = '\0';
2116
2117     addr = strchrW(pszIn, ':');
2118     if(!addr)
2119         scheme = URL_SCHEME_UNKNOWN;
2120     else
2121         scheme = get_scheme_code(pszIn, addr-pszIn);
2122
2123     ret = URL_ParseUrl(pszIn, &pl);
2124
2125         switch (dwPart) {
2126         case URL_PART_SCHEME:
2127             if (!pl.szScheme || scheme == URL_SCHEME_UNKNOWN) {
2128                 *pcchOut = 0;
2129                 return S_FALSE;
2130             }
2131             addr = pl.pScheme;
2132             size = pl.szScheme;
2133             break;
2134
2135         case URL_PART_HOSTNAME:
2136             switch(scheme) {
2137             case URL_SCHEME_FTP:
2138             case URL_SCHEME_HTTP:
2139             case URL_SCHEME_GOPHER:
2140             case URL_SCHEME_TELNET:
2141             case URL_SCHEME_FILE:
2142             case URL_SCHEME_HTTPS:
2143                 break;
2144             default:
2145                 *pcchOut = 0;
2146                 return E_FAIL;
2147             }
2148
2149             if(scheme==URL_SCHEME_FILE && (!pl.szHostName ||
2150                         (pl.szHostName==1 && *(pl.pHostName+1)==':'))) {
2151                 *pcchOut = 0;
2152                 return S_FALSE;
2153             }
2154
2155             if (!pl.szHostName) {
2156                 *pcchOut = 0;
2157                 return S_FALSE;
2158             }
2159             addr = pl.pHostName;
2160             size = pl.szHostName;
2161             break;
2162
2163         case URL_PART_USERNAME:
2164             if (!pl.szUserName) {
2165                 *pcchOut = 0;
2166                 return S_FALSE;
2167             }
2168             addr = pl.pUserName;
2169             size = pl.szUserName;
2170             break;
2171
2172         case URL_PART_PASSWORD:
2173             if (!pl.szPassword) {
2174                 *pcchOut = 0;
2175                 return S_FALSE;
2176             }
2177             addr = pl.pPassword;
2178             size = pl.szPassword;
2179             break;
2180
2181         case URL_PART_PORT:
2182             if (!pl.szPort) {
2183                 *pcchOut = 0;
2184                 return S_FALSE;
2185             }
2186             addr = pl.pPort;
2187             size = pl.szPort;
2188             break;
2189
2190         case URL_PART_QUERY:
2191             if (!pl.szQuery) {
2192                 *pcchOut = 0;
2193                 return S_FALSE;
2194             }
2195             addr = pl.pQuery;
2196             size = pl.szQuery;
2197             break;
2198
2199         default:
2200             *pcchOut = 0;
2201             return E_INVALIDARG;
2202         }
2203
2204         if (dwFlags == URL_PARTFLAG_KEEPSCHEME) {
2205             if(!pl.pScheme || !pl.szScheme) {
2206                 *pcchOut = 0;
2207                 return E_FAIL;
2208             }
2209             schaddr = pl.pScheme;
2210             schsize = pl.szScheme;
2211             if (*pcchOut < schsize + size + 2) {
2212                 *pcchOut = schsize + size + 2;
2213                 return E_POINTER;
2214             }
2215             memcpy(pszOut, schaddr, schsize*sizeof(WCHAR));
2216             pszOut[schsize] = ':';
2217             memcpy(pszOut+schsize+1, addr, size*sizeof(WCHAR));
2218             pszOut[schsize+1+size] = 0;
2219             *pcchOut = schsize + 1 + size;
2220         }
2221         else {
2222             if (*pcchOut < size + 1) {*pcchOut = size+1; return E_POINTER;}
2223             memcpy(pszOut, addr, size*sizeof(WCHAR));
2224             pszOut[size] = 0;
2225             *pcchOut = size;
2226         }
2227         TRACE("len=%d %s\n", *pcchOut, debugstr_w(pszOut));
2228
2229     return ret;
2230 }
2231
2232 /*************************************************************************
2233  * PathIsURLA   [SHLWAPI.@]
2234  *
2235  * Check if the given path is a Url.
2236  *
2237  * PARAMS
2238  *  lpszPath [I] Path to check.
2239  *
2240  * RETURNS
2241  *  TRUE  if lpszPath is a Url.
2242  *  FALSE if lpszPath is NULL or not a Url.
2243  */
2244 BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
2245 {
2246     PARSEDURLA base;
2247     HRESULT hres;
2248
2249     TRACE("%s\n", debugstr_a(lpstrPath));
2250
2251     if (!lpstrPath || !*lpstrPath) return FALSE;
2252
2253     /* get protocol        */
2254     base.cbSize = sizeof(base);
2255     hres = ParseURLA(lpstrPath, &base);
2256     return hres == S_OK && (base.nScheme != URL_SCHEME_INVALID);
2257 }
2258
2259 /*************************************************************************
2260  * PathIsURLW   [SHLWAPI.@]
2261  *
2262  * See PathIsURLA.
2263  */
2264 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
2265 {
2266     PARSEDURLW base;
2267     HRESULT hres;
2268
2269     TRACE("%s\n", debugstr_w(lpstrPath));
2270
2271     if (!lpstrPath || !*lpstrPath) return FALSE;
2272
2273     /* get protocol        */
2274     base.cbSize = sizeof(base);
2275     hres = ParseURLW(lpstrPath, &base);
2276     return hres == S_OK && (base.nScheme != URL_SCHEME_INVALID);
2277 }
2278
2279 /*************************************************************************
2280  *      UrlCreateFromPathA      [SHLWAPI.@]
2281  *
2282  * See UrlCreateFromPathW
2283  */
2284 HRESULT WINAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2285 {
2286     WCHAR bufW[INTERNET_MAX_URL_LENGTH];
2287     WCHAR *urlW = bufW;
2288     UNICODE_STRING pathW;
2289     HRESULT ret;
2290     DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
2291
2292     if(!RtlCreateUnicodeStringFromAsciiz(&pathW, pszPath))
2293         return E_INVALIDARG;
2294     if((ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved)) == E_POINTER) {
2295         urlW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
2296         ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved);
2297     }
2298     if(ret == S_OK || ret == S_FALSE) {
2299         RtlUnicodeToMultiByteSize(&lenA, urlW, lenW * sizeof(WCHAR));
2300         if(*pcchUrl > lenA) {
2301             RtlUnicodeToMultiByteN(pszUrl, *pcchUrl - 1, &lenA, urlW, lenW * sizeof(WCHAR));
2302             pszUrl[lenA] = 0;
2303             *pcchUrl = lenA;
2304         } else {
2305             *pcchUrl = lenA + 1;
2306             ret = E_POINTER;
2307         }
2308     }
2309     if(urlW != bufW) HeapFree(GetProcessHeap(), 0, urlW);
2310     RtlFreeUnicodeString(&pathW);
2311     return ret;
2312 }
2313
2314 /*************************************************************************
2315  *      UrlCreateFromPathW      [SHLWAPI.@]
2316  *
2317  * Create a Url from a file path.
2318  *
2319  * PARAMS
2320  *  pszPath [I]    Path to convert
2321  *  pszUrl  [O]    Destination for the converted Url
2322  *  pcchUrl [I/O]  Length of pszUrl
2323  *  dwReserved [I] Reserved, must be 0
2324  *
2325  * RETURNS
2326  *  Success: S_OK pszUrl contains the converted path, S_FALSE if the path is already a Url
2327  *  Failure: An HRESULT error code.
2328  */
2329 HRESULT WINAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2330 {
2331     DWORD needed;
2332     HRESULT ret;
2333     WCHAR *pszNewUrl;
2334     WCHAR file_colonW[] = {'f','i','l','e',':',0};
2335     WCHAR three_slashesW[] = {'/','/','/',0};
2336     PARSEDURLW parsed_url;
2337
2338     TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszPath), pszUrl, pcchUrl, dwReserved);
2339
2340     /* Validate arguments */
2341     if (dwReserved != 0)
2342         return E_INVALIDARG;
2343     if (!pszUrl || !pcchUrl)
2344         return E_INVALIDARG;
2345
2346
2347     parsed_url.cbSize = sizeof(parsed_url);
2348     if(ParseURLW(pszPath, &parsed_url) == S_OK) {
2349         if(parsed_url.nScheme != URL_SCHEME_INVALID && parsed_url.cchProtocol > 1) {
2350             needed = strlenW(pszPath);
2351             if (needed >= *pcchUrl) {
2352                 *pcchUrl = needed + 1;
2353                 return E_POINTER;
2354             } else {
2355                 *pcchUrl = needed;
2356                 strcpyW(pszUrl, pszPath);
2357                 return S_FALSE;
2358             }
2359         }
2360     }
2361
2362     pszNewUrl = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath) + 9) * sizeof(WCHAR)); /* "file:///" + pszPath_len + 1 */
2363     strcpyW(pszNewUrl, file_colonW);
2364     if(isalphaW(pszPath[0]) && pszPath[1] == ':')
2365         strcatW(pszNewUrl, three_slashesW);
2366     strcatW(pszNewUrl, pszPath);
2367     ret = UrlEscapeW(pszNewUrl, pszUrl, pcchUrl, URL_ESCAPE_PERCENT);
2368
2369     HeapFree(GetProcessHeap(), 0, pszNewUrl);
2370     return ret;
2371 }
2372
2373 /*************************************************************************
2374  *      SHAutoComplete          [SHLWAPI.@]
2375  *
2376  * Enable auto-completion for an edit control.
2377  *
2378  * PARAMS
2379  *  hwndEdit [I] Handle of control to enable auto-completion for
2380  *  dwFlags  [I] SHACF_ flags from "shlwapi.h"
2381  *
2382  * RETURNS
2383  *  Success: S_OK. Auto-completion is enabled for the control.
2384  *  Failure: An HRESULT error code indicating the error.
2385  */
2386 HRESULT WINAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags)
2387 {
2388   FIXME("stub\n");
2389   return S_FALSE;
2390 }
2391
2392 /*************************************************************************
2393  *  MLBuildResURLA      [SHLWAPI.405]
2394  *
2395  * Create a Url pointing to a resource in a module.
2396  *
2397  * PARAMS
2398  *  lpszLibName [I] Name of the module containing the resource
2399  *  hMod        [I] Callers module handle
2400  *  dwFlags     [I] Undocumented flags for loading the module
2401  *  lpszRes     [I] Resource name
2402  *  lpszDest    [O] Destination for resulting Url
2403  *  dwDestLen   [I] Length of lpszDest
2404  *
2405  * RETURNS
2406  *  Success: S_OK. lpszDest contains the resource Url.
2407  *  Failure: E_INVALIDARG, if any argument is invalid, or
2408  *           E_FAIL if dwDestLen is too small.
2409  */
2410 HRESULT WINAPI MLBuildResURLA(LPCSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2411                               LPCSTR lpszRes, LPSTR lpszDest, DWORD dwDestLen)
2412 {
2413   WCHAR szLibName[MAX_PATH], szRes[MAX_PATH], szDest[MAX_PATH];
2414   HRESULT hRet;
2415
2416   if (lpszLibName)
2417     MultiByteToWideChar(CP_ACP, 0, lpszLibName, -1, szLibName, sizeof(szLibName)/sizeof(WCHAR));
2418
2419   if (lpszRes)
2420     MultiByteToWideChar(CP_ACP, 0, lpszRes, -1, szRes, sizeof(szRes)/sizeof(WCHAR));
2421
2422   if (dwDestLen > sizeof(szLibName)/sizeof(WCHAR))
2423     dwDestLen = sizeof(szLibName)/sizeof(WCHAR);
2424
2425   hRet = MLBuildResURLW(lpszLibName ? szLibName : NULL, hMod, dwFlags,
2426                         lpszRes ? szRes : NULL, lpszDest ? szDest : NULL, dwDestLen);
2427   if (SUCCEEDED(hRet) && lpszDest)
2428     WideCharToMultiByte(CP_ACP, 0, szDest, -1, lpszDest, dwDestLen, 0, 0);
2429
2430   return hRet;
2431 }
2432
2433 /*************************************************************************
2434  *  MLBuildResURLA      [SHLWAPI.406]
2435  *
2436  * See MLBuildResURLA.
2437  */
2438 HRESULT WINAPI MLBuildResURLW(LPCWSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2439                               LPCWSTR lpszRes, LPWSTR lpszDest, DWORD dwDestLen)
2440 {
2441   static const WCHAR szRes[] = { 'r','e','s',':','/','/','\0' };
2442 #define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR))
2443   HRESULT hRet = E_FAIL;
2444
2445   TRACE("(%s,%p,0x%08x,%s,%p,%d)\n", debugstr_w(lpszLibName), hMod, dwFlags,
2446         debugstr_w(lpszRes), lpszDest, dwDestLen);
2447
2448   if (!lpszLibName || !hMod || hMod == INVALID_HANDLE_VALUE || !lpszRes ||
2449       !lpszDest || (dwFlags && dwFlags != 2))
2450     return E_INVALIDARG;
2451
2452   if (dwDestLen >= szResLen + 1)
2453   {
2454     dwDestLen -= (szResLen + 1);
2455     memcpy(lpszDest, szRes, sizeof(szRes));
2456
2457     hMod = MLLoadLibraryW(lpszLibName, hMod, dwFlags);
2458
2459     if (hMod)
2460     {
2461       WCHAR szBuff[MAX_PATH];
2462       DWORD len;
2463
2464       len = GetModuleFileNameW(hMod, szBuff, sizeof(szBuff)/sizeof(WCHAR));
2465       if (len && len < sizeof(szBuff)/sizeof(WCHAR))
2466       {
2467         DWORD dwPathLen = strlenW(szBuff) + 1;
2468
2469         if (dwDestLen >= dwPathLen)
2470         {
2471           DWORD dwResLen;
2472
2473           dwDestLen -= dwPathLen;
2474           memcpy(lpszDest + szResLen, szBuff, dwPathLen * sizeof(WCHAR));
2475
2476           dwResLen = strlenW(lpszRes) + 1;
2477           if (dwDestLen >= dwResLen + 1)
2478           {
2479             lpszDest[szResLen + dwPathLen-1] = '/';
2480             memcpy(lpszDest + szResLen + dwPathLen, lpszRes, dwResLen * sizeof(WCHAR));
2481             hRet = S_OK;
2482           }
2483         }
2484       }
2485       MLFreeLibrary(hMod);
2486     }
2487   }
2488   return hRet;
2489 }
2490
2491 /***********************************************************************
2492  *             UrlFixupW [SHLWAPI.462]
2493  *
2494  * Checks the scheme part of a URL and attempts to correct misspellings.
2495  *
2496  * PARAMS
2497  *  lpszUrl           [I] Pointer to the URL to be corrected
2498  *  lpszTranslatedUrl [O] Pointer to a buffer to store corrected URL
2499  *  dwMaxChars        [I] Maximum size of corrected URL
2500  *
2501  * RETURNS
2502  *  success: S_OK if URL corrected or already correct
2503  *  failure: S_FALSE if unable to correct / COM error code if other error
2504  *
2505  */
2506 HRESULT WINAPI UrlFixupW(LPCWSTR url, LPWSTR translatedUrl, DWORD maxChars)
2507 {
2508     DWORD srcLen;
2509
2510     FIXME("(%s,%p,%d) STUB\n", debugstr_w(url), translatedUrl, maxChars);
2511
2512     if (!url)
2513         return E_FAIL;
2514
2515     srcLen = lstrlenW(url) + 1;
2516
2517     /* For now just copy the URL directly */
2518     lstrcpynW(translatedUrl, url, (maxChars < srcLen) ? maxChars : srcLen);
2519
2520     return S_OK;
2521 }