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