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