4 * Copyright 2000 Huw D M Davies for CodeWeavers.
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.
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.
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
22 #include "wine/port.h"
30 #include "wine/unicode.h"
34 #define NO_SHLWAPI_STREAM
36 #include "wine/debug.h"
38 HMODULE WINAPI MLLoadLibraryW(LPCWSTR,HMODULE,DWORD);
39 BOOL WINAPI MLFreeLibrary(HMODULE);
40 HRESULT WINAPI MLBuildResURLW(LPCWSTR,HMODULE,DWORD,LPCWSTR,LPWSTR,DWORD);
42 WINE_DEFAULT_DEBUG_CHANNEL(shell);
44 /* The following schemes were identified in the native version of
45 * SHLWAPI.DLL version 5.50
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}},
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) */
93 static const CHAR hexDigits[] = "0123456789ABCDEF";
95 static const WCHAR fileW[] = {'f','i','l','e','\0'};
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 };
119 static DWORD get_scheme_code(LPCWSTR scheme, DWORD scheme_len)
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;
129 return URL_SCHEME_UNKNOWN;
132 static BOOL URL_JustLocation(LPCWSTR str)
134 while(*str && (*str == '/')) str++;
136 while (*str && ((*str == '-') ||
138 isalnumW(*str))) str++;
139 if (*str == '/') return FALSE;
145 /*************************************************************************
148 * Parse a Url into its constituent parts.
152 * y [O] Undocumented structure holding the parsed information
155 * Success: S_OK. y contains the parsed Url details.
156 * Failure: An HRESULT error code.
158 HRESULT WINAPI ParseURLA(LPCSTR x, PARSEDURLA *y)
160 WCHAR scheme[INTERNET_MAX_SCHEME_LENGTH];
163 y->nScheme = URL_SCHEME_INVALID;
164 if (y->cbSize != sizeof(*y)) return E_INVALIDARG;
165 /* FIXME: leading white space generates error of 0x80041001 which
168 if (*x <= ' ') return 0x80041001;
174 y->cchProtocol = cnt;
183 /* check for no scheme in string start */
184 /* (apparently schemes *must* be larger than a single character) */
185 if ((*x == '\0') || (y->cchProtocol <= 1)) {
186 y->pszProtocol = NULL;
190 /* found scheme, set length of remainder */
191 y->cchSuffix = lstrlenA(y->pszSuffix);
193 len = MultiByteToWideChar(CP_ACP, 0, y->pszProtocol, y->cchProtocol,
194 scheme, sizeof(scheme)/sizeof(WCHAR));
195 y->nScheme = get_scheme_code(scheme, len);
200 /*************************************************************************
203 * Unicode version of ParseURLA.
205 HRESULT WINAPI ParseURLW(LPCWSTR x, PARSEDURLW *y)
209 y->nScheme = URL_SCHEME_INVALID;
210 if (y->cbSize != sizeof(*y)) return E_INVALIDARG;
211 /* FIXME: leading white space generates error of 0x80041001 which
214 if (*x <= ' ') return 0x80041001;
220 y->cchProtocol = cnt;
229 /* check for no scheme in string start */
230 /* (apparently schemes *must* be larger than a single character) */
231 if ((*x == '\0') || (y->cchProtocol <= 1)) {
232 y->pszProtocol = NULL;
236 /* found scheme, set length of remainder */
237 y->cchSuffix = lstrlenW(y->pszSuffix);
238 y->nScheme = get_scheme_code(y->pszProtocol, y->cchProtocol);
243 /*************************************************************************
244 * UrlCanonicalizeA [SHLWAPI.@]
246 * Canonicalize a Url.
249 * pszUrl [I] Url to cCanonicalize
250 * pszCanonicalized [O] Destination for converted Url.
251 * pcchCanonicalized [I/O] Length of pszUrl, destination for length of pszCanonicalized
252 * dwFlags [I] Flags controlling the conversion.
255 * Success: S_OK. The pszCanonicalized contains the converted Url.
256 * Failure: E_POINTER, if *pcchCanonicalized is too small.
258 * MSDN incorrectly describes the flags for this function. They should be:
259 *| URL_DONT_ESCAPE_EXTRA_INFO 0x02000000
260 *| URL_ESCAPE_SPACES_ONLY 0x04000000
261 *| URL_ESCAPE_PERCENT 0x00001000
262 *| URL_ESCAPE_UNSAFE 0x10000000
263 *| URL_UNESCAPE 0x10000000
264 *| URL_DONT_SIMPLIFY 0x08000000
265 *| URL_ESCAPE_SEGMENT_ONLY 0x00002000
267 HRESULT WINAPI UrlCanonicalizeA(LPCSTR pszUrl, LPSTR pszCanonicalized,
268 LPDWORD pcchCanonicalized, DWORD dwFlags)
270 LPWSTR base, canonical;
274 TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_a(pszUrl), pszCanonicalized,
275 pcchCanonicalized, dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
277 if(!pszUrl || !pszCanonicalized || !pcchCanonicalized)
280 base = HeapAlloc(GetProcessHeap(), 0,
281 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
282 canonical = base + INTERNET_MAX_URL_LENGTH;
284 MultiByteToWideChar(0, 0, pszUrl, -1, base, INTERNET_MAX_URL_LENGTH);
285 len = INTERNET_MAX_URL_LENGTH;
287 ret = UrlCanonicalizeW(base, canonical, &len, dwFlags);
289 *pcchCanonicalized = len * 2;
290 HeapFree(GetProcessHeap(), 0, base);
294 len2 = WideCharToMultiByte(0, 0, canonical, -1, 0, 0, 0, 0);
295 if (len2 > *pcchCanonicalized) {
296 *pcchCanonicalized = len2;
297 HeapFree(GetProcessHeap(), 0, base);
300 WideCharToMultiByte(0, 0, canonical, -1, pszCanonicalized, *pcchCanonicalized, 0, 0);
301 *pcchCanonicalized = len;
302 HeapFree(GetProcessHeap(), 0, base);
306 /*************************************************************************
307 * UrlCanonicalizeW [SHLWAPI.@]
309 * See UrlCanonicalizeA.
311 HRESULT WINAPI UrlCanonicalizeW(LPCWSTR pszUrl, LPWSTR pszCanonicalized,
312 LPDWORD pcchCanonicalized, DWORD dwFlags)
316 LPWSTR lpszUrlCpy, wk1, wk2, mp, mp2, root;
321 static const WCHAR wszFile[] = {'f','i','l','e',':'};
322 static const WCHAR wszLocalhost[] = {'l','o','c','a','l','h','o','s','t'};
324 TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_w(pszUrl), pszCanonicalized,
325 pcchCanonicalized, dwFlags, pcchCanonicalized ? *pcchCanonicalized : -1);
327 if(!pszUrl || !pszCanonicalized || !pcchCanonicalized)
331 *pszCanonicalized = 0;
335 nByteLen = (lstrlenW(pszUrl) + 1) * sizeof(WCHAR); /* length in bytes */
336 lpszUrlCpy = HeapAlloc(GetProcessHeap(), 0,
337 INTERNET_MAX_URL_LENGTH * sizeof(WCHAR));
339 if((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszFile)
340 && !memcmp(wszFile, pszUrl, sizeof(wszFile)))
346 * 1 have 2[+] alnum 2,3
347 * 2 have scheme (found :) 4,6,3
348 * 3 failed (no location)
350 * 5 have 1[+] alnum 6,3
351 * 6 have location (found /) save root location
354 wk1 = (LPWSTR)pszUrl;
358 if(pszUrl[1] == ':') { /* Assume path */
359 static const WCHAR wszFilePrefix[] = {'f','i','l','e',':','/','/','/'};
361 memcpy(wk2, wszFilePrefix, sizeof(wszFilePrefix));
362 wk2 += sizeof(wszFilePrefix)/sizeof(WCHAR);
363 if (dwFlags & URL_FILE_USE_PATHURL)
369 dwFlags |= URL_ESCAPE_UNSAFE;
376 if (!isalnumW(*wk1)) {state = 3; break;}
378 if (!isalnumW(*wk1)) {state = 3; break;}
384 if (*wk1++ == ':') state = 2;
388 if (*wk1 != '/') {state = 6; break;}
390 if((dwFlags & URL_FILE_USE_PATHURL) && nByteLen >= sizeof(wszLocalhost)
391 && !memcmp(wszLocalhost, wk1, sizeof(wszLocalhost))){
392 wk1 += sizeof(wszLocalhost)/sizeof(WCHAR);
393 while(*wk1 == '\\' && (dwFlags & URL_FILE_USE_PATHURL))
396 if(*wk1 == '/' && (dwFlags & URL_FILE_USE_PATHURL))
401 nWkLen = strlenW(wk1);
402 memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
408 if(*mp == '/' || *mp == '\\')
414 if (!isalnumW(*wk1) && (*wk1 != '-') && (*wk1 != '.') && (*wk1 != ':'))
416 while(isalnumW(*wk1) || (*wk1 == '-') || (*wk1 == '.') || (*wk1 == ':'))
423 if (*wk1 != '/' && *wk1 != '\\') {state = 3; break;}
424 while(*wk1 == '/' || *wk1 == '\\') {
431 if(dwFlags & URL_DONT_SIMPLIFY) {
436 /* Now at root location, cannot back up any more. */
437 /* "root" will point at the '/' */
441 mp = strchrW(wk1, '/');
442 mp2 = strchrW(wk1, '\\');
443 if(mp2 && (!mp || mp2 < mp))
446 nWkLen = strlenW(wk1);
447 memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
454 memcpy(wk2, wk1, nLen * sizeof(WCHAR));
462 TRACE("found '/.'\n");
463 if (wk1[1] == '/' || wk1[1] == '\\') {
464 /* case of /./ -> skip the ./ */
467 else if (wk1[1] == '.') {
468 /* found /.. look for next / */
469 TRACE("found '/..'\n");
470 if (wk1[2] == '/' || wk1[2] == '\\' ||wk1[2] == '?'
471 || wk1[2] == '#' || !wk1[2]) {
472 /* case /../ -> need to backup wk2 */
473 TRACE("found '/../'\n");
474 *(wk2-1) = '\0'; /* set end of string */
475 mp = strrchrW(root, slash);
476 if (mp && (mp >= root)) {
477 /* found valid backup point */
479 if(wk1[2] != '/' && wk1[2] != '\\')
485 /* did not find point, restore '/' */
495 FIXME("how did we get here - state=%d\n", state);
496 HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
500 TRACE("Simplified, orig <%s>, simple <%s>\n",
501 debugstr_w(pszUrl), debugstr_w(lpszUrlCpy));
503 nLen = lstrlenW(lpszUrlCpy);
504 while ((nLen > 0) && ((lpszUrlCpy[nLen-1] <= ' ')))
505 lpszUrlCpy[--nLen]=0;
507 if(dwFlags & (URL_UNESCAPE | URL_FILE_USE_PATHURL))
508 UrlUnescapeW(lpszUrlCpy, NULL, &nLen, URL_UNESCAPE_INPLACE);
510 if((EscapeFlags = dwFlags & (URL_ESCAPE_UNSAFE |
511 URL_ESCAPE_SPACES_ONLY |
513 URL_DONT_ESCAPE_EXTRA_INFO |
514 URL_ESCAPE_SEGMENT_ONLY ))) {
515 EscapeFlags &= ~URL_ESCAPE_UNSAFE;
516 hr = UrlEscapeW(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
518 } else { /* No escaping needed, just copy the string */
519 nLen = lstrlenW(lpszUrlCpy);
520 if(nLen < *pcchCanonicalized)
521 memcpy(pszCanonicalized, lpszUrlCpy, (nLen + 1)*sizeof(WCHAR));
526 *pcchCanonicalized = nLen;
529 HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
532 TRACE("result %s\n", debugstr_w(pszCanonicalized));
537 /*************************************************************************
538 * UrlCombineA [SHLWAPI.@]
543 * pszBase [I] Base Url
544 * pszRelative [I] Url to combine with pszBase
545 * pszCombined [O] Destination for combined Url
546 * pcchCombined [O] Destination for length of pszCombined
547 * dwFlags [I] URL_ flags from "shlwapi.h"
550 * Success: S_OK. pszCombined contains the combined Url, pcchCombined
551 * contains its length.
552 * Failure: An HRESULT error code indicating the error.
554 HRESULT WINAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative,
555 LPSTR pszCombined, LPDWORD pcchCombined,
558 LPWSTR base, relative, combined;
559 DWORD ret, len, len2;
561 TRACE("(base %s, Relative %s, Combine size %d, flags %08x) using W version\n",
562 debugstr_a(pszBase),debugstr_a(pszRelative),
563 pcchCombined?*pcchCombined:0,dwFlags);
565 if(!pszBase || !pszRelative || !pcchCombined)
568 base = HeapAlloc(GetProcessHeap(), 0,
569 (3*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
570 relative = base + INTERNET_MAX_URL_LENGTH;
571 combined = relative + INTERNET_MAX_URL_LENGTH;
573 MultiByteToWideChar(0, 0, pszBase, -1, base, INTERNET_MAX_URL_LENGTH);
574 MultiByteToWideChar(0, 0, pszRelative, -1, relative, INTERNET_MAX_URL_LENGTH);
577 ret = UrlCombineW(base, relative, pszCombined?combined:NULL, &len, dwFlags);
580 HeapFree(GetProcessHeap(), 0, base);
584 len2 = WideCharToMultiByte(0, 0, combined, len, 0, 0, 0, 0);
585 if (len2 > *pcchCombined) {
586 *pcchCombined = len2;
587 HeapFree(GetProcessHeap(), 0, base);
590 WideCharToMultiByte(0, 0, combined, len+1, pszCombined, (*pcchCombined)+1,
592 *pcchCombined = len2;
593 HeapFree(GetProcessHeap(), 0, base);
597 /*************************************************************************
598 * UrlCombineW [SHLWAPI.@]
602 HRESULT WINAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative,
603 LPWSTR pszCombined, LPDWORD pcchCombined,
606 PARSEDURLW base, relative;
607 DWORD myflags, sizeloc = 0;
608 DWORD len, res1, res2, process_case = 0;
609 LPWSTR work, preliminary, mbase, mrelative;
610 static const WCHAR myfilestr[] = {'f','i','l','e',':','/','/','/','\0'};
611 static const WCHAR single_slash[] = {'/','\0'};
614 TRACE("(base %s, Relative %s, Combine size %d, flags %08x)\n",
615 debugstr_w(pszBase),debugstr_w(pszRelative),
616 pcchCombined?*pcchCombined:0,dwFlags);
618 if(!pszBase || !pszRelative || !pcchCombined)
621 base.cbSize = sizeof(base);
622 relative.cbSize = sizeof(relative);
624 /* Get space for duplicates of the input and the output */
625 preliminary = HeapAlloc(GetProcessHeap(), 0, (3*INTERNET_MAX_URL_LENGTH) *
627 mbase = preliminary + INTERNET_MAX_URL_LENGTH;
628 mrelative = mbase + INTERNET_MAX_URL_LENGTH;
631 /* Canonicalize the base input prior to looking for the scheme */
632 myflags = dwFlags & (URL_DONT_SIMPLIFY | URL_UNESCAPE);
633 len = INTERNET_MAX_URL_LENGTH;
634 ret = UrlCanonicalizeW(pszBase, mbase, &len, myflags);
636 /* Canonicalize the relative input prior to looking for the scheme */
637 len = INTERNET_MAX_URL_LENGTH;
638 ret = UrlCanonicalizeW(pszRelative, mrelative, &len, myflags);
640 /* See if the base has a scheme */
641 res1 = ParseURLW(mbase, &base);
643 /* if pszBase has no scheme, then return pszRelative */
644 TRACE("no scheme detected in Base\n");
648 /* mk is a special case */
649 if(base.nScheme == URL_SCHEME_MK) {
650 static const WCHAR wsz[] = {':',':',0};
652 WCHAR *ptr = strstrW(base.pszSuffix, wsz);
657 delta = ptr-base.pszSuffix;
658 base.cchProtocol += delta;
659 base.pszSuffix += delta;
660 base.cchSuffix -= delta;
663 /* get size of location field (if it exists) */
664 work = (LPWSTR)base.pszSuffix;
666 if (*work++ == '/') {
667 if (*work++ == '/') {
668 /* At this point have start of location and
669 * it ends at next '/' or end of string.
671 while(*work && (*work != '/')) work++;
672 sizeloc = (DWORD)(work - base.pszSuffix);
677 /* Change .sizep2 to not have the last leaf in it,
678 * Note: we need to start after the location (if it exists)
680 work = strrchrW((base.pszSuffix+sizeloc), '/');
682 len = (DWORD)(work - base.pszSuffix + 1);
683 base.cchSuffix = len;
688 * .pszSuffix points to location (starting with '//')
689 * .cchSuffix length of location (above) and rest less the last
691 * sizeloc length of location (above) up to but not including
695 res2 = ParseURLW(mrelative, &relative);
697 /* no scheme in pszRelative */
698 TRACE("no scheme detected in Relative\n");
699 relative.pszSuffix = mrelative; /* case 3,4,5 depends on this */
700 relative.cchSuffix = strlenW(mrelative);
701 if (*pszRelative == ':') {
702 /* case that is either left alone or uses pszBase */
703 if (dwFlags & URL_PLUGGABLE_PROTOCOL) {
710 if (isalnum(*mrelative) && (*(mrelative + 1) == ':')) {
711 /* case that becomes "file:///" */
712 strcpyW(preliminary, myfilestr);
716 if ((*mrelative == '/') && (*(mrelative+1) == '/')) {
717 /* pszRelative has location and rest */
721 if (*mrelative == '/') {
722 /* case where pszRelative is root to location */
726 process_case = (*base.pszSuffix == '/' || base.nScheme == URL_SCHEME_MK) ? 5 : 3;
730 /* handle cases where pszRelative has scheme */
731 if ((base.cchProtocol == relative.cchProtocol) &&
732 (strncmpW(base.pszProtocol, relative.pszProtocol, base.cchProtocol) == 0)) {
734 /* since the schemes are the same */
735 if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
736 /* case where pszRelative replaces location and following */
740 if (*relative.pszSuffix == '/') {
741 /* case where pszRelative is root to location */
745 /* replace either just location if base's location starts with a
746 * slash or otherwise everything */
747 process_case = (*base.pszSuffix == '/') ? 5 : 1;
750 if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
751 /* case where pszRelative replaces scheme, location,
752 * and following and handles PLUGGABLE
759 } while(FALSE); /* a little trick to allow easy exit from nested if's */
762 switch (process_case) {
765 * Return pszRelative appended to what ever is in pszCombined,
766 * (which may the string "file:///"
768 strcatW(preliminary, mrelative);
772 * Same as case 1, but if URL_PLUGGABLE_PROTOCOL was specified
773 * and pszRelative starts with "//", then append a "/"
775 strcpyW(preliminary, mrelative);
776 if (!(dwFlags & URL_PLUGGABLE_PROTOCOL) &&
777 URL_JustLocation(relative.pszSuffix))
778 strcatW(preliminary, single_slash);
782 * Return the pszBase scheme with pszRelative. Basically
783 * keeps the scheme and replaces the domain and following.
785 memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1)*sizeof(WCHAR));
786 work = preliminary + base.cchProtocol + 1;
787 strcpyW(work, relative.pszSuffix);
791 * Return the pszBase scheme and location but everything
792 * after the location is pszRelative. (Replace document
795 memcpy(preliminary, base.pszProtocol, (base.cchProtocol+1+sizeloc)*sizeof(WCHAR));
796 work = preliminary + base.cchProtocol + 1 + sizeloc;
797 if (dwFlags & URL_PLUGGABLE_PROTOCOL)
799 strcpyW(work, relative.pszSuffix);
803 * Return the pszBase without its document (if any) and
804 * append pszRelative after its scheme.
806 memcpy(preliminary, base.pszProtocol,
807 (base.cchProtocol+1+base.cchSuffix)*sizeof(WCHAR));
808 work = preliminary + base.cchProtocol+1+base.cchSuffix - 1;
811 strcpyW(work, relative.pszSuffix);
815 FIXME("How did we get here????? process_case=%d\n", process_case);
820 /* Reuse mrelative as temp storage as its already allocated and not needed anymore */
821 ret = UrlCanonicalizeW(preliminary, mrelative, pcchCombined, (dwFlags & ~URL_FILE_USE_PATHURL));
822 if(SUCCEEDED(ret) && pszCombined) {
823 lstrcpyW(pszCombined, mrelative);
825 TRACE("return-%d len=%d, %s\n",
826 process_case, *pcchCombined, debugstr_w(pszCombined));
828 HeapFree(GetProcessHeap(), 0, preliminary);
832 /*************************************************************************
833 * UrlEscapeA [SHLWAPI.@]
836 HRESULT WINAPI UrlEscapeA(
842 WCHAR bufW[INTERNET_MAX_URL_LENGTH];
843 WCHAR *escapedW = bufW;
846 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
848 if (!pszEscaped || !pcchEscaped || !*pcchEscaped)
851 if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
853 if((ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags)) == E_POINTER) {
854 escapedW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
855 ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags);
858 RtlUnicodeToMultiByteSize(&lenA, escapedW, lenW * sizeof(WCHAR));
859 if(*pcchEscaped > lenA) {
860 RtlUnicodeToMultiByteN(pszEscaped, *pcchEscaped - 1, &lenA, escapedW, lenW * sizeof(WCHAR));
861 pszEscaped[lenA] = 0;
864 *pcchEscaped = lenA + 1;
868 if(escapedW != bufW) HeapFree(GetProcessHeap(), 0, escapedW);
869 RtlFreeUnicodeString(&urlW);
873 #define WINE_URL_BASH_AS_SLASH 0x01
874 #define WINE_URL_COLLAPSE_SLASHES 0x02
875 #define WINE_URL_ESCAPE_SLASH 0x04
876 #define WINE_URL_ESCAPE_HASH 0x08
877 #define WINE_URL_ESCAPE_QUESTION 0x10
878 #define WINE_URL_STOP_ON_HASH 0x20
879 #define WINE_URL_STOP_ON_QUESTION 0x40
881 static inline BOOL URL_NeedEscapeW(WCHAR ch, DWORD dwFlags, DWORD int_flags)
887 if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
894 if ((dwFlags & URL_ESCAPE_PERCENT) && (ch == '%'))
897 if (ch <= 31 || ch >= 127)
918 if (int_flags & WINE_URL_ESCAPE_SLASH) return TRUE;
922 if (int_flags & WINE_URL_ESCAPE_QUESTION) return TRUE;
926 if (int_flags & WINE_URL_ESCAPE_HASH) return TRUE;
936 /*************************************************************************
937 * UrlEscapeW [SHLWAPI.@]
939 * Converts unsafe characters in a Url into escape sequences.
942 * pszUrl [I] Url to modify
943 * pszEscaped [O] Destination for modified Url
944 * pcchEscaped [I/O] Length of pszUrl, destination for length of pszEscaped
945 * dwFlags [I] URL_ flags from "shlwapi.h"
948 * Success: S_OK. pszEscaped contains the escaped Url, pcchEscaped
949 * contains its length.
950 * Failure: E_POINTER, if pszEscaped is not large enough. In this case
951 * pcchEscaped is set to the required length.
953 * Converts unsafe characters into their escape sequences.
956 * - By default this function stops converting at the first '?' or
958 * - If dwFlags contains URL_ESCAPE_SPACES_ONLY then only spaces are
959 * converted, but the conversion continues past a '?' or '#'.
960 * - Note that this function did not work well (or at all) in shlwapi version 4.
963 * Only the following flags are implemented:
964 *| URL_ESCAPE_SPACES_ONLY
965 *| URL_DONT_ESCAPE_EXTRA_INFO
966 *| URL_ESCAPE_SEGMENT_ONLY
967 *| URL_ESCAPE_PERCENT
969 HRESULT WINAPI UrlEscapeW(
976 DWORD needed = 0, ret;
977 BOOL stop_escaping = FALSE;
978 WCHAR next[5], *dst = pszEscaped;
980 PARSEDURLW parsed_url;
983 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
985 TRACE("(%s %p %p 0x%08x)\n", debugstr_w(pszUrl), pszEscaped,
986 pcchEscaped, dwFlags);
988 if(!pszUrl || !pcchEscaped)
991 if(dwFlags & ~(URL_ESCAPE_SPACES_ONLY |
992 URL_ESCAPE_SEGMENT_ONLY |
993 URL_DONT_ESCAPE_EXTRA_INFO |
995 FIXME("Unimplemented flags: %08x\n", dwFlags);
998 if (dwFlags & URL_ESCAPE_SPACES_ONLY)
999 /* if SPACES_ONLY specified, reset the other controls */
1000 dwFlags &= ~(URL_DONT_ESCAPE_EXTRA_INFO |
1001 URL_ESCAPE_PERCENT |
1002 URL_ESCAPE_SEGMENT_ONLY);
1005 /* if SPACES_ONLY *not* specified the assume DONT_ESCAPE_EXTRA_INFO */
1006 dwFlags |= URL_DONT_ESCAPE_EXTRA_INFO;
1010 if(dwFlags & URL_ESCAPE_SEGMENT_ONLY) {
1011 int_flags = WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH | WINE_URL_ESCAPE_SLASH;
1013 parsed_url.cbSize = sizeof(parsed_url);
1014 if(ParseURLW(pszUrl, &parsed_url) != S_OK)
1015 parsed_url.nScheme = URL_SCHEME_INVALID;
1017 TRACE("scheme = %d (%s)\n", parsed_url.nScheme, debugstr_wn(parsed_url.pszProtocol, parsed_url.cchProtocol));
1019 if(dwFlags & URL_DONT_ESCAPE_EXTRA_INFO)
1020 int_flags = WINE_URL_STOP_ON_HASH | WINE_URL_STOP_ON_QUESTION;
1022 switch(parsed_url.nScheme) {
1023 case URL_SCHEME_FILE:
1024 int_flags |= WINE_URL_BASH_AS_SLASH | WINE_URL_COLLAPSE_SLASHES | WINE_URL_ESCAPE_HASH;
1025 int_flags &= ~WINE_URL_STOP_ON_HASH;
1028 case URL_SCHEME_HTTP:
1029 case URL_SCHEME_HTTPS:
1030 int_flags |= WINE_URL_BASH_AS_SLASH;
1031 if(parsed_url.pszSuffix[0] != '/' && parsed_url.pszSuffix[0] != '\\')
1032 int_flags |= WINE_URL_ESCAPE_SLASH;
1035 case URL_SCHEME_MAILTO:
1036 int_flags |= WINE_URL_ESCAPE_SLASH | WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH;
1037 int_flags &= ~(WINE_URL_STOP_ON_QUESTION | WINE_URL_STOP_ON_HASH);
1040 case URL_SCHEME_INVALID:
1043 case URL_SCHEME_FTP:
1045 if(parsed_url.pszSuffix[0] != '/')
1046 int_flags |= WINE_URL_ESCAPE_SLASH;
1051 for(src = pszUrl; *src; ) {
1055 if((int_flags & WINE_URL_COLLAPSE_SLASHES) && src == pszUrl + parsed_url.cchProtocol + 1) {
1056 int localhost_len = sizeof(localhost)/sizeof(WCHAR) - 1;
1057 while(cur == '/' || cur == '\\') {
1061 if(slashes == 2 && !strncmpiW(src, localhost, localhost_len)) { /* file://localhost/ -> file:/// */
1062 if(*(src + localhost_len) == '/' || *(src + localhost_len) == '\\')
1063 src += localhost_len + 1;
1070 next[0] = next[1] = next[2] = '/';
1077 next[0] = next[1] = '/';
1084 if(cur == '#' && (int_flags & WINE_URL_STOP_ON_HASH))
1085 stop_escaping = TRUE;
1087 if(cur == '?' && (int_flags & WINE_URL_STOP_ON_QUESTION))
1088 stop_escaping = TRUE;
1090 if(cur == '\\' && (int_flags & WINE_URL_BASH_AS_SLASH) && !stop_escaping) cur = '/';
1092 if(URL_NeedEscapeW(cur, dwFlags, int_flags) && stop_escaping == FALSE) {
1094 next[1] = hexDigits[(cur >> 4) & 0xf];
1095 next[2] = hexDigits[cur & 0xf];
1104 if(needed + len <= *pcchEscaped) {
1105 memcpy(dst, next, len*sizeof(WCHAR));
1111 if(needed < *pcchEscaped) {
1115 needed++; /* add one for the '\0' */
1118 *pcchEscaped = needed;
1123 /*************************************************************************
1124 * UrlUnescapeA [SHLWAPI.@]
1126 * Converts Url escape sequences back to ordinary characters.
1129 * pszUrl [I/O] Url to convert
1130 * pszUnescaped [O] Destination for converted Url
1131 * pcchUnescaped [I/O] Size of output string
1132 * dwFlags [I] URL_ESCAPE_ Flags from "shlwapi.h"
1135 * Success: S_OK. The converted value is in pszUnescaped, or in pszUrl if
1136 * dwFlags includes URL_ESCAPE_INPLACE.
1137 * Failure: E_POINTER if the converted Url is bigger than pcchUnescaped. In
1138 * this case pcchUnescaped is set to the size required.
1140 * If dwFlags includes URL_DONT_ESCAPE_EXTRA_INFO, the conversion stops at
1141 * the first occurrence of either a '?' or '#' character.
1143 HRESULT WINAPI UrlUnescapeA(
1146 LPDWORD pcchUnescaped,
1153 BOOL stop_unescaping = FALSE;
1155 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_a(pszUrl), pszUnescaped,
1156 pcchUnescaped, dwFlags);
1158 if (!pszUrl) return E_INVALIDARG;
1160 if(dwFlags & URL_UNESCAPE_INPLACE)
1164 if (!pszUnescaped || !pcchUnescaped) return E_INVALIDARG;
1168 for(src = pszUrl, needed = 0; *src; src++, needed++) {
1169 if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1170 (*src == '#' || *src == '?')) {
1171 stop_unescaping = TRUE;
1173 } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
1174 && stop_unescaping == FALSE) {
1177 memcpy(buf, src + 1, 2);
1179 ih = strtol(buf, NULL, 16);
1181 src += 2; /* Advance to end of escape */
1185 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1189 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1193 needed++; /* add one for the '\0' */
1196 if(!(dwFlags & URL_UNESCAPE_INPLACE))
1197 *pcchUnescaped = needed;
1200 TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1201 debugstr_a(pszUrl) : debugstr_a(pszUnescaped));
1207 /*************************************************************************
1208 * UrlUnescapeW [SHLWAPI.@]
1212 HRESULT WINAPI UrlUnescapeW(
1214 LPWSTR pszUnescaped,
1215 LPDWORD pcchUnescaped,
1222 BOOL stop_unescaping = FALSE;
1224 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszUrl), pszUnescaped,
1225 pcchUnescaped, dwFlags);
1227 if(!pszUrl) return E_INVALIDARG;
1229 if(dwFlags & URL_UNESCAPE_INPLACE)
1233 if (!pszUnescaped || !pcchUnescaped) return E_INVALIDARG;
1237 for(src = pszUrl, needed = 0; *src; src++, needed++) {
1238 if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1239 (*src == '#' || *src == '?')) {
1240 stop_unescaping = TRUE;
1242 } else if(*src == '%' && isxdigitW(*(src + 1)) && isxdigitW(*(src + 2))
1243 && stop_unescaping == FALSE) {
1245 WCHAR buf[5] = {'0','x',0};
1246 memcpy(buf + 2, src + 1, 2*sizeof(WCHAR));
1248 StrToIntExW(buf, STIF_SUPPORT_HEX, &ih);
1250 src += 2; /* Advance to end of escape */
1254 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1258 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1262 needed++; /* add one for the '\0' */
1265 if(!(dwFlags & URL_UNESCAPE_INPLACE))
1266 *pcchUnescaped = needed;
1269 TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1270 debugstr_w(pszUrl) : debugstr_w(pszUnescaped));
1276 /*************************************************************************
1277 * UrlGetLocationA [SHLWAPI.@]
1279 * Get the location from a Url.
1282 * pszUrl [I] Url to get the location from
1285 * A pointer to the start of the location in pszUrl, or NULL if there is
1289 * - MSDN erroneously states that "The location is the segment of the Url
1290 * starting with a '?' or '#' character". Neither V4 nor V5 of shlwapi.dll
1291 * stop at '?' and always return a NULL in this case.
1292 * - MSDN also erroneously states that "If a file URL has a query string,
1293 * the returned string is the query string". In all tested cases, if the
1294 * Url starts with "fi" then a NULL is returned. V5 gives the following results:
1297 *| NULL file://aa/b/cd#hohoh
1298 *| #hohoh http://aa/b/cd#hohoh
1299 *| NULL fi://aa/b/cd#hohoh
1300 *| #hohoh ff://aa/b/cd#hohoh
1302 LPCSTR WINAPI UrlGetLocationA(
1308 base.cbSize = sizeof(base);
1309 res1 = ParseURLA(pszUrl, &base);
1310 if (res1) return NULL; /* invalid scheme */
1312 /* if scheme is file: then never return pointer */
1313 if (strncmp(base.pszProtocol, "file", min(4,base.cchProtocol)) == 0) return NULL;
1315 /* Look for '#' and return its addr */
1316 return strchr(base.pszSuffix, '#');
1319 /*************************************************************************
1320 * UrlGetLocationW [SHLWAPI.@]
1322 * See UrlGetLocationA.
1324 LPCWSTR WINAPI UrlGetLocationW(
1330 base.cbSize = sizeof(base);
1331 res1 = ParseURLW(pszUrl, &base);
1332 if (res1) return NULL; /* invalid scheme */
1334 /* if scheme is file: then never return pointer */
1335 if (strncmpW(base.pszProtocol, fileW, min(4,base.cchProtocol)) == 0) return NULL;
1337 /* Look for '#' and return its addr */
1338 return strchrW(base.pszSuffix, '#');
1341 /*************************************************************************
1342 * UrlCompareA [SHLWAPI.@]
1347 * pszUrl1 [I] First Url to compare
1348 * pszUrl2 [I] Url to compare to pszUrl1
1349 * fIgnoreSlash [I] TRUE = compare only up to a final slash
1352 * less than zero, zero, or greater than zero indicating pszUrl2 is greater
1353 * than, equal to, or less than pszUrl1 respectively.
1355 INT WINAPI UrlCompareA(
1360 INT ret, len, len1, len2;
1363 return strcmp(pszUrl1, pszUrl2);
1364 len1 = strlen(pszUrl1);
1365 if (pszUrl1[len1-1] == '/') len1--;
1366 len2 = strlen(pszUrl2);
1367 if (pszUrl2[len2-1] == '/') len2--;
1369 return strncmp(pszUrl1, pszUrl2, len1);
1370 len = min(len1, len2);
1371 ret = strncmp(pszUrl1, pszUrl2, len);
1372 if (ret) return ret;
1373 if (len1 > len2) return 1;
1377 /*************************************************************************
1378 * UrlCompareW [SHLWAPI.@]
1382 INT WINAPI UrlCompareW(
1388 size_t len, len1, len2;
1391 return strcmpW(pszUrl1, pszUrl2);
1392 len1 = strlenW(pszUrl1);
1393 if (pszUrl1[len1-1] == '/') len1--;
1394 len2 = strlenW(pszUrl2);
1395 if (pszUrl2[len2-1] == '/') len2--;
1397 return strncmpW(pszUrl1, pszUrl2, len1);
1398 len = min(len1, len2);
1399 ret = strncmpW(pszUrl1, pszUrl2, len);
1400 if (ret) return ret;
1401 if (len1 > len2) return 1;
1405 /*************************************************************************
1406 * HashData [SHLWAPI.@]
1408 * Hash an input block into a variable sized digest.
1411 * lpSrc [I] Input block
1412 * nSrcLen [I] Length of lpSrc
1413 * lpDest [I] Output for hash digest
1414 * nDestLen [I] Length of lpDest
1417 * Success: TRUE. lpDest is filled with the computed hash value.
1418 * Failure: FALSE, if any argument is invalid.
1420 HRESULT WINAPI HashData(const unsigned char *lpSrc, DWORD nSrcLen,
1421 unsigned char *lpDest, DWORD nDestLen)
1423 INT srcCount = nSrcLen - 1, destCount = nDestLen - 1;
1425 if (IsBadReadPtr(lpSrc, nSrcLen) ||
1426 IsBadWritePtr(lpDest, nDestLen))
1427 return E_INVALIDARG;
1429 while (destCount >= 0)
1431 lpDest[destCount] = (destCount & 0xff);
1435 while (srcCount >= 0)
1437 destCount = nDestLen - 1;
1438 while (destCount >= 0)
1440 lpDest[destCount] = HashDataLookup[lpSrc[srcCount] ^ lpDest[destCount]];
1448 /*************************************************************************
1449 * UrlHashA [SHLWAPI.@]
1451 * Produce a Hash from a Url.
1454 * pszUrl [I] Url to hash
1455 * lpDest [O] Destinationh for hash
1456 * nDestLen [I] Length of lpDest
1459 * Success: S_OK. lpDest is filled with the computed hash value.
1460 * Failure: E_INVALIDARG, if any argument is invalid.
1462 HRESULT WINAPI UrlHashA(LPCSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1464 if (IsBadStringPtrA(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1465 return E_INVALIDARG;
1467 HashData((const BYTE*)pszUrl, (int)strlen(pszUrl), lpDest, nDestLen);
1471 /*************************************************************************
1472 * UrlHashW [SHLWAPI.@]
1476 HRESULT WINAPI UrlHashW(LPCWSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1478 char szUrl[MAX_PATH];
1480 TRACE("(%s,%p,%d)\n",debugstr_w(pszUrl), lpDest, nDestLen);
1482 if (IsBadStringPtrW(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1483 return E_INVALIDARG;
1485 /* Win32 hashes the data as an ASCII string, presumably so that both A+W
1486 * return the same digests for the same URL.
1488 WideCharToMultiByte(0, 0, pszUrl, -1, szUrl, MAX_PATH, 0, 0);
1489 HashData((const BYTE*)szUrl, (int)strlen(szUrl), lpDest, nDestLen);
1493 /*************************************************************************
1494 * UrlApplySchemeA [SHLWAPI.@]
1496 * Apply a scheme to a Url.
1499 * pszIn [I] Url to apply scheme to
1500 * pszOut [O] Destination for modified Url
1501 * pcchOut [I/O] Length of pszOut/destination for length of pszOut
1502 * dwFlags [I] URL_ flags from "shlwapi.h"
1505 * Success: S_OK: pszOut contains the modified Url, pcchOut contains its length.
1506 * Failure: An HRESULT error code describing the error.
1508 HRESULT WINAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1514 TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_a(pszIn),
1515 pszOut, pcchOut, pcchOut ? *pcchOut : 0, dwFlags);
1517 if (!pszIn || !pszOut || !pcchOut) return E_INVALIDARG;
1519 in = HeapAlloc(GetProcessHeap(), 0,
1520 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
1521 out = in + INTERNET_MAX_URL_LENGTH;
1523 MultiByteToWideChar(CP_ACP, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
1524 len = INTERNET_MAX_URL_LENGTH;
1526 ret = UrlApplySchemeW(in, out, &len, dwFlags);
1528 HeapFree(GetProcessHeap(), 0, in);
1532 len = WideCharToMultiByte(CP_ACP, 0, out, -1, NULL, 0, NULL, NULL);
1533 if (len > *pcchOut) {
1538 WideCharToMultiByte(CP_ACP, 0, out, -1, pszOut, *pcchOut, NULL, NULL);
1543 HeapFree(GetProcessHeap(), 0, in);
1547 static HRESULT URL_GuessScheme(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1552 DWORD value_len, data_len, dwType, i;
1553 WCHAR reg_path[MAX_PATH];
1554 WCHAR value[MAX_PATH], data[MAX_PATH];
1557 MultiByteToWideChar(0, 0,
1558 "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes",
1559 -1, reg_path, MAX_PATH);
1560 RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_path, 0, 1, &newkey);
1562 while(value_len = data_len = MAX_PATH,
1563 RegEnumValueW(newkey, index, value, &value_len,
1564 0, &dwType, (LPVOID)data, &data_len) == 0) {
1565 TRACE("guess %d %s is %s\n",
1566 index, debugstr_w(value), debugstr_w(data));
1569 for(i=0; i<value_len; i++) {
1572 /* remember that TRUE is not-equal */
1573 j = ChrCmpIW(Wxx, Wyy);
1576 if ((i == value_len) && !j) {
1577 if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1578 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1579 RegCloseKey(newkey);
1582 strcpyW(pszOut, data);
1583 strcatW(pszOut, pszIn);
1584 *pcchOut = strlenW(pszOut);
1585 TRACE("matched and set to %s\n", debugstr_w(pszOut));
1586 RegCloseKey(newkey);
1591 RegCloseKey(newkey);
1595 static HRESULT URL_ApplyDefault(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1598 DWORD data_len, dwType;
1599 WCHAR data[MAX_PATH];
1601 static const WCHAR prefix_keyW[] =
1602 {'S','o','f','t','w','a','r','e',
1603 '\\','M','i','c','r','o','s','o','f','t',
1604 '\\','W','i','n','d','o','w','s',
1605 '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
1607 '\\','D','e','f','a','u','l','t','P','r','e','f','i','x',0};
1609 /* get and prepend default */
1610 RegOpenKeyExW(HKEY_LOCAL_MACHINE, prefix_keyW, 0, 1, &newkey);
1611 data_len = sizeof(data);
1612 RegQueryValueExW(newkey, NULL, 0, &dwType, (LPBYTE)data, &data_len);
1613 RegCloseKey(newkey);
1614 if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1615 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1618 strcpyW(pszOut, data);
1619 strcatW(pszOut, pszIn);
1620 *pcchOut = strlenW(pszOut);
1621 TRACE("used default %s\n", debugstr_w(pszOut));
1625 /*************************************************************************
1626 * UrlApplySchemeW [SHLWAPI.@]
1628 * See UrlApplySchemeA.
1630 HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1632 PARSEDURLW in_scheme;
1636 TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_w(pszIn),
1637 pszOut, pcchOut, pcchOut ? *pcchOut : 0, dwFlags);
1639 if (!pszIn || !pszOut || !pcchOut) return E_INVALIDARG;
1641 if (dwFlags & URL_APPLY_GUESSFILE) {
1642 FIXME("(%s %p %p(%d) 0x%08x): stub URL_APPLY_GUESSFILE not implemented\n",
1643 debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwFlags);
1644 strcpyW(pszOut, pszIn);
1645 *pcchOut = strlenW(pszOut);
1649 in_scheme.cbSize = sizeof(in_scheme);
1650 /* See if the base has a scheme */
1651 res1 = ParseURLW(pszIn, &in_scheme);
1653 /* no scheme in input, need to see if we need to guess */
1654 if (dwFlags & URL_APPLY_GUESSSCHEME) {
1655 if ((ret = URL_GuessScheme(pszIn, pszOut, pcchOut)) != E_FAIL)
1660 /* we have a scheme, see if valid (known scheme) */
1661 if (in_scheme.nScheme) {
1662 /* have valid scheme, so just copy and exit */
1663 if (strlenW(pszIn) + 1 > *pcchOut) {
1664 *pcchOut = strlenW(pszIn) + 1;
1667 strcpyW(pszOut, pszIn);
1668 *pcchOut = strlenW(pszOut);
1669 TRACE("valid scheme, returning copy\n");
1674 /* If we are here, then either invalid scheme,
1675 * or no scheme and can't/failed guess.
1677 if ( ( ((res1 == 0) && (dwFlags & URL_APPLY_FORCEAPPLY)) ||
1679 (dwFlags & URL_APPLY_DEFAULT)) {
1680 /* find and apply default scheme */
1681 return URL_ApplyDefault(pszIn, pszOut, pcchOut);
1687 /*************************************************************************
1688 * UrlIsA [SHLWAPI.@]
1690 * Determine if a Url is of a certain class.
1693 * pszUrl [I] Url to check
1694 * Urlis [I] URLIS_ constant from "shlwapi.h"
1697 * TRUE if pszUrl belongs to the class type in Urlis.
1700 BOOL WINAPI UrlIsA(LPCSTR pszUrl, URLIS Urlis)
1706 TRACE("(%s %d)\n", debugstr_a(pszUrl), Urlis);
1711 base.cbSize = sizeof(base);
1712 res1 = ParseURLA(pszUrl, &base);
1713 if (res1) return FALSE; /* invalid scheme */
1714 switch (base.nScheme)
1716 case URL_SCHEME_MAILTO:
1717 case URL_SCHEME_SHELL:
1718 case URL_SCHEME_JAVASCRIPT:
1719 case URL_SCHEME_VBSCRIPT:
1720 case URL_SCHEME_ABOUT:
1726 return !StrCmpNA("file:", pszUrl, 5);
1728 case URLIS_DIRECTORY:
1729 last = pszUrl + strlen(pszUrl) - 1;
1730 return (last >= pszUrl && (*last == '/' || *last == '\\' ));
1733 return PathIsURLA(pszUrl);
1735 case URLIS_NOHISTORY:
1736 case URLIS_APPLIABLE:
1737 case URLIS_HASQUERY:
1739 FIXME("(%s %d): stub\n", debugstr_a(pszUrl), Urlis);
1744 /*************************************************************************
1745 * UrlIsW [SHLWAPI.@]
1749 BOOL WINAPI UrlIsW(LPCWSTR pszUrl, URLIS Urlis)
1751 static const WCHAR stemp[] = { 'f','i','l','e',':',0 };
1756 TRACE("(%s %d)\n", debugstr_w(pszUrl), Urlis);
1761 base.cbSize = sizeof(base);
1762 res1 = ParseURLW(pszUrl, &base);
1763 if (res1) return FALSE; /* invalid scheme */
1764 switch (base.nScheme)
1766 case URL_SCHEME_MAILTO:
1767 case URL_SCHEME_SHELL:
1768 case URL_SCHEME_JAVASCRIPT:
1769 case URL_SCHEME_VBSCRIPT:
1770 case URL_SCHEME_ABOUT:
1776 return !strncmpW(stemp, pszUrl, 5);
1778 case URLIS_DIRECTORY:
1779 last = pszUrl + strlenW(pszUrl) - 1;
1780 return (last >= pszUrl && (*last == '/' || *last == '\\'));
1783 return PathIsURLW(pszUrl);
1785 case URLIS_NOHISTORY:
1786 case URLIS_APPLIABLE:
1787 case URLIS_HASQUERY:
1789 FIXME("(%s %d): stub\n", debugstr_w(pszUrl), Urlis);
1794 /*************************************************************************
1795 * UrlIsNoHistoryA [SHLWAPI.@]
1797 * Determine if a Url should not be stored in the users history list.
1800 * pszUrl [I] Url to check
1803 * TRUE, if pszUrl should be excluded from the history list,
1806 BOOL WINAPI UrlIsNoHistoryA(LPCSTR pszUrl)
1808 return UrlIsA(pszUrl, URLIS_NOHISTORY);
1811 /*************************************************************************
1812 * UrlIsNoHistoryW [SHLWAPI.@]
1814 * See UrlIsNoHistoryA.
1816 BOOL WINAPI UrlIsNoHistoryW(LPCWSTR pszUrl)
1818 return UrlIsW(pszUrl, URLIS_NOHISTORY);
1821 /*************************************************************************
1822 * UrlIsOpaqueA [SHLWAPI.@]
1824 * Determine if a Url is opaque.
1827 * pszUrl [I] Url to check
1830 * TRUE if pszUrl is opaque,
1834 * An opaque Url is one that does not start with "<protocol>://".
1836 BOOL WINAPI UrlIsOpaqueA(LPCSTR pszUrl)
1838 return UrlIsA(pszUrl, URLIS_OPAQUE);
1841 /*************************************************************************
1842 * UrlIsOpaqueW [SHLWAPI.@]
1846 BOOL WINAPI UrlIsOpaqueW(LPCWSTR pszUrl)
1848 return UrlIsW(pszUrl, URLIS_OPAQUE);
1851 /*************************************************************************
1852 * Scans for characters of type "type" and when not matching found,
1853 * returns pointer to it and length in size.
1855 * Characters tested based on RFC 1738
1857 static LPCWSTR URL_ScanID(LPCWSTR start, LPDWORD size, WINE_URL_SCAN_TYPE type)
1859 static DWORD alwayszero = 0;
1868 if ( (islowerW(*start) && isalphaW(*start)) ||
1883 if ( isalphaW(*start) ||
1885 /* user/password only characters */
1890 /* *extra* characters */
1897 /* *safe* characters */
1905 } else if (*start == '%') {
1906 if (isxdigitW(*(start+1)) &&
1907 isxdigitW(*(start+2))) {
1919 if (isdigitW(*start)) {
1930 if (isalnumW(*start) ||
1941 FIXME("unknown type %d\n", type);
1942 return (LPWSTR)&alwayszero;
1944 /* TRACE("scanned %d characters next char %p<%c>\n",
1945 *size, start, *start); */
1949 /*************************************************************************
1950 * Attempt to parse URL into pieces.
1952 static LONG URL_ParseUrl(LPCWSTR pszUrl, WINE_PARSE_URL *pl)
1956 memset(pl, 0, sizeof(WINE_PARSE_URL));
1957 pl->pScheme = pszUrl;
1958 work = URL_ScanID(pl->pScheme, &pl->szScheme, SCHEME);
1959 if (!*work || (*work != ':')) goto ErrorExit;
1961 if ((*work != '/') || (*(work+1) != '/')) goto ErrorExit;
1962 pl->pUserName = work + 2;
1963 work = URL_ScanID(pl->pUserName, &pl->szUserName, USERPASS);
1964 if (*work == ':' ) {
1965 /* parse password */
1967 pl->pPassword = work;
1968 work = URL_ScanID(pl->pPassword, &pl->szPassword, USERPASS);
1970 /* what we just parsed must be the hostname and port
1971 * so reset pointers and clear then let it parse */
1972 pl->szUserName = pl->szPassword = 0;
1973 work = pl->pUserName - 1;
1974 pl->pUserName = pl->pPassword = 0;
1976 } else if (*work == '@') {
1980 } else if (!*work || (*work == '/') || (*work == '.')) {
1981 /* what was parsed was hostname, so reset pointers and let it parse */
1982 pl->szUserName = pl->szPassword = 0;
1983 work = pl->pUserName - 1;
1984 pl->pUserName = pl->pPassword = 0;
1985 } else goto ErrorExit;
1987 /* now start parsing hostname or hostnumber */
1989 pl->pHostName = work;
1990 work = URL_ScanID(pl->pHostName, &pl->szHostName, HOST);
1995 work = URL_ScanID(pl->pPort, &pl->szPort, PORT);
1998 /* see if query string */
1999 pl->pQuery = strchrW(work, '?');
2000 if (pl->pQuery) pl->szQuery = strlenW(pl->pQuery);
2002 TRACE("parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
2003 pl->pScheme, pl->szScheme,
2004 pl->pUserName, pl->szUserName,
2005 pl->pPassword, pl->szPassword,
2006 pl->pHostName, pl->szHostName,
2007 pl->pPort, pl->szPort,
2008 pl->pQuery, pl->szQuery);
2011 FIXME("failed to parse %s\n", debugstr_w(pszUrl));
2012 return E_INVALIDARG;
2015 /*************************************************************************
2016 * UrlGetPartA [SHLWAPI.@]
2018 * Retrieve part of a Url.
2021 * pszIn [I] Url to parse
2022 * pszOut [O] Destination for part of pszIn requested
2023 * pcchOut [I] Size of pszOut
2024 * [O] length of pszOut string EXCLUDING '\0' if S_OK, otherwise
2025 * needed size of pszOut INCLUDING '\0'.
2026 * dwPart [I] URL_PART_ enum from "shlwapi.h"
2027 * dwFlags [I] URL_ flags from "shlwapi.h"
2030 * Success: S_OK. pszOut contains the part requested, pcchOut contains its length.
2031 * Failure: An HRESULT error code describing the error.
2033 HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut,
2034 DWORD dwPart, DWORD dwFlags)
2037 DWORD ret, len, len2;
2039 in = HeapAlloc(GetProcessHeap(), 0,
2040 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
2041 out = in + INTERNET_MAX_URL_LENGTH;
2043 MultiByteToWideChar(0, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
2045 len = INTERNET_MAX_URL_LENGTH;
2046 ret = UrlGetPartW(in, out, &len, dwPart, dwFlags);
2049 HeapFree(GetProcessHeap(), 0, in);
2053 len2 = WideCharToMultiByte(0, 0, out, len, 0, 0, 0, 0);
2054 if (len2 > *pcchOut) {
2056 HeapFree(GetProcessHeap(), 0, in);
2059 WideCharToMultiByte(0, 0, out, len+1, pszOut, *pcchOut, 0, 0);
2061 HeapFree(GetProcessHeap(), 0, in);
2065 /*************************************************************************
2066 * UrlGetPartW [SHLWAPI.@]
2070 HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut,
2071 DWORD dwPart, DWORD dwFlags)
2075 DWORD size, schsize;
2076 LPCWSTR addr, schaddr;
2078 TRACE("(%s %p %p(%d) %08x %08x)\n",
2079 debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwPart, dwFlags);
2081 ret = URL_ParseUrl(pszIn, &pl);
2083 schaddr = pl.pScheme;
2084 schsize = pl.szScheme;
2087 case URL_PART_SCHEME:
2088 if (!pl.szScheme) return E_INVALIDARG;
2093 case URL_PART_HOSTNAME:
2094 if (!pl.szHostName) return E_INVALIDARG;
2095 addr = pl.pHostName;
2096 size = pl.szHostName;
2099 case URL_PART_USERNAME:
2100 if (!pl.szUserName) return E_INVALIDARG;
2101 addr = pl.pUserName;
2102 size = pl.szUserName;
2105 case URL_PART_PASSWORD:
2106 if (!pl.szPassword) return E_INVALIDARG;
2107 addr = pl.pPassword;
2108 size = pl.szPassword;
2112 if (!pl.szPort) return E_INVALIDARG;
2117 case URL_PART_QUERY:
2118 if (!pl.szQuery) return E_INVALIDARG;
2124 return E_INVALIDARG;
2127 if (dwFlags == URL_PARTFLAG_KEEPSCHEME) {
2128 if (*pcchOut < schsize + size + 2) {
2129 *pcchOut = schsize + size + 2;
2132 memcpy(pszOut, schaddr, schsize*sizeof(WCHAR));
2133 pszOut[schsize] = ':';
2134 memcpy(pszOut+schsize+1, addr, size*sizeof(WCHAR));
2135 pszOut[schsize+1+size] = 0;
2136 *pcchOut = schsize + 1 + size;
2139 if (*pcchOut < size + 1) {*pcchOut = size+1; return E_POINTER;}
2140 memcpy(pszOut, addr, size*sizeof(WCHAR));
2144 TRACE("len=%d %s\n", *pcchOut, debugstr_w(pszOut));
2149 /*************************************************************************
2150 * PathIsURLA [SHLWAPI.@]
2152 * Check if the given path is a Url.
2155 * lpszPath [I] Path to check.
2158 * TRUE if lpszPath is a Url.
2159 * FALSE if lpszPath is NULL or not a Url.
2161 BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
2165 TRACE("%s\n", debugstr_a(lpstrPath));
2167 if (!lpstrPath || !*lpstrPath) return FALSE;
2170 base.cbSize = sizeof(base);
2171 ParseURLA(lpstrPath, &base);
2172 return (base.nScheme != URL_SCHEME_INVALID);
2175 /*************************************************************************
2176 * PathIsURLW [SHLWAPI.@]
2180 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
2184 TRACE("%s\n", debugstr_w(lpstrPath));
2186 if (!lpstrPath || !*lpstrPath) return FALSE;
2189 base.cbSize = sizeof(base);
2190 ParseURLW(lpstrPath, &base);
2191 return (base.nScheme != URL_SCHEME_INVALID);
2194 /*************************************************************************
2195 * UrlCreateFromPathA [SHLWAPI.@]
2197 * See UrlCreateFromPathW
2199 HRESULT WINAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2201 WCHAR bufW[INTERNET_MAX_URL_LENGTH];
2203 UNICODE_STRING pathW;
2205 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
2207 if(!RtlCreateUnicodeStringFromAsciiz(&pathW, pszPath))
2208 return E_INVALIDARG;
2209 if((ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved)) == E_POINTER) {
2210 urlW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
2211 ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved);
2213 if(ret == S_OK || ret == S_FALSE) {
2214 RtlUnicodeToMultiByteSize(&lenA, urlW, lenW * sizeof(WCHAR));
2215 if(*pcchUrl > lenA) {
2216 RtlUnicodeToMultiByteN(pszUrl, *pcchUrl - 1, &lenA, urlW, lenW * sizeof(WCHAR));
2220 *pcchUrl = lenA + 1;
2224 if(urlW != bufW) HeapFree(GetProcessHeap(), 0, urlW);
2225 RtlFreeUnicodeString(&pathW);
2229 /*************************************************************************
2230 * UrlCreateFromPathW [SHLWAPI.@]
2232 * Create a Url from a file path.
2235 * pszPath [I] Path to convert
2236 * pszUrl [O] Destination for the converted Url
2237 * pcchUrl [I/O] Length of pszUrl
2238 * dwReserved [I] Reserved, must be 0
2241 * Success: S_OK pszUrl contains the converted path, S_FALSE if the path is already a Url
2242 * Failure: An HRESULT error code.
2244 HRESULT WINAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2249 WCHAR file_colonW[] = {'f','i','l','e',':',0};
2250 WCHAR three_slashesW[] = {'/','/','/',0};
2251 PARSEDURLW parsed_url;
2253 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszPath), pszUrl, pcchUrl, dwReserved);
2255 /* Validate arguments */
2256 if (dwReserved != 0)
2257 return E_INVALIDARG;
2258 if (!pszUrl || !pcchUrl)
2259 return E_INVALIDARG;
2262 parsed_url.cbSize = sizeof(parsed_url);
2263 if(ParseURLW(pszPath, &parsed_url) == S_OK) {
2264 if(parsed_url.nScheme != URL_SCHEME_INVALID && parsed_url.cchProtocol > 1) {
2265 needed = strlenW(pszPath);
2266 if (needed >= *pcchUrl) {
2267 *pcchUrl = needed + 1;
2271 strcpyW(pszUrl, pszPath);
2277 pszNewUrl = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath) + 9) * sizeof(WCHAR)); /* "file:///" + pszPath_len + 1 */
2278 strcpyW(pszNewUrl, file_colonW);
2279 if(isalphaW(pszPath[0]) && pszPath[1] == ':')
2280 strcatW(pszNewUrl, three_slashesW);
2281 strcatW(pszNewUrl, pszPath);
2282 ret = UrlEscapeW(pszNewUrl, pszUrl, pcchUrl, URL_ESCAPE_PERCENT);
2284 HeapFree(GetProcessHeap(), 0, pszNewUrl);
2288 /*************************************************************************
2289 * SHAutoComplete [SHLWAPI.@]
2291 * Enable auto-completion for an edit control.
2294 * hwndEdit [I] Handle of control to enable auto-completion for
2295 * dwFlags [I] SHACF_ flags from "shlwapi.h"
2298 * Success: S_OK. Auto-completion is enabled for the control.
2299 * Failure: An HRESULT error code indicating the error.
2301 HRESULT WINAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags)
2303 FIXME("SHAutoComplete stub\n");
2307 /*************************************************************************
2308 * MLBuildResURLA [SHLWAPI.405]
2310 * Create a Url pointing to a resource in a module.
2313 * lpszLibName [I] Name of the module containing the resource
2314 * hMod [I] Callers module handle
2315 * dwFlags [I] Undocumented flags for loading the module
2316 * lpszRes [I] Resource name
2317 * lpszDest [O] Destination for resulting Url
2318 * dwDestLen [I] Length of lpszDest
2321 * Success: S_OK. lpszDest contains the resource Url.
2322 * Failure: E_INVALIDARG, if any argument is invalid, or
2323 * E_FAIL if dwDestLen is too small.
2325 HRESULT WINAPI MLBuildResURLA(LPCSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2326 LPCSTR lpszRes, LPSTR lpszDest, DWORD dwDestLen)
2328 WCHAR szLibName[MAX_PATH], szRes[MAX_PATH], szDest[MAX_PATH];
2332 MultiByteToWideChar(CP_ACP, 0, lpszLibName, -1, szLibName, sizeof(szLibName)/sizeof(WCHAR));
2335 MultiByteToWideChar(CP_ACP, 0, lpszRes, -1, szRes, sizeof(szRes)/sizeof(WCHAR));
2337 if (dwDestLen > sizeof(szLibName)/sizeof(WCHAR))
2338 dwDestLen = sizeof(szLibName)/sizeof(WCHAR);
2340 hRet = MLBuildResURLW(lpszLibName ? szLibName : NULL, hMod, dwFlags,
2341 lpszRes ? szRes : NULL, lpszDest ? szDest : NULL, dwDestLen);
2342 if (SUCCEEDED(hRet) && lpszDest)
2343 WideCharToMultiByte(CP_ACP, 0, szDest, -1, lpszDest, dwDestLen, 0, 0);
2348 /*************************************************************************
2349 * MLBuildResURLA [SHLWAPI.406]
2351 * See MLBuildResURLA.
2353 HRESULT WINAPI MLBuildResURLW(LPCWSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2354 LPCWSTR lpszRes, LPWSTR lpszDest, DWORD dwDestLen)
2356 static const WCHAR szRes[] = { 'r','e','s',':','/','/','\0' };
2357 #define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR))
2358 HRESULT hRet = E_FAIL;
2360 TRACE("(%s,%p,0x%08x,%s,%p,%d)\n", debugstr_w(lpszLibName), hMod, dwFlags,
2361 debugstr_w(lpszRes), lpszDest, dwDestLen);
2363 if (!lpszLibName || !hMod || hMod == INVALID_HANDLE_VALUE || !lpszRes ||
2364 !lpszDest || (dwFlags && dwFlags != 2))
2365 return E_INVALIDARG;
2367 if (dwDestLen >= szResLen + 1)
2369 dwDestLen -= (szResLen + 1);
2370 memcpy(lpszDest, szRes, sizeof(szRes));
2372 hMod = MLLoadLibraryW(lpszLibName, hMod, dwFlags);
2376 WCHAR szBuff[MAX_PATH];
2379 len = GetModuleFileNameW(hMod, szBuff, sizeof(szBuff)/sizeof(WCHAR));
2380 if (len && len < sizeof(szBuff)/sizeof(WCHAR))
2382 DWORD dwPathLen = strlenW(szBuff) + 1;
2384 if (dwDestLen >= dwPathLen)
2388 dwDestLen -= dwPathLen;
2389 memcpy(lpszDest + szResLen, szBuff, dwPathLen * sizeof(WCHAR));
2391 dwResLen = strlenW(lpszRes) + 1;
2392 if (dwDestLen >= dwResLen + 1)
2394 lpszDest[szResLen + dwPathLen + dwResLen] = '/';
2395 memcpy(lpszDest + szResLen + dwPathLen, lpszRes, dwResLen * sizeof(WCHAR));
2400 MLFreeLibrary(hMod);