projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[SHLWAPI]
[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 && !strncmpW(wszFile, pszUrl, sizeof(wszFile)/sizeof(WCHAR))
363 && !memcmp(wszLocalhost, wk1, sizeof(wszLocalhost))){
364 wk1 += sizeof(wszLocalhost)/sizeof(WCHAR);
365 while(*wk1 == '\\' && (dwFlags & URL_FILE_USE_PATHURL))
366 wk1++;
367 }
368 if(*wk1 == '/' && (dwFlags & URL_FILE_USE_PATHURL))
369 wk1++;
370 state = 4;
371 break;
372 case 3:
373 nWkLen = strlenW(wk1);
374 memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
375 mp = wk2;
376 wk1 += nWkLen;
377 wk2 += nWkLen;
378
379 if(slash) {
380 while(mp < wk2) {
381 if(*mp == '/' || *mp == '\\')
382 *mp = slash;
383 mp++;
384 }
385 }
386 break;
387 case 4:
388 if (!isalnumW(*wk1) && (*wk1 != '-') && (*wk1 != '.') && (*wk1 != ':'))
389 {state = 3; break;}
390 while(isalnumW(*wk1) || (*wk1 == '-') || (*wk1 == '.') || (*wk1 == ':'))
391 *wk2++ = *wk1++;
392 state = 5;
393 if (!*wk1) {
394 if(slash)
395 *wk2++ = slash;
396 else
397 *wk2++ = '/';
398 }
399 break;
400 case 5:
401 if (*wk1 != '/' && *wk1 != '\\') {state = 3; break;}
402 while(*wk1 == '/' || *wk1 == '\\') {
403 if(slash)
404 *wk2++ = slash;
405 else
406 *wk2++ = *wk1;
407 wk1++;
408 }
409 state = 6;
410 break;
411 case 6:
412 if(dwFlags & URL_DONT_SIMPLIFY) {
413 state = 3;
414 break;
415 }
416
417 /* Now at root location, cannot back up any more. */
418 /* "root" will point at the '/' */
419
420 root = wk2-1;
421 while (*wk1) {
422 mp = strchrW(wk1, '/');
423 mp2 = strchrW(wk1, '\\');
424 if(mp2 && (!mp || mp2 < mp))
425 mp = mp2;
426 if (!mp) {
427 nWkLen = strlenW(wk1);
428 memcpy(wk2, wk1, (nWkLen + 1) * sizeof(WCHAR));
429 wk1 += nWkLen;
430 wk2 += nWkLen;
431 continue;
432 }
433 nLen = mp - wk1;
434 if(nLen) {
435 memcpy(wk2, wk1, nLen * sizeof(WCHAR));
436 wk2 += nLen;
437 wk1 += nLen;
438 }
439 if(slash)
440 *wk2++ = slash;
441 else
442 *wk2++ = *wk1;
443 wk1++;
444
445 if (*wk1 == '.') {
446 TRACE("found '/.'\n");
447 if (wk1[1] == '/' || wk1[1] == '\\') {
448 /* case of /./ -> skip the ./ */
449 wk1 += 2;
450 }
451 else if (wk1[1] == '.') {
452 /* found /.. look for next / */
453 TRACE("found '/..'\n");
454 if (wk1[2] == '/' || wk1[2] == '\\' ||wk1[2] == '?'
455 || wk1[2] == '#' || !wk1[2]) {
456 /* case /../ -> need to backup wk2 */
457 TRACE("found '/../'\n");
458 *(wk2-1) = '\0'; /* set end of string */
459 mp = strrchrW(root, '/');
460 mp2 = strrchrW(root, '\\');
461 if(mp2 && (!mp || mp2 < mp))
462 mp = mp2;
463 if (mp && (mp >= root)) {
464 /* found valid backup point */
465 wk2 = mp + 1;
466 if(wk1[2] != '/' && wk1[2] != '\\')
467 wk1 += 2;
468 else
469 wk1 += 3;
470 }
471 else {
472 /* did not find point, restore '/' */
473 *(wk2-1) = slash;
474 }
475 }
476 }
477 }
478 }
479 *wk2 = '\0';
480 break;
481 default:
482 FIXME("how did we get here - state=%d\n", state);
483 HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
484 return E_INVALIDARG;
485 }
486 *wk2 = '\0';
487 TRACE("Simplified, orig <%s>, simple <%s>\n",
488 debugstr_w(pszUrl), debugstr_w(lpszUrlCpy));
489 }
490 nLen = lstrlenW(lpszUrlCpy);
491 while ((nLen > 0) && ((lpszUrlCpy[nLen-1] <= ' ')))
492 lpszUrlCpy[--nLen]=0;
493
494 if(dwFlags & (URL_UNESCAPE | URL_FILE_USE_PATHURL))
495 UrlUnescapeW(lpszUrlCpy, NULL, &nLen, URL_UNESCAPE_INPLACE);
496
497 if((EscapeFlags = dwFlags & (URL_ESCAPE_UNSAFE |
498 URL_ESCAPE_SPACES_ONLY |
499 URL_ESCAPE_PERCENT |
500 URL_DONT_ESCAPE_EXTRA_INFO |
501 URL_ESCAPE_SEGMENT_ONLY ))) {
502 EscapeFlags &= ~URL_ESCAPE_UNSAFE;
503 hr = UrlEscapeW(lpszUrlCpy, pszCanonicalized, pcchCanonicalized,
504 EscapeFlags);
505 } else { /* No escaping needed, just copy the string */
506 nLen = lstrlenW(lpszUrlCpy);
507 if(nLen < *pcchCanonicalized)
508 memcpy(pszCanonicalized, lpszUrlCpy, (nLen + 1)*sizeof(WCHAR));
509 else {
510 hr = E_POINTER;
511 nLen++;
512 }
513 *pcchCanonicalized = nLen;
514 }
515
516 HeapFree(GetProcessHeap(), 0, lpszUrlCpy);
517
518 if (hr == S_OK)
519 TRACE("result %s\n", debugstr_w(pszCanonicalized));
520
521 return hr;
522 }
523
524 /*************************************************************************
525 * UrlCombineA [SHLWAPI.@]
526 *
527 * Combine two Urls.
528 *
529 * PARAMS
530 * pszBase [I] Base Url
531 * pszRelative [I] Url to combine with pszBase
532 * pszCombined [O] Destination for combined Url
533 * pcchCombined [O] Destination for length of pszCombined
534 * dwFlags [I] URL_ flags from "shlwapi.h"
535 *
536 * RETURNS
537 * Success: S_OK. pszCombined contains the combined Url, pcchCombined
538 * contains its length.
539 * Failure: An HRESULT error code indicating the error.
540 */
541 HRESULT WINAPI UrlCombineA(LPCSTR pszBase, LPCSTR pszRelative,
542 LPSTR pszCombined, LPDWORD pcchCombined,
543 DWORD dwFlags)
544 {
545 LPWSTR base, relative, combined;
546 DWORD ret, len, len2;
547
548 TRACE("(base %s, Relative %s, Combine size %d, flags %08x) using W version\n",
549 debugstr_a(pszBase),debugstr_a(pszRelative),
550 pcchCombined?*pcchCombined:0,dwFlags);
551
552 if(!pszBase || !pszRelative || !pcchCombined)
553 return E_INVALIDARG;
554
555 base = HeapAlloc(GetProcessHeap(), 0,
556 (3*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
557 relative = base + INTERNET_MAX_URL_LENGTH;
558 combined = relative + INTERNET_MAX_URL_LENGTH;
559
560 MultiByteToWideChar(0, 0, pszBase, -1, base, INTERNET_MAX_URL_LENGTH);
561 MultiByteToWideChar(0, 0, pszRelative, -1, relative, INTERNET_MAX_URL_LENGTH);
562 len = *pcchCombined;
563
564 ret = UrlCombineW(base, relative, pszCombined?combined:NULL, &len, dwFlags);
565 if (ret != S_OK) {
566 *pcchCombined = len;
567 HeapFree(GetProcessHeap(), 0, base);
568 return ret;
569 }
570
571 len2 = WideCharToMultiByte(0, 0, combined, len, 0, 0, 0, 0);
572 if (len2 > *pcchCombined) {
573 *pcchCombined = len2;
574 HeapFree(GetProcessHeap(), 0, base);
575 return E_POINTER;
576 }
577 WideCharToMultiByte(0, 0, combined, len+1, pszCombined, (*pcchCombined)+1,
578 0, 0);
579 *pcchCombined = len2;
580 HeapFree(GetProcessHeap(), 0, base);
581 return S_OK;
582 }
583
584 /*************************************************************************
585 * UrlCombineW [SHLWAPI.@]
586 *
587 * See UrlCombineA.
588 */
589 HRESULT WINAPI UrlCombineW(LPCWSTR pszBase, LPCWSTR pszRelative,
590 LPWSTR pszCombined, LPDWORD pcchCombined,
591 DWORD dwFlags)
592 {
593 PARSEDURLW base, relative;
594 DWORD myflags, sizeloc = 0;
595 DWORD len, res1, res2, process_case = 0;
596 LPWSTR work, preliminary, mbase, mrelative;
597 static const WCHAR myfilestr[] = {'f','i','l','e',':','/','/','/','\0'};
598 HRESULT ret;
599
600 TRACE("(base %s, Relative %s, Combine size %d, flags %08x)\n",
601 debugstr_w(pszBase),debugstr_w(pszRelative),
602 pcchCombined?*pcchCombined:0,dwFlags);
603
604 if(!pszBase || !pszRelative || !pcchCombined)
605 return E_INVALIDARG;
606
607 base.cbSize = sizeof(base);
608 relative.cbSize = sizeof(relative);
609
610 /* Get space for duplicates of the input and the output */
611 preliminary = HeapAlloc(GetProcessHeap(), 0, (3*INTERNET_MAX_URL_LENGTH) *
612 sizeof(WCHAR));
613 mbase = preliminary + INTERNET_MAX_URL_LENGTH;
614 mrelative = mbase + INTERNET_MAX_URL_LENGTH;
615 *preliminary = '\0';
616
617 /* Canonicalize the base input prior to looking for the scheme */
618 myflags = dwFlags & (URL_DONT_SIMPLIFY | URL_UNESCAPE);
619 len = INTERNET_MAX_URL_LENGTH;
620 ret = UrlCanonicalizeW(pszBase, mbase, &len, myflags);
621
622 /* Canonicalize the relative input prior to looking for the scheme */
623 len = INTERNET_MAX_URL_LENGTH;
624 ret = UrlCanonicalizeW(pszRelative, mrelative, &len, myflags);
625
626 /* See if the base has a scheme */
627 res1 = ParseURLW(mbase, &base);
628 if (res1) {
629 /* if pszBase has no scheme, then return pszRelative */
630 TRACE("no scheme detected in Base\n");
631 process_case = 1;
632 }
633 else do {
634 BOOL manual_search = FALSE;
635
636 /* mk is a special case */
637 if(base.nScheme == URL_SCHEME_MK) {
638 static const WCHAR wsz[] = {':',':',0};
639
640 WCHAR *ptr = strstrW(base.pszSuffix, wsz);
641 if(ptr) {
642 int delta;
643
644 ptr += 2;
645 delta = ptr-base.pszSuffix;
646 base.cchProtocol += delta;
647 base.pszSuffix += delta;
648 base.cchSuffix -= delta;
649 }
650 }else {
651 /* get size of location field (if it exists) */
652 work = (LPWSTR)base.pszSuffix;
653 sizeloc = 0;
654 if (*work++ == '/') {
655 if (*work++ == '/') {
656 /* At this point have start of location and
657 * it ends at next '/' or end of string.
658 */
659 while(*work && (*work != '/')) work++;
660 sizeloc = (DWORD)(work - base.pszSuffix);
661 }
662 }
663 }
664
665 /* If there is a '#' and the characters immediately preceeding it are
666 * ".htm[l]", then begin looking for the last leaf starting from
667 * the '#'. Otherwise the '#' is not meaningful and just start
668 * looking from the end. */
669 if ((work = strchrW(base.pszSuffix + sizeloc, '#'))) {
670 const WCHAR htmlW[] = {'.','h','t','m','l',0};
671 const int len_htmlW = 5;
672 const WCHAR htmW[] = {'.','h','t','m',0};
673 const int len_htmW = 4;
674
675 if (work - base.pszSuffix > len_htmW * sizeof(WCHAR)) {
676 work -= len_htmW;
677 if (strncmpiW(work, htmW, len_htmW) == 0)
678 manual_search = TRUE;
679 work += len_htmW;
680 }
681
682 if (!manual_search &&
683 work - base.pszSuffix > len_htmlW * sizeof(WCHAR)) {
684 work -= len_htmlW;
685 if (strncmpiW(work, htmlW, len_htmlW) == 0)
686 manual_search = TRUE;
687 work += len_htmlW;
688 }
689 }
690
691 if (manual_search) {
692 /* search backwards starting from the current position */
693 while (*work != '/' && work > base.pszSuffix + sizeloc)
694 --work;
695 if (work > base.pszSuffix + sizeloc)
696 base.cchSuffix = work - base.pszSuffix + 1;
697 }else {
698 /* search backwards starting from the end of the string */
699 work = strrchrW((base.pszSuffix+sizeloc), '/');
700 if (work) {
701 len = (DWORD)(work - base.pszSuffix + 1);
702 base.cchSuffix = len;
703 }
704 }
705
706 /*
707 * At this point:
708 * .pszSuffix points to location (starting with '//')
709 * .cchSuffix length of location (above) and rest less the last
710 * leaf (if any)
711 * sizeloc length of location (above) up to but not including
712 * the last '/'
713 */
714
715 res2 = ParseURLW(mrelative, &relative);
716 if (res2) {
717 /* no scheme in pszRelative */
718 TRACE("no scheme detected in Relative\n");
719 relative.pszSuffix = mrelative; /* case 3,4,5 depends on this */
720 relative.cchSuffix = strlenW(mrelative);
721 if (*pszRelative == ':') {
722 /* case that is either left alone or uses pszBase */
723 if (dwFlags & URL_PLUGGABLE_PROTOCOL) {
724 process_case = 5;
725 break;
726 }
727 process_case = 1;
728 break;
729 }
730 if (isalnum(*mrelative) && (*(mrelative + 1) == ':')) {
731 /* case that becomes "file:///" */
732 strcpyW(preliminary, myfilestr);
733 process_case = 1;
734 break;
735 }
736 if ((*mrelative == '/') && (*(mrelative+1) == '/')) {
737 /* pszRelative has location and rest */
738 process_case = 3;
739 break;
740 }
741 if (*mrelative == '/') {
742 /* case where pszRelative is root to location */
743 process_case = 4;
744 break;
745 }
746 process_case = (*base.pszSuffix == '/' || base.nScheme == URL_SCHEME_MK) ? 5 : 3;
747 break;
748 }
749
750 /* handle cases where pszRelative has scheme */
751 if ((base.cchProtocol == relative.cchProtocol) &&
752 (strncmpW(base.pszProtocol, relative.pszProtocol, base.cchProtocol) == 0)) {
753
754 /* since the schemes are the same */
755 if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
756 /* case where pszRelative replaces location and following */
757 process_case = 3;
758 break;
759 }
760 if (*relative.pszSuffix == '/') {
761 /* case where pszRelative is root to location */
762 process_case = 4;
763 break;
764 }
765 /* replace either just location if base's location starts with a
766 * slash or otherwise everything */
767 process_case = (*base.pszSuffix == '/') ? 5 : 1;
768 break;
769 }
770 if ((*relative.pszSuffix == '/') && (*(relative.pszSuffix+1) == '/')) {
771 /* case where pszRelative replaces scheme, location,
772 * and following and handles PLUGGABLE
773 */
774 process_case = 2;
775 break;
776 }
777 process_case = 1;
778 break;
779 } while(FALSE); /* a little trick to allow easy exit from nested if's */
780
781 ret = S_OK;
782 switch (process_case) {
783
784 case 1: /*
785 * Return pszRelative appended to what ever is in pszCombined,
786 * (which may the string "file:///"
787 */
788 strcatW(preliminary, mrelative);
789 break;
790
791 case 2: /* case where pszRelative replaces scheme, and location */
792 strcpyW(preliminary, mrelative);
793 break;
794
795 case 3: /*
796 * Return the pszBase scheme with pszRelative. Basically
797 * keeps the scheme and replaces the domain and following.
798 */
799 memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1)*sizeof(WCHAR));
800 work = preliminary + base.cchProtocol + 1;
801 strcpyW(work, relative.pszSuffix);
802 break;
803
804 case 4: /*
805 * Return the pszBase scheme and location but everything
806 * after the location is pszRelative. (Replace document
807 * from root on.)
808 */
809 memcpy(preliminary, base.pszProtocol, (base.cchProtocol+1+sizeloc)*sizeof(WCHAR));
810 work = preliminary + base.cchProtocol + 1 + sizeloc;
811 if (dwFlags & URL_PLUGGABLE_PROTOCOL)
812 *(work++) = '/';
813 strcpyW(work, relative.pszSuffix);
814 break;
815
816 case 5: /*
817 * Return the pszBase without its document (if any) and
818 * append pszRelative after its scheme.
819 */
820 memcpy(preliminary, base.pszProtocol,
821 (base.cchProtocol+1+base.cchSuffix)*sizeof(WCHAR));
822 work = preliminary + base.cchProtocol+1+base.cchSuffix - 1;
823 if (*work++ != '/')
824 *(work++) = '/';
825 strcpyW(work, relative.pszSuffix);
826 break;
827
828 default:
829 FIXME("How did we get here????? process_case=%d\n", process_case);
830 ret = E_INVALIDARG;
831 }
832
833 if (ret == S_OK) {
834 /* Reuse mrelative as temp storage as its already allocated and not needed anymore */
835 ret = UrlCanonicalizeW(preliminary, mrelative, pcchCombined, (dwFlags & ~URL_FILE_USE_PATHURL));
836 if(SUCCEEDED(ret) && pszCombined) {
837 lstrcpyW(pszCombined, mrelative);
838 }
839 TRACE("return-%d len=%d, %s\n",
840 process_case, *pcchCombined, debugstr_w(pszCombined));
841 }
842 HeapFree(GetProcessHeap(), 0, preliminary);
843 return ret;
844 }
845
846 /*************************************************************************
847 * UrlEscapeA [SHLWAPI.@]
848 */
849
850 HRESULT WINAPI UrlEscapeA(
851 LPCSTR pszUrl,
852 LPSTR pszEscaped,
853 LPDWORD pcchEscaped,
854 DWORD dwFlags)
855 {
856 WCHAR bufW[INTERNET_MAX_URL_LENGTH];
857 WCHAR *escapedW = bufW;
858 UNICODE_STRING urlW;
859 HRESULT ret;
860 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
861
862 if (!pszEscaped || !pcchEscaped || !*pcchEscaped)
863 return E_INVALIDARG;
864
865 if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl))
866 return E_INVALIDARG;
867 if((ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags)) == E_POINTER) {
868 escapedW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
869 ret = UrlEscapeW(urlW.Buffer, escapedW, &lenW, dwFlags);
870 }
871 if(ret == S_OK) {
872 RtlUnicodeToMultiByteSize(&lenA, escapedW, lenW * sizeof(WCHAR));
873 if(*pcchEscaped > lenA) {
874 RtlUnicodeToMultiByteN(pszEscaped, *pcchEscaped - 1, &lenA, escapedW, lenW * sizeof(WCHAR));
875 pszEscaped[lenA] = 0;
876 *pcchEscaped = lenA;
877 } else {
878 *pcchEscaped = lenA + 1;
879 ret = E_POINTER;
880 }
881 }
882 if(escapedW != bufW) HeapFree(GetProcessHeap(), 0, escapedW);
883 RtlFreeUnicodeString(&urlW);
884 return ret;
885 }
886
887 #define WINE_URL_BASH_AS_SLASH 0x01
888 #define WINE_URL_COLLAPSE_SLASHES 0x02
889 #define WINE_URL_ESCAPE_SLASH 0x04
890 #define WINE_URL_ESCAPE_HASH 0x08
891 #define WINE_URL_ESCAPE_QUESTION 0x10
892 #define WINE_URL_STOP_ON_HASH 0x20
893 #define WINE_URL_STOP_ON_QUESTION 0x40
894
895 static inline BOOL URL_NeedEscapeW(WCHAR ch, DWORD dwFlags, DWORD int_flags)
896 {
897
898 if (isalnumW(ch))
899 return FALSE;
900
901 if(dwFlags & URL_ESCAPE_SPACES_ONLY) {
902 if(ch == ' ')
903 return TRUE;
904 else
905 return FALSE;
906 }
907
908 if ((dwFlags & URL_ESCAPE_PERCENT) && (ch == '%'))
909 return TRUE;
910
911 if (ch <= 31 || ch >= 127)
912 return TRUE;
913
914 else {
915 switch (ch) {
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 case '&':
929 return TRUE;
930
931 case '/':
932 if (int_flags & WINE_URL_ESCAPE_SLASH) return TRUE;
933 return FALSE;
934
935 case '?':
936 if (int_flags & WINE_URL_ESCAPE_QUESTION) return TRUE;
937 return FALSE;
938
939 case '#':
940 if (int_flags & WINE_URL_ESCAPE_HASH) return TRUE;
941 return FALSE;
942
943 default:
944 return FALSE;
945 }
946 }
947 }
948
949
950 /*************************************************************************
951 * UrlEscapeW [SHLWAPI.@]
952 *
953 * Converts unsafe characters in a Url into escape sequences.
954 *
955 * PARAMS
956 * pszUrl [I] Url to modify
957 * pszEscaped [O] Destination for modified Url
958 * pcchEscaped [I/O] Length of pszUrl, destination for length of pszEscaped
959 * dwFlags [I] URL_ flags from "shlwapi.h"
960 *
961 * RETURNS
962 * Success: S_OK. pszEscaped contains the escaped Url, pcchEscaped
963 * contains its length.
964 * Failure: E_POINTER, if pszEscaped is not large enough. In this case
965 * pcchEscaped is set to the required length.
966 *
967 * Converts unsafe characters into their escape sequences.
968 *
969 * NOTES
970 * - By default this function stops converting at the first '?' or
971 * '#' character.
972 * - If dwFlags contains URL_ESCAPE_SPACES_ONLY then only spaces are
973 * converted, but the conversion continues past a '?' or '#'.
974 * - Note that this function did not work well (or at all) in shlwapi version 4.
975 *
976 * BUGS
977 * Only the following flags are implemented:
978 *| URL_ESCAPE_SPACES_ONLY
979 *| URL_DONT_ESCAPE_EXTRA_INFO
980 *| URL_ESCAPE_SEGMENT_ONLY
981 *| URL_ESCAPE_PERCENT
982 */
983 HRESULT WINAPI UrlEscapeW(
984 LPCWSTR pszUrl,
985 LPWSTR pszEscaped,
986 LPDWORD pcchEscaped,
987 DWORD dwFlags)
988 {
989 LPCWSTR src;
990 DWORD needed = 0, ret;
991 BOOL stop_escaping = FALSE;
992 WCHAR next[5], *dst = pszEscaped;
993 INT len;
994 PARSEDURLW parsed_url;
995 DWORD int_flags;
996 DWORD slashes = 0;
997 static const WCHAR localhost[] = {'l','o','c','a','l','h','o','s','t',0};
998
999 TRACE("(%s %p %p 0x%08x)\n", debugstr_w(pszUrl), pszEscaped,
1000 pcchEscaped, dwFlags);
1001
1002 if(!pszUrl || !pcchEscaped)
1003 return E_INVALIDARG;
1004
1005 if(dwFlags & ~(URL_ESCAPE_SPACES_ONLY |
1006 URL_ESCAPE_SEGMENT_ONLY |
1007 URL_DONT_ESCAPE_EXTRA_INFO |
1008 URL_ESCAPE_PERCENT))
1009 FIXME("Unimplemented flags: %08x\n", dwFlags);
1010
1011 /* fix up flags */
1012 if (dwFlags & URL_ESCAPE_SPACES_ONLY)
1013 /* if SPACES_ONLY specified, reset the other controls */
1014 dwFlags &= ~(URL_DONT_ESCAPE_EXTRA_INFO |
1015 URL_ESCAPE_PERCENT |
1016 URL_ESCAPE_SEGMENT_ONLY);
1017
1018 else
1019 /* if SPACES_ONLY *not* specified the assume DONT_ESCAPE_EXTRA_INFO */
1020 dwFlags |= URL_DONT_ESCAPE_EXTRA_INFO;
1021
1022
1023 int_flags = 0;
1024 if(dwFlags & URL_ESCAPE_SEGMENT_ONLY) {
1025 int_flags = WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH | WINE_URL_ESCAPE_SLASH;
1026 } else {
1027 parsed_url.cbSize = sizeof(parsed_url);
1028 if(ParseURLW(pszUrl, &parsed_url) != S_OK)
1029 parsed_url.nScheme = URL_SCHEME_INVALID;
1030
1031 TRACE("scheme = %d (%s)\n", parsed_url.nScheme, debugstr_wn(parsed_url.pszProtocol, parsed_url.cchProtocol));
1032
1033 if(dwFlags & URL_DONT_ESCAPE_EXTRA_INFO)
1034 int_flags = WINE_URL_STOP_ON_HASH | WINE_URL_STOP_ON_QUESTION;
1035
1036 switch(parsed_url.nScheme) {
1037 case URL_SCHEME_FILE:
1038 int_flags |= WINE_URL_BASH_AS_SLASH | WINE_URL_COLLAPSE_SLASHES | WINE_URL_ESCAPE_HASH;
1039 int_flags &= ~WINE_URL_STOP_ON_HASH;
1040 break;
1041
1042 case URL_SCHEME_HTTP:
1043 case URL_SCHEME_HTTPS:
1044 int_flags |= WINE_URL_BASH_AS_SLASH;
1045 if(parsed_url.pszSuffix[0] != '/' && parsed_url.pszSuffix[0] != '\\')
1046 int_flags |= WINE_URL_ESCAPE_SLASH;
1047 break;
1048
1049 case URL_SCHEME_MAILTO:
1050 int_flags |= WINE_URL_ESCAPE_SLASH | WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH;
1051 int_flags &= ~(WINE_URL_STOP_ON_QUESTION | WINE_URL_STOP_ON_HASH);
1052 break;
1053
1054 case URL_SCHEME_INVALID:
1055 break;
1056
1057 case URL_SCHEME_FTP:
1058 default:
1059 if(parsed_url.pszSuffix[0] != '/')
1060 int_flags |= WINE_URL_ESCAPE_SLASH;
1061 break;
1062 }
1063 }
1064
1065 for(src = pszUrl; *src; ) {
1066 WCHAR cur = *src;
1067 len = 0;
1068
1069 if((int_flags & WINE_URL_COLLAPSE_SLASHES) && src == pszUrl + parsed_url.cchProtocol + 1) {
1070 int localhost_len = sizeof(localhost)/sizeof(WCHAR) - 1;
1071 while(cur == '/' || cur == '\\') {
1072 slashes++;
1073 cur = *++src;
1074 }
1075 if(slashes == 2 && !strncmpiW(src, localhost, localhost_len)) { /* file://localhost/ -> file:/// */
1076 if(*(src + localhost_len) == '/' || *(src + localhost_len) == '\\')
1077 src += localhost_len + 1;
1078 slashes = 3;
1079 }
1080
1081 switch(slashes) {
1082 case 1:
1083 case 3:
1084 next[0] = next[1] = next[2] = '/';
1085 len = 3;
1086 break;
1087 case 0:
1088 len = 0;
1089 break;
1090 default:
1091 next[0] = next[1] = '/';
1092 len = 2;
1093 break;
1094 }
1095 }
1096 if(len == 0) {
1097
1098 if(cur == '#' && (int_flags & WINE_URL_STOP_ON_HASH))
1099 stop_escaping = TRUE;
1100
1101 if(cur == '?' && (int_flags & WINE_URL_STOP_ON_QUESTION))
1102 stop_escaping = TRUE;
1103
1104 if(cur == '\\' && (int_flags & WINE_URL_BASH_AS_SLASH) && !stop_escaping) cur = '/';
1105
1106 if(URL_NeedEscapeW(cur, dwFlags, int_flags) && stop_escaping == FALSE) {
1107 next[0] = '%';
1108 next[1] = hexDigits[(cur >> 4) & 0xf];
1109 next[2] = hexDigits[cur & 0xf];
1110 len = 3;
1111 } else {
1112 next[0] = cur;
1113 len = 1;
1114 }
1115 src++;
1116 }
1117
1118 if(needed + len <= *pcchEscaped) {
1119 memcpy(dst, next, len*sizeof(WCHAR));
1120 dst += len;
1121 }
1122 needed += len;
1123 }
1124
1125 if(needed < *pcchEscaped) {
1126 *dst = '\0';
1127 ret = S_OK;
1128 } else {
1129 needed++; /* add one for the '\0' */
1130 ret = E_POINTER;
1131 }
1132 *pcchEscaped = needed;
1133 return ret;
1134 }
1135
1136
1137 /*************************************************************************
1138 * UrlUnescapeA [SHLWAPI.@]
1139 *
1140 * Converts Url escape sequences back to ordinary characters.
1141 *
1142 * PARAMS
1143 * pszUrl [I/O] Url to convert
1144 * pszUnescaped [O] Destination for converted Url
1145 * pcchUnescaped [I/O] Size of output string
1146 * dwFlags [I] URL_ESCAPE_ Flags from "shlwapi.h"
1147 *
1148 * RETURNS
1149 * Success: S_OK. The converted value is in pszUnescaped, or in pszUrl if
1150 * dwFlags includes URL_ESCAPE_INPLACE.
1151 * Failure: E_POINTER if the converted Url is bigger than pcchUnescaped. In
1152 * this case pcchUnescaped is set to the size required.
1153 * NOTES
1154 * If dwFlags includes URL_DONT_ESCAPE_EXTRA_INFO, the conversion stops at
1155 * the first occurrence of either a '?' or '#' character.
1156 */
1157 HRESULT WINAPI UrlUnescapeA(
1158 LPSTR pszUrl,
1159 LPSTR pszUnescaped,
1160 LPDWORD pcchUnescaped,
1161 DWORD dwFlags)
1162 {
1163 char *dst, next;
1164 LPCSTR src;
1165 HRESULT ret;
1166 DWORD needed;
1167 BOOL stop_unescaping = FALSE;
1168
1169 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_a(pszUrl), pszUnescaped,
1170 pcchUnescaped, dwFlags);
1171
1172 if (!pszUrl) return E_INVALIDARG;
1173
1174 if(dwFlags & URL_UNESCAPE_INPLACE)
1175 dst = pszUrl;
1176 else
1177 {
1178 if (!pszUnescaped || !pcchUnescaped) return E_INVALIDARG;
1179 dst = pszUnescaped;
1180 }
1181
1182 for(src = pszUrl, needed = 0; *src; src++, needed++) {
1183 if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1184 (*src == '#' || *src == '?')) {
1185 stop_unescaping = TRUE;
1186 next = *src;
1187 } else if(*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2))
1188 && stop_unescaping == FALSE) {
1189 INT ih;
1190 char buf[3];
1191 memcpy(buf, src + 1, 2);
1192 buf[2] = '\0';
1193 ih = strtol(buf, NULL, 16);
1194 next = (CHAR) ih;
1195 src += 2; /* Advance to end of escape */
1196 } else
1197 next = *src;
1198
1199 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1200 *dst++ = next;
1201 }
1202
1203 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1204 *dst = '\0';
1205 ret = S_OK;
1206 } else {
1207 needed++; /* add one for the '\0' */
1208 ret = E_POINTER;
1209 }
1210 if(!(dwFlags & URL_UNESCAPE_INPLACE))
1211 *pcchUnescaped = needed;
1212
1213 if (ret == S_OK) {
1214 TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1215 debugstr_a(pszUrl) : debugstr_a(pszUnescaped));
1216 }
1217
1218 return ret;
1219 }
1220
1221 /*************************************************************************
1222 * UrlUnescapeW [SHLWAPI.@]
1223 *
1224 * See UrlUnescapeA.
1225 */
1226 HRESULT WINAPI UrlUnescapeW(
1227 LPWSTR pszUrl,
1228 LPWSTR pszUnescaped,
1229 LPDWORD pcchUnescaped,
1230 DWORD dwFlags)
1231 {
1232 WCHAR *dst, next;
1233 LPCWSTR src;
1234 HRESULT ret;
1235 DWORD needed;
1236 BOOL stop_unescaping = FALSE;
1237
1238 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszUrl), pszUnescaped,
1239 pcchUnescaped, dwFlags);
1240
1241 if(!pszUrl) return E_INVALIDARG;
1242
1243 if(dwFlags & URL_UNESCAPE_INPLACE)
1244 dst = pszUrl;
1245 else
1246 {
1247 if (!pszUnescaped || !pcchUnescaped) return E_INVALIDARG;
1248 dst = pszUnescaped;
1249 }
1250
1251 for(src = pszUrl, needed = 0; *src; src++, needed++) {
1252 if(dwFlags & URL_DONT_UNESCAPE_EXTRA_INFO &&
1253 (*src == '#' || *src == '?')) {
1254 stop_unescaping = TRUE;
1255 next = *src;
1256 } else if(*src == '%' && isxdigitW(*(src + 1)) && isxdigitW(*(src + 2))
1257 && stop_unescaping == FALSE) {
1258 INT ih;
1259 WCHAR buf[5] = {'0','x',0};
1260 memcpy(buf + 2, src + 1, 2*sizeof(WCHAR));
1261 buf[4] = 0;
1262 StrToIntExW(buf, STIF_SUPPORT_HEX, &ih);
1263 next = (WCHAR) ih;
1264 src += 2; /* Advance to end of escape */
1265 } else
1266 next = *src;
1267
1268 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped)
1269 *dst++ = next;
1270 }
1271
1272 if(dwFlags & URL_UNESCAPE_INPLACE || needed < *pcchUnescaped) {
1273 *dst = '\0';
1274 ret = S_OK;
1275 } else {
1276 needed++; /* add one for the '\0' */
1277 ret = E_POINTER;
1278 }
1279 if(!(dwFlags & URL_UNESCAPE_INPLACE))
1280 *pcchUnescaped = needed;
1281
1282 if (ret == S_OK) {
1283 TRACE("result %s\n", (dwFlags & URL_UNESCAPE_INPLACE) ?
1284 debugstr_w(pszUrl) : debugstr_w(pszUnescaped));
1285 }
1286
1287 return ret;
1288 }
1289
1290 /*************************************************************************
1291 * UrlGetLocationA [SHLWAPI.@]
1292 *
1293 * Get the location from a Url.
1294 *
1295 * PARAMS
1296 * pszUrl [I] Url to get the location from
1297 *
1298 * RETURNS
1299 * A pointer to the start of the location in pszUrl, or NULL if there is
1300 * no location.
1301 *
1302 * NOTES
1303 * - MSDN erroneously states that "The location is the segment of the Url
1304 * starting with a '?' or '#' character". Neither V4 nor V5 of shlwapi.dll
1305 * stop at '?' and always return a NULL in this case.
1306 * - MSDN also erroneously states that "If a file URL has a query string,
1307 * the returned string is the query string". In all tested cases, if the
1308 * Url starts with "fi" then a NULL is returned. V5 gives the following results:
1309 *| Result Url
1310 *| ------ ---
1311 *| NULL file://aa/b/cd#hohoh
1312 *| #hohoh http://aa/b/cd#hohoh
1313 *| NULL fi://aa/b/cd#hohoh
1314 *| #hohoh ff://aa/b/cd#hohoh
1315 */
1316 LPCSTR WINAPI UrlGetLocationA(
1317 LPCSTR pszUrl)
1318 {
1319 PARSEDURLA base;
1320 DWORD res1;
1321
1322 base.cbSize = sizeof(base);
1323 res1 = ParseURLA(pszUrl, &base);
1324 if (res1) return NULL; /* invalid scheme */
1325
1326 /* if scheme is file: then never return pointer */
1327 if (strncmp(base.pszProtocol, "file", min(4,base.cchProtocol)) == 0) return NULL;
1328
1329 /* Look for '#' and return its addr */
1330 return strchr(base.pszSuffix, '#');
1331 }
1332
1333 /*************************************************************************
1334 * UrlGetLocationW [SHLWAPI.@]
1335 *
1336 * See UrlGetLocationA.
1337 */
1338 LPCWSTR WINAPI UrlGetLocationW(
1339 LPCWSTR pszUrl)
1340 {
1341 PARSEDURLW base;
1342 DWORD res1;
1343
1344 base.cbSize = sizeof(base);
1345 res1 = ParseURLW(pszUrl, &base);
1346 if (res1) return NULL; /* invalid scheme */
1347
1348 /* if scheme is file: then never return pointer */
1349 if (strncmpW(base.pszProtocol, fileW, min(4,base.cchProtocol)) == 0) return NULL;
1350
1351 /* Look for '#' and return its addr */
1352 return strchrW(base.pszSuffix, '#');
1353 }
1354
1355 /*************************************************************************
1356 * UrlCompareA [SHLWAPI.@]
1357 *
1358 * Compare two Urls.
1359 *
1360 * PARAMS
1361 * pszUrl1 [I] First Url to compare
1362 * pszUrl2 [I] Url to compare to pszUrl1
1363 * fIgnoreSlash [I] TRUE = compare only up to a final slash
1364 *
1365 * RETURNS
1366 * less than zero, zero, or greater than zero indicating pszUrl2 is greater
1367 * than, equal to, or less than pszUrl1 respectively.
1368 */
1369 INT WINAPI UrlCompareA(
1370 LPCSTR pszUrl1,
1371 LPCSTR pszUrl2,
1372 BOOL fIgnoreSlash)
1373 {
1374 INT ret, len, len1, len2;
1375
1376 if (!fIgnoreSlash)
1377 return strcmp(pszUrl1, pszUrl2);
1378 len1 = strlen(pszUrl1);
1379 if (pszUrl1[len1-1] == '/') len1--;
1380 len2 = strlen(pszUrl2);
1381 if (pszUrl2[len2-1] == '/') len2--;
1382 if (len1 == len2)
1383 return strncmp(pszUrl1, pszUrl2, len1);
1384 len = min(len1, len2);
1385 ret = strncmp(pszUrl1, pszUrl2, len);
1386 if (ret) return ret;
1387 if (len1 > len2) return 1;
1388 return -1;
1389 }
1390
1391 /*************************************************************************
1392 * UrlCompareW [SHLWAPI.@]
1393 *
1394 * See UrlCompareA.
1395 */
1396 INT WINAPI UrlCompareW(
1397 LPCWSTR pszUrl1,
1398 LPCWSTR pszUrl2,
1399 BOOL fIgnoreSlash)
1400 {
1401 INT ret;
1402 size_t len, len1, len2;
1403
1404 if (!fIgnoreSlash)
1405 return strcmpW(pszUrl1, pszUrl2);
1406 len1 = strlenW(pszUrl1);
1407 if (pszUrl1[len1-1] == '/') len1--;
1408 len2 = strlenW(pszUrl2);
1409 if (pszUrl2[len2-1] == '/') len2--;
1410 if (len1 == len2)
1411 return strncmpW(pszUrl1, pszUrl2, len1);
1412 len = min(len1, len2);
1413 ret = strncmpW(pszUrl1, pszUrl2, len);
1414 if (ret) return ret;
1415 if (len1 > len2) return 1;
1416 return -1;
1417 }
1418
1419 /*************************************************************************
1420 * HashData [SHLWAPI.@]
1421 *
1422 * Hash an input block into a variable sized digest.
1423 *
1424 * PARAMS
1425 * lpSrc [I] Input block
1426 * nSrcLen [I] Length of lpSrc
1427 * lpDest [I] Output for hash digest
1428 * nDestLen [I] Length of lpDest
1429 *
1430 * RETURNS
1431 * Success: TRUE. lpDest is filled with the computed hash value.
1432 * Failure: FALSE, if any argument is invalid.
1433 */
1434 HRESULT WINAPI HashData(const unsigned char *lpSrc, DWORD nSrcLen,
1435 unsigned char *lpDest, DWORD nDestLen)
1436 {
1437 INT srcCount = nSrcLen - 1, destCount = nDestLen - 1;
1438
1439 if (!lpSrc || !lpDest)
1440 return E_INVALIDARG;
1441
1442 while (destCount >= 0)
1443 {
1444 lpDest[destCount] = (destCount & 0xff);
1445 destCount--;
1446 }
1447
1448 while (srcCount >= 0)
1449 {
1450 destCount = nDestLen - 1;
1451 while (destCount >= 0)
1452 {
1453 lpDest[destCount] = HashDataLookup[lpSrc[srcCount] ^ lpDest[destCount]];
1454 destCount--;
1455 }
1456 srcCount--;
1457 }
1458 return S_OK;
1459 }
1460
1461 /*************************************************************************
1462 * UrlHashA [SHLWAPI.@]
1463 *
1464 * Produce a Hash from a Url.
1465 *
1466 * PARAMS
1467 * pszUrl [I] Url to hash
1468 * lpDest [O] Destinationh for hash
1469 * nDestLen [I] Length of lpDest
1470 *
1471 * RETURNS
1472 * Success: S_OK. lpDest is filled with the computed hash value.
1473 * Failure: E_INVALIDARG, if any argument is invalid.
1474 */
1475 HRESULT WINAPI UrlHashA(LPCSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1476 {
1477 if (IsBadStringPtrA(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1478 return E_INVALIDARG;
1479
1480 HashData((const BYTE*)pszUrl, (int)strlen(pszUrl), lpDest, nDestLen);
1481 return S_OK;
1482 }
1483
1484 /*************************************************************************
1485 * UrlHashW [SHLWAPI.@]
1486 *
1487 * See UrlHashA.
1488 */
1489 HRESULT WINAPI UrlHashW(LPCWSTR pszUrl, unsigned char *lpDest, DWORD nDestLen)
1490 {
1491 char szUrl[MAX_PATH];
1492
1493 TRACE("(%s,%p,%d)\n",debugstr_w(pszUrl), lpDest, nDestLen);
1494
1495 if (IsBadStringPtrW(pszUrl, -1) || IsBadWritePtr(lpDest, nDestLen))
1496 return E_INVALIDARG;
1497
1498 /* Win32 hashes the data as an ASCII string, presumably so that both A+W
1499 * return the same digests for the same URL.
1500 */
1501 WideCharToMultiByte(0, 0, pszUrl, -1, szUrl, MAX_PATH, 0, 0);
1502 HashData((const BYTE*)szUrl, (int)strlen(szUrl), lpDest, nDestLen);
1503 return S_OK;
1504 }
1505
1506 /*************************************************************************
1507 * UrlApplySchemeA [SHLWAPI.@]
1508 *
1509 * Apply a scheme to a Url.
1510 *
1511 * PARAMS
1512 * pszIn [I] Url to apply scheme to
1513 * pszOut [O] Destination for modified Url
1514 * pcchOut [I/O] Length of pszOut/destination for length of pszOut
1515 * dwFlags [I] URL_ flags from "shlwapi.h"
1516 *
1517 * RETURNS
1518 * Success: S_OK: pszOut contains the modified Url, pcchOut contains its length.
1519 * Failure: An HRESULT error code describing the error.
1520 */
1521 HRESULT WINAPI UrlApplySchemeA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1522 {
1523 LPWSTR in, out;
1524 HRESULT ret;
1525 DWORD len;
1526
1527 TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_a(pszIn),
1528 pszOut, pcchOut, pcchOut ? *pcchOut : 0, dwFlags);
1529
1530 if (!pszIn || !pszOut || !pcchOut) return E_INVALIDARG;
1531
1532 in = HeapAlloc(GetProcessHeap(), 0,
1533 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
1534 out = in + INTERNET_MAX_URL_LENGTH;
1535
1536 MultiByteToWideChar(CP_ACP, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
1537 len = INTERNET_MAX_URL_LENGTH;
1538
1539 ret = UrlApplySchemeW(in, out, &len, dwFlags);
1540 if (ret != S_OK) {
1541 HeapFree(GetProcessHeap(), 0, in);
1542 return ret;
1543 }
1544
1545 len = WideCharToMultiByte(CP_ACP, 0, out, -1, NULL, 0, NULL, NULL);
1546 if (len > *pcchOut) {
1547 ret = E_POINTER;
1548 goto cleanup;
1549 }
1550
1551 WideCharToMultiByte(CP_ACP, 0, out, -1, pszOut, *pcchOut, NULL, NULL);
1552 len--;
1553
1554 cleanup:
1555 *pcchOut = len;
1556 HeapFree(GetProcessHeap(), 0, in);
1557 return ret;
1558 }
1559
1560 static HRESULT URL_GuessScheme(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1561 {
1562 HKEY newkey;
1563 BOOL j;
1564 INT index;
1565 DWORD value_len, data_len, dwType, i;
1566 WCHAR reg_path[MAX_PATH];
1567 WCHAR value[MAX_PATH], data[MAX_PATH];
1568 WCHAR Wxx, Wyy;
1569
1570 MultiByteToWideChar(0, 0,
1571 "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes",
1572 -1, reg_path, MAX_PATH);
1573 RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_path, 0, 1, &newkey);
1574 index = 0;
1575 while(value_len = data_len = MAX_PATH,
1576 RegEnumValueW(newkey, index, value, &value_len,
1577 0, &dwType, (LPVOID)data, &data_len) == 0) {
1578 TRACE("guess %d %s is %s\n",
1579 index, debugstr_w(value), debugstr_w(data));
1580
1581 j = FALSE;
1582 for(i=0; i<value_len; i++) {
1583 Wxx = pszIn[i];
1584 Wyy = value[i];
1585 /* remember that TRUE is not-equal */
1586 j = ChrCmpIW(Wxx, Wyy);
1587 if (j) break;
1588 }
1589 if ((i == value_len) && !j) {
1590 if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1591 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1592 RegCloseKey(newkey);
1593 return E_POINTER;
1594 }
1595 strcpyW(pszOut, data);
1596 strcatW(pszOut, pszIn);
1597 *pcchOut = strlenW(pszOut);
1598 TRACE("matched and set to %s\n", debugstr_w(pszOut));
1599 RegCloseKey(newkey);
1600 return S_OK;
1601 }
1602 index++;
1603 }
1604 RegCloseKey(newkey);
1605 return E_FAIL;
1606 }
1607
1608 static HRESULT URL_ApplyDefault(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut)
1609 {
1610 HKEY newkey;
1611 DWORD data_len, dwType;
1612 WCHAR data[MAX_PATH];
1613
1614 static const WCHAR prefix_keyW[] =
1615 {'S','o','f','t','w','a','r','e',
1616 '\\','M','i','c','r','o','s','o','f','t',
1617 '\\','W','i','n','d','o','w','s',
1618 '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
1619 '\\','U','R','L',
1620 '\\','D','e','f','a','u','l','t','P','r','e','f','i','x',0};
1621
1622 /* get and prepend default */
1623 RegOpenKeyExW(HKEY_LOCAL_MACHINE, prefix_keyW, 0, 1, &newkey);
1624 data_len = sizeof(data);
1625 RegQueryValueExW(newkey, NULL, 0, &dwType, (LPBYTE)data, &data_len);
1626 RegCloseKey(newkey);
1627 if (strlenW(data) + strlenW(pszIn) + 1 > *pcchOut) {
1628 *pcchOut = strlenW(data) + strlenW(pszIn) + 1;
1629 return E_POINTER;
1630 }
1631 strcpyW(pszOut, data);
1632 strcatW(pszOut, pszIn);
1633 *pcchOut = strlenW(pszOut);
1634 TRACE("used default %s\n", debugstr_w(pszOut));
1635 return S_OK;
1636 }
1637
1638 /*************************************************************************
1639 * UrlApplySchemeW [SHLWAPI.@]
1640 *
1641 * See UrlApplySchemeA.
1642 */
1643 HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
1644 {
1645 PARSEDURLW in_scheme;
1646 DWORD res1;
1647 HRESULT ret;
1648
1649 TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_w(pszIn),
1650 pszOut, pcchOut, pcchOut ? *pcchOut : 0, dwFlags);
1651
1652 if (!pszIn || !pszOut || !pcchOut) return E_INVALIDARG;
1653
1654 if (dwFlags & URL_APPLY_GUESSFILE) {
1655 FIXME("(%s %p %p(%d) 0x%08x): stub URL_APPLY_GUESSFILE not implemented\n",
1656 debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwFlags);
1657 strcpyW(pszOut, pszIn);
1658 *pcchOut = strlenW(pszOut);
1659 return S_FALSE;
1660 }
1661
1662 in_scheme.cbSize = sizeof(in_scheme);
1663 /* See if the base has a scheme */
1664 res1 = ParseURLW(pszIn, &in_scheme);
1665 if (res1) {
1666 /* no scheme in input, need to see if we need to guess */
1667 if (dwFlags & URL_APPLY_GUESSSCHEME) {
1668 if ((ret = URL_GuessScheme(pszIn, pszOut, pcchOut)) != E_FAIL)
1669 return ret;
1670 }
1671 }
1672 else {
1673 /* we have a scheme, see if valid (known scheme) */
1674 if (in_scheme.nScheme) {
1675 /* have valid scheme, so just copy and exit */
1676 if (strlenW(pszIn) + 1 > *pcchOut) {
1677 *pcchOut = strlenW(pszIn) + 1;
1678 return E_POINTER;
1679 }
1680 strcpyW(pszOut, pszIn);
1681 *pcchOut = strlenW(pszOut);
1682 TRACE("valid scheme, returning copy\n");
1683 return S_OK;
1684 }
1685 }
1686
1687 /* If we are here, then either invalid scheme,
1688 * or no scheme and can't/failed guess.
1689 */
1690 if ( ( ((res1 == 0) && (dwFlags & URL_APPLY_FORCEAPPLY)) ||
1691 ((res1 != 0)) ) &&
1692 (dwFlags & URL_APPLY_DEFAULT)) {
1693 /* find and apply default scheme */
1694 return URL_ApplyDefault(pszIn, pszOut, pcchOut);
1695 }
1696
1697 return S_FALSE;
1698 }
1699
1700 /*************************************************************************
1701 * UrlIsA [SHLWAPI.@]
1702 *
1703 * Determine if a Url is of a certain class.
1704 *
1705 * PARAMS
1706 * pszUrl [I] Url to check
1707 * Urlis [I] URLIS_ constant from "shlwapi.h"
1708 *
1709 * RETURNS
1710 * TRUE if pszUrl belongs to the class type in Urlis.
1711 * FALSE Otherwise.
1712 */
1713 BOOL WINAPI UrlIsA(LPCSTR pszUrl, URLIS Urlis)
1714 {
1715 PARSEDURLA base;
1716 DWORD res1;
1717 LPCSTR last;
1718
1719 TRACE("(%s %d)\n", debugstr_a(pszUrl), Urlis);
1720
1721 switch (Urlis) {
1722
1723 case URLIS_OPAQUE:
1724 base.cbSize = sizeof(base);
1725 res1 = ParseURLA(pszUrl, &base);
1726 if (res1) return FALSE; /* invalid scheme */
1727 switch (base.nScheme)
1728 {
1729 case URL_SCHEME_MAILTO:
1730 case URL_SCHEME_SHELL:
1731 case URL_SCHEME_JAVASCRIPT:
1732 case URL_SCHEME_VBSCRIPT:
1733 case URL_SCHEME_ABOUT:
1734 return TRUE;
1735 }
1736 return FALSE;
1737
1738 case URLIS_FILEURL:
1739 return !StrCmpNA("file:", pszUrl, 5);
1740
1741 case URLIS_DIRECTORY:
1742 last = pszUrl + strlen(pszUrl) - 1;
1743 return (last >= pszUrl && (*last == '/' || *last == '\\' ));
1744
1745 case URLIS_URL:
1746 return PathIsURLA(pszUrl);
1747
1748 case URLIS_NOHISTORY:
1749 case URLIS_APPLIABLE:
1750 case URLIS_HASQUERY:
1751 default:
1752 FIXME("(%s %d): stub\n", debugstr_a(pszUrl), Urlis);
1753 }
1754 return FALSE;
1755 }
1756
1757 /*************************************************************************
1758 * UrlIsW [SHLWAPI.@]
1759 *
1760 * See UrlIsA.
1761 */
1762 BOOL WINAPI UrlIsW(LPCWSTR pszUrl, URLIS Urlis)
1763 {
1764 static const WCHAR stemp[] = { 'f','i','l','e',':',0 };
1765 PARSEDURLW base;
1766 DWORD res1;
1767 LPCWSTR last;
1768
1769 TRACE("(%s %d)\n", debugstr_w(pszUrl), Urlis);
1770
1771 switch (Urlis) {
1772
1773 case URLIS_OPAQUE:
1774 base.cbSize = sizeof(base);
1775 res1 = ParseURLW(pszUrl, &base);
1776 if (res1) return FALSE; /* invalid scheme */
1777 switch (base.nScheme)
1778 {
1779 case URL_SCHEME_MAILTO:
1780 case URL_SCHEME_SHELL:
1781 case URL_SCHEME_JAVASCRIPT:
1782 case URL_SCHEME_VBSCRIPT:
1783 case URL_SCHEME_ABOUT:
1784 return TRUE;
1785 }
1786 return FALSE;
1787
1788 case URLIS_FILEURL:
1789 return !strncmpW(stemp, pszUrl, 5);
1790
1791 case URLIS_DIRECTORY:
1792 last = pszUrl + strlenW(pszUrl) - 1;
1793 return (last >= pszUrl && (*last == '/' || *last == '\\'));
1794
1795 case URLIS_URL:
1796 return PathIsURLW(pszUrl);
1797
1798 case URLIS_NOHISTORY:
1799 case URLIS_APPLIABLE:
1800 case URLIS_HASQUERY:
1801 default:
1802 FIXME("(%s %d): stub\n", debugstr_w(pszUrl), Urlis);
1803 }
1804 return FALSE;
1805 }
1806
1807 /*************************************************************************
1808 * UrlIsNoHistoryA [SHLWAPI.@]
1809 *
1810 * Determine if a Url should not be stored in the users history list.
1811 *
1812 * PARAMS
1813 * pszUrl [I] Url to check
1814 *
1815 * RETURNS
1816 * TRUE, if pszUrl should be excluded from the history list,
1817 * FALSE otherwise.
1818 */
1819 BOOL WINAPI UrlIsNoHistoryA(LPCSTR pszUrl)
1820 {
1821 return UrlIsA(pszUrl, URLIS_NOHISTORY);
1822 }
1823
1824 /*************************************************************************
1825 * UrlIsNoHistoryW [SHLWAPI.@]
1826 *
1827 * See UrlIsNoHistoryA.
1828 */
1829 BOOL WINAPI UrlIsNoHistoryW(LPCWSTR pszUrl)
1830 {
1831 return UrlIsW(pszUrl, URLIS_NOHISTORY);
1832 }
1833
1834 /*************************************************************************
1835 * UrlIsOpaqueA [SHLWAPI.@]
1836 *
1837 * Determine if a Url is opaque.
1838 *
1839 * PARAMS
1840 * pszUrl [I] Url to check
1841 *
1842 * RETURNS
1843 * TRUE if pszUrl is opaque,
1844 * FALSE Otherwise.
1845 *
1846 * NOTES
1847 * An opaque Url is one that does not start with "<protocol>://".
1848 */
1849 BOOL WINAPI UrlIsOpaqueA(LPCSTR pszUrl)
1850 {
1851 return UrlIsA(pszUrl, URLIS_OPAQUE);
1852 }
1853
1854 /*************************************************************************
1855 * UrlIsOpaqueW [SHLWAPI.@]
1856 *
1857 * See UrlIsOpaqueA.
1858 */
1859 BOOL WINAPI UrlIsOpaqueW(LPCWSTR pszUrl)
1860 {
1861 return UrlIsW(pszUrl, URLIS_OPAQUE);
1862 }
1863
1864 /*************************************************************************
1865 * Scans for characters of type "type" and when not matching found,
1866 * returns pointer to it and length in size.
1867 *
1868 * Characters tested based on RFC 1738
1869 */
1870 static LPCWSTR URL_ScanID(LPCWSTR start, LPDWORD size, WINE_URL_SCAN_TYPE type)
1871 {
1872 static DWORD alwayszero = 0;
1873 BOOL cont = TRUE;
1874
1875 *size = 0;
1876
1877 switch(type){
1878
1879 case SCHEME:
1880 while (cont) {
1881 if ( (islowerW(*start) && isalphaW(*start)) ||
1882 isdigitW(*start) ||
1883 (*start == '+') ||
1884 (*start == '-') ||
1885 (*start == '.')) {
1886 start++;
1887 (*size)++;
1888 }
1889 else
1890 cont = FALSE;
1891 }
1892 break;
1893
1894 case USERPASS:
1895 while (cont) {
1896 if ( isalphaW(*start) ||
1897 isdigitW(*start) ||
1898 /* user/password only characters */
1899 (*start == ';') ||
1900 (*start == '?') ||
1901 (*start == '&') ||
1902 (*start == '=') ||
1903 /* *extra* characters */
1904 (*start == '!') ||
1905 (*start == '*') ||
1906 (*start == '\'') ||
1907 (*start == '(') ||
1908 (*start == ')') ||
1909 (*start == ',') ||
1910 /* *safe* characters */
1911 (*start == '$') ||
1912 (*start == '_') ||
1913 (*start == '+') ||
1914 (*start == '-') ||
1915 (*start == '.') ||
1916 (*start == ' ')) {
1917 start++;
1918 (*size)++;
1919 } else if (*start == '%') {
1920 if (isxdigitW(*(start+1)) &&
1921 isxdigitW(*(start+2))) {
1922 start += 3;
1923 *size += 3;
1924 } else
1925 cont = FALSE;
1926 } else
1927 cont = FALSE;
1928 }
1929 break;
1930
1931 case PORT:
1932 while (cont) {
1933 if (isdigitW(*start)) {
1934 start++;
1935 (*size)++;
1936 }
1937 else
1938 cont = FALSE;
1939 }
1940 break;
1941
1942 case HOST:
1943 while (cont) {
1944 if (isalnumW(*start) ||
1945 (*start == '-') ||
1946 (*start == '.') ||
1947 (*start == ' ') ) {
1948 start++;
1949 (*size)++;
1950 }
1951 else
1952 cont = FALSE;
1953 }
1954 break;
1955 default:
1956 FIXME("unknown type %d\n", type);
1957 return (LPWSTR)&alwayszero;
1958 }
1959 /* TRACE("scanned %d characters next char %p<%c>\n",
1960 *size, start, *start); */
1961 return start;
1962 }
1963
1964 /*************************************************************************
1965 * Attempt to parse URL into pieces.
1966 */
1967 static LONG URL_ParseUrl(LPCWSTR pszUrl, WINE_PARSE_URL *pl)
1968 {
1969 LPCWSTR work;
1970
1971 memset(pl, 0, sizeof(WINE_PARSE_URL));
1972 pl->pScheme = pszUrl;
1973 work = URL_ScanID(pl->pScheme, &pl->szScheme, SCHEME);
1974 if (!*work || (*work != ':')) goto ErrorExit;
1975 work++;
1976 if ((*work != '/') || (*(work+1) != '/')) goto SuccessExit;
1977 pl->pUserName = work + 2;
1978 work = URL_ScanID(pl->pUserName, &pl->szUserName, USERPASS);
1979 if (*work == ':' ) {
1980 /* parse password */
1981 work++;
1982 pl->pPassword = work;
1983 work = URL_ScanID(pl->pPassword, &pl->szPassword, USERPASS);
1984 if (*work != '@') {
1985 /* what we just parsed must be the hostname and port
1986 * so reset pointers and clear then let it parse */
1987 pl->szUserName = pl->szPassword = 0;
1988 work = pl->pUserName - 1;
1989 pl->pUserName = pl->pPassword = 0;
1990 }
1991 } else if (*work == '@') {
1992 /* no password */
1993 pl->szPassword = 0;
1994 pl->pPassword = 0;
1995 } else if (!*work || (*work == '/') || (*work == '.')) {
1996 /* what was parsed was hostname, so reset pointers and let it parse */
1997 pl->szUserName = pl->szPassword = 0;
1998 work = pl->pUserName - 1;
1999 pl->pUserName = pl->pPassword = 0;
2000 } else goto ErrorExit;
2001
2002 /* now start parsing hostname or hostnumber */
2003 work++;
2004 pl->pHostName = work;
2005 work = URL_ScanID(pl->pHostName, &pl->szHostName, HOST);
2006 if (*work == ':') {
2007 /* parse port */
2008 work++;
2009 pl->pPort = work;
2010 work = URL_ScanID(pl->pPort, &pl->szPort, PORT);
2011 }
2012 if (*work == '/') {
2013 /* see if query string */
2014 pl->pQuery = strchrW(work, '?');
2015 if (pl->pQuery) pl->szQuery = strlenW(pl->pQuery);
2016 }
2017 SuccessExit:
2018 TRACE("parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
2019 pl->pScheme, pl->szScheme,
2020 pl->pUserName, pl->szUserName,
2021 pl->pPassword, pl->szPassword,
2022 pl->pHostName, pl->szHostName,
2023 pl->pPort, pl->szPort,
2024 pl->pQuery, pl->szQuery);
2025 return S_OK;
2026 ErrorExit:
2027 FIXME("failed to parse %s\n", debugstr_w(pszUrl));
2028 return E_INVALIDARG;
2029 }
2030
2031 /*************************************************************************
2032 * UrlGetPartA [SHLWAPI.@]
2033 *
2034 * Retrieve part of a Url.
2035 *
2036 * PARAMS
2037 * pszIn [I] Url to parse
2038 * pszOut [O] Destination for part of pszIn requested
2039 * pcchOut [I] Size of pszOut
2040 * [O] length of pszOut string EXCLUDING '\0' if S_OK, otherwise
2041 * needed size of pszOut INCLUDING '\0'.
2042 * dwPart [I] URL_PART_ enum from "shlwapi.h"
2043 * dwFlags [I] URL_ flags from "shlwapi.h"
2044 *
2045 * RETURNS
2046 * Success: S_OK. pszOut contains the part requested, pcchOut contains its length.
2047 * Failure: An HRESULT error code describing the error.
2048 */
2049 HRESULT WINAPI UrlGetPartA(LPCSTR pszIn, LPSTR pszOut, LPDWORD pcchOut,
2050 DWORD dwPart, DWORD dwFlags)
2051 {
2052 LPWSTR in, out;
2053 DWORD ret, len, len2;
2054
2055 if(!pszIn || !pszOut || !pcchOut || *pcchOut <= 0)
2056 return E_INVALIDARG;
2057
2058 in = HeapAlloc(GetProcessHeap(), 0,
2059 (2*INTERNET_MAX_URL_LENGTH) * sizeof(WCHAR));
2060 out = in + INTERNET_MAX_URL_LENGTH;
2061
2062 MultiByteToWideChar(0, 0, pszIn, -1, in, INTERNET_MAX_URL_LENGTH);
2063
2064 len = INTERNET_MAX_URL_LENGTH;
2065 ret = UrlGetPartW(in, out, &len, dwPart, dwFlags);
2066
2067 if (FAILED(ret)) {
2068 HeapFree(GetProcessHeap(), 0, in);
2069 return ret;
2070 }
2071
2072 len2 = WideCharToMultiByte(0, 0, out, len, 0, 0, 0, 0);
2073 if (len2 > *pcchOut) {
2074 *pcchOut = len2+1;
2075 HeapFree(GetProcessHeap(), 0, in);
2076 return E_POINTER;
2077 }
2078 len2 = WideCharToMultiByte(0, 0, out, len+1, pszOut, *pcchOut, 0, 0);
2079 *pcchOut = len2-1;
2080 HeapFree(GetProcessHeap(), 0, in);
2081 return ret;
2082 }
2083
2084 /*************************************************************************
2085 * UrlGetPartW [SHLWAPI.@]
2086 *
2087 * See UrlGetPartA.
2088 */
2089 HRESULT WINAPI UrlGetPartW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut,
2090 DWORD dwPart, DWORD dwFlags)
2091 {
2092 WINE_PARSE_URL pl;
2093 HRESULT ret;
2094 DWORD scheme, size, schsize;
2095 LPCWSTR addr, schaddr;
2096
2097 TRACE("(%s %p %p(%d) %08x %08x)\n",
2098 debugstr_w(pszIn), pszOut, pcchOut, *pcchOut, dwPart, dwFlags);
2099
2100 if(!pszIn || !pszOut || !pcchOut || *pcchOut <= 0)
2101 return E_INVALIDARG;
2102
2103 *pszOut = '\0';
2104
2105 addr = strchrW(pszIn, ':');
2106 if(!addr)
2107 scheme = URL_SCHEME_UNKNOWN;
2108 else
2109 scheme = get_scheme_code(pszIn, addr-pszIn);
2110
2111 ret = URL_ParseUrl(pszIn, &pl);
2112
2113 switch (dwPart) {
2114 case URL_PART_SCHEME:
2115 if (!pl.szScheme || scheme == URL_SCHEME_UNKNOWN) {
2116 *pcchOut = 0;
2117 return S_FALSE;
2118 }
2119 addr = pl.pScheme;
2120 size = pl.szScheme;
2121 break;
2122
2123 case URL_PART_HOSTNAME:
2124 switch(scheme) {
2125 case URL_SCHEME_FTP:
2126 case URL_SCHEME_HTTP:
2127 case URL_SCHEME_GOPHER:
2128 case URL_SCHEME_TELNET:
2129 case URL_SCHEME_FILE:
2130 case URL_SCHEME_HTTPS:
2131 break;
2132 default:
2133 *pcchOut = 0;
2134 return E_FAIL;
2135 }
2136
2137 if(scheme==URL_SCHEME_FILE && (!pl.szHostName ||
2138 (pl.szHostName==1 && *(pl.pHostName+1)==':'))) {
2139 *pcchOut = 0;
2140 return S_FALSE;
2141 }
2142
2143 if (!pl.szHostName) {
2144 *pcchOut = 0;
2145 return S_FALSE;
2146 }
2147 addr = pl.pHostName;
2148 size = pl.szHostName;
2149 break;
2150
2151 case URL_PART_USERNAME:
2152 if (!pl.szUserName) {
2153 *pcchOut = 0;
2154 return S_FALSE;
2155 }
2156 addr = pl.pUserName;
2157 size = pl.szUserName;
2158 break;
2159
2160 case URL_PART_PASSWORD:
2161 if (!pl.szPassword) {
2162 *pcchOut = 0;
2163 return S_FALSE;
2164 }
2165 addr = pl.pPassword;
2166 size = pl.szPassword;
2167 break;
2168
2169 case URL_PART_PORT:
2170 if (!pl.szPort) {
2171 *pcchOut = 0;
2172 return S_FALSE;
2173 }
2174 addr = pl.pPort;
2175 size = pl.szPort;
2176 break;
2177
2178 case URL_PART_QUERY:
2179 if (!pl.szQuery) {
2180 *pcchOut = 0;
2181 return S_FALSE;
2182 }
2183 addr = pl.pQuery;
2184 size = pl.szQuery;
2185 break;
2186
2187 default:
2188 *pcchOut = 0;
2189 return E_INVALIDARG;
2190 }
2191
2192 if (dwFlags == URL_PARTFLAG_KEEPSCHEME) {
2193 if(!pl.pScheme || !pl.szScheme) {
2194 *pcchOut = 0;
2195 return E_FAIL;
2196 }
2197 schaddr = pl.pScheme;
2198 schsize = pl.szScheme;
2199 if (*pcchOut < schsize + size + 2) {
2200 *pcchOut = schsize + size + 2;
2201 return E_POINTER;
2202 }
2203 memcpy(pszOut, schaddr, schsize*sizeof(WCHAR));
2204 pszOut[schsize] = ':';
2205 memcpy(pszOut+schsize+1, addr, size*sizeof(WCHAR));
2206 pszOut[schsize+1+size] = 0;
2207 *pcchOut = schsize + 1 + size;
2208 }
2209 else {
2210 if (*pcchOut < size + 1) {*pcchOut = size+1; return E_POINTER;}
2211 memcpy(pszOut, addr, size*sizeof(WCHAR));
2212 pszOut[size] = 0;
2213 *pcchOut = size;
2214 }
2215 TRACE("len=%d %s\n", *pcchOut, debugstr_w(pszOut));
2216
2217 return ret;
2218 }
2219
2220 /*************************************************************************
2221 * PathIsURLA [SHLWAPI.@]
2222 *
2223 * Check if the given path is a Url.
2224 *
2225 * PARAMS
2226 * lpszPath [I] Path to check.
2227 *
2228 * RETURNS
2229 * TRUE if lpszPath is a Url.
2230 * FALSE if lpszPath is NULL or not a Url.
2231 */
2232 BOOL WINAPI PathIsURLA(LPCSTR lpstrPath)
2233 {
2234 PARSEDURLA base;
2235 HRESULT hres;
2236
2237 TRACE("%s\n", debugstr_a(lpstrPath));
2238
2239 if (!lpstrPath || !*lpstrPath) return FALSE;
2240
2241 /* get protocol */
2242 base.cbSize = sizeof(base);
2243 hres = ParseURLA(lpstrPath, &base);
2244 return hres == S_OK && (base.nScheme != URL_SCHEME_INVALID);
2245 }
2246
2247 /*************************************************************************
2248 * PathIsURLW [SHLWAPI.@]
2249 *
2250 * See PathIsURLA.
2251 */
2252 BOOL WINAPI PathIsURLW(LPCWSTR lpstrPath)
2253 {
2254 PARSEDURLW base;
2255 HRESULT hres;
2256
2257 TRACE("%s\n", debugstr_w(lpstrPath));
2258
2259 if (!lpstrPath || !*lpstrPath) return FALSE;
2260
2261 /* get protocol */
2262 base.cbSize = sizeof(base);
2263 hres = ParseURLW(lpstrPath, &base);
2264 return hres == S_OK && (base.nScheme != URL_SCHEME_INVALID);
2265 }
2266
2267 /*************************************************************************
2268 * UrlCreateFromPathA [SHLWAPI.@]
2269 *
2270 * See UrlCreateFromPathW
2271 */
2272 HRESULT WINAPI UrlCreateFromPathA(LPCSTR pszPath, LPSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2273 {
2274 WCHAR bufW[INTERNET_MAX_URL_LENGTH];
2275 WCHAR *urlW = bufW;
2276 UNICODE_STRING pathW;
2277 HRESULT ret;
2278 DWORD lenW = sizeof(bufW)/sizeof(WCHAR), lenA;
2279
2280 if(!RtlCreateUnicodeStringFromAsciiz(&pathW, pszPath))
2281 return E_INVALIDARG;
2282 if((ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved)) == E_POINTER) {
2283 urlW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
2284 ret = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, dwReserved);
2285 }
2286 if(ret == S_OK || ret == S_FALSE) {
2287 RtlUnicodeToMultiByteSize(&lenA, urlW, lenW * sizeof(WCHAR));
2288 if(*pcchUrl > lenA) {
2289 RtlUnicodeToMultiByteN(pszUrl, *pcchUrl - 1, &lenA, urlW, lenW * sizeof(WCHAR));
2290 pszUrl[lenA] = 0;
2291 *pcchUrl = lenA;
2292 } else {
2293 *pcchUrl = lenA + 1;
2294 ret = E_POINTER;
2295 }
2296 }
2297 if(urlW != bufW) HeapFree(GetProcessHeap(), 0, urlW);
2298 RtlFreeUnicodeString(&pathW);
2299 return ret;
2300 }
2301
2302 /*************************************************************************
2303 * UrlCreateFromPathW [SHLWAPI.@]
2304 *
2305 * Create a Url from a file path.
2306 *
2307 * PARAMS
2308 * pszPath [I] Path to convert
2309 * pszUrl [O] Destination for the converted Url
2310 * pcchUrl [I/O] Length of pszUrl
2311 * dwReserved [I] Reserved, must be 0
2312 *
2313 * RETURNS
2314 * Success: S_OK pszUrl contains the converted path, S_FALSE if the path is already a Url
2315 * Failure: An HRESULT error code.
2316 */
2317 HRESULT WINAPI UrlCreateFromPathW(LPCWSTR pszPath, LPWSTR pszUrl, LPDWORD pcchUrl, DWORD dwReserved)
2318 {
2319 DWORD needed;
2320 HRESULT ret;
2321 WCHAR *pszNewUrl;
2322 WCHAR file_colonW[] = {'f','i','l','e',':',0};
2323 WCHAR three_slashesW[] = {'/','/','/',0};
2324 PARSEDURLW parsed_url;
2325
2326 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszPath), pszUrl, pcchUrl, dwReserved);
2327
2328 /* Validate arguments */
2329 if (dwReserved != 0)
2330 return E_INVALIDARG;
2331 if (!pszUrl || !pcchUrl)
2332 return E_INVALIDARG;
2333
2334
2335 parsed_url.cbSize = sizeof(parsed_url);
2336 if(ParseURLW(pszPath, &parsed_url) == S_OK) {
2337 if(parsed_url.nScheme != URL_SCHEME_INVALID && parsed_url.cchProtocol > 1) {
2338 needed = strlenW(pszPath);
2339 if (needed >= *pcchUrl) {
2340 *pcchUrl = needed + 1;
2341 return E_POINTER;
2342 } else {
2343 *pcchUrl = needed;
2344 strcpyW(pszUrl, pszPath);
2345 return S_FALSE;
2346 }
2347 }
2348 }
2349
2350 pszNewUrl = HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath) + 9) * sizeof(WCHAR)); /* "file:///" + pszPath_len + 1 */
2351 strcpyW(pszNewUrl, file_colonW);
2352 if(isalphaW(pszPath[0]) && pszPath[1] == ':')
2353 strcatW(pszNewUrl, three_slashesW);
2354 strcatW(pszNewUrl, pszPath);
2355 ret = UrlEscapeW(pszNewUrl, pszUrl, pcchUrl, URL_ESCAPE_PERCENT);
2356
2357 HeapFree(GetProcessHeap(), 0, pszNewUrl);
2358 return ret;
2359 }
2360
2361 /*************************************************************************
2362 * SHAutoComplete [SHLWAPI.@]
2363 *
2364 * Enable auto-completion for an edit control.
2365 *
2366 * PARAMS
2367 * hwndEdit [I] Handle of control to enable auto-completion for
2368 * dwFlags [I] SHACF_ flags from "shlwapi.h"
2369 *
2370 * RETURNS
2371 * Success: S_OK. Auto-completion is enabled for the control.
2372 * Failure: An HRESULT error code indicating the error.
2373 */
2374 HRESULT WINAPI SHAutoComplete(HWND hwndEdit, DWORD dwFlags)
2375 {
2376 FIXME("stub\n");
2377 return S_FALSE;
2378 }
2379
2380 /*************************************************************************
2381 * MLBuildResURLA [SHLWAPI.405]
2382 *
2383 * Create a Url pointing to a resource in a module.
2384 *
2385 * PARAMS
2386 * lpszLibName [I] Name of the module containing the resource
2387 * hMod [I] Callers module handle
2388 * dwFlags [I] Undocumented flags for loading the module
2389 * lpszRes [I] Resource name
2390 * lpszDest [O] Destination for resulting Url
2391 * dwDestLen [I] Length of lpszDest
2392 *
2393 * RETURNS
2394 * Success: S_OK. lpszDest contains the resource Url.
2395 * Failure: E_INVALIDARG, if any argument is invalid, or
2396 * E_FAIL if dwDestLen is too small.
2397 */
2398 HRESULT WINAPI MLBuildResURLA(LPCSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2399 LPCSTR lpszRes, LPSTR lpszDest, DWORD dwDestLen)
2400 {
2401 WCHAR szLibName[MAX_PATH], szRes[MAX_PATH], szDest[MAX_PATH];
2402 HRESULT hRet;
2403
2404 if (lpszLibName)
2405 MultiByteToWideChar(CP_ACP, 0, lpszLibName, -1, szLibName, sizeof(szLibName)/sizeof(WCHAR));
2406
2407 if (lpszRes)
2408 MultiByteToWideChar(CP_ACP, 0, lpszRes, -1, szRes, sizeof(szRes)/sizeof(WCHAR));
2409
2410 if (dwDestLen > sizeof(szLibName)/sizeof(WCHAR))
2411 dwDestLen = sizeof(szLibName)/sizeof(WCHAR);
2412
2413 hRet = MLBuildResURLW(lpszLibName ? szLibName : NULL, hMod, dwFlags,
2414 lpszRes ? szRes : NULL, lpszDest ? szDest : NULL, dwDestLen);
2415 if (SUCCEEDED(hRet) && lpszDest)
2416 WideCharToMultiByte(CP_ACP, 0, szDest, -1, lpszDest, dwDestLen, 0, 0);
2417
2418 return hRet;
2419 }
2420
2421 /*************************************************************************
2422 * MLBuildResURLA [SHLWAPI.406]
2423 *
2424 * See MLBuildResURLA.
2425 */
2426 HRESULT WINAPI MLBuildResURLW(LPCWSTR lpszLibName, HMODULE hMod, DWORD dwFlags,
2427 LPCWSTR lpszRes, LPWSTR lpszDest, DWORD dwDestLen)
2428 {
2429 static const WCHAR szRes[] = { 'r','e','s',':','/','/','\0' };
2430 #define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR))
2431 HRESULT hRet = E_FAIL;
2432
2433 TRACE("(%s,%p,0x%08x,%s,%p,%d)\n", debugstr_w(lpszLibName), hMod, dwFlags,
2434 debugstr_w(lpszRes), lpszDest, dwDestLen);
2435
2436 if (!lpszLibName || !hMod || hMod == INVALID_HANDLE_VALUE || !lpszRes ||
2437 !lpszDest || (dwFlags && dwFlags != 2))
2438 return E_INVALIDARG;
2439
2440 if (dwDestLen >= szResLen + 1)
2441 {
2442 dwDestLen -= (szResLen + 1);
2443 memcpy(lpszDest, szRes, sizeof(szRes));
2444
2445 hMod = MLLoadLibraryW(lpszLibName, hMod, dwFlags);
2446
2447 if (hMod)
2448 {
2449 WCHAR szBuff[MAX_PATH];
2450 DWORD len;
2451
2452 len = GetModuleFileNameW(hMod, szBuff, sizeof(szBuff)/sizeof(WCHAR));
2453 if (len && len < sizeof(szBuff)/sizeof(WCHAR))
2454 {
2455 DWORD dwPathLen = strlenW(szBuff) + 1;
2456
2457 if (dwDestLen >= dwPathLen)
2458 {
2459 DWORD dwResLen;
2460
2461 dwDestLen -= dwPathLen;
2462 memcpy(lpszDest + szResLen, szBuff, dwPathLen * sizeof(WCHAR));
2463
2464 dwResLen = strlenW(lpszRes) + 1;
2465 if (dwDestLen >= dwResLen + 1)
2466 {
2467 lpszDest[szResLen + dwPathLen-1] = '/';
2468 memcpy(lpszDest + szResLen + dwPathLen, lpszRes, dwResLen * sizeof(WCHAR));
2469 hRet = S_OK;
2470 }
2471 }
2472 }
2473 MLFreeLibrary(hMod);
2474 }
2475 }
2476 return hRet;
2477 }
2478
2479 /***********************************************************************
2480 * UrlFixupW [SHLWAPI.462]
2481 *
2482 * Checks the scheme part of a URL and attempts to correct misspellings.
2483 *
2484 * PARAMS
2485 * lpszUrl [I] Pointer to the URL to be corrected
2486 * lpszTranslatedUrl [O] Pointer to a buffer to store corrected URL
2487 * dwMaxChars [I] Maximum size of corrected URL
2488 *
2489 * RETURNS
2490 * success: S_OK if URL corrected or already correct
2491 * failure: S_FALSE if unable to correct / COM error code if other error
2492 *
2493 */
2494 HRESULT WINAPI UrlFixupW(LPCWSTR url, LPWSTR translatedUrl, DWORD maxChars)
2495 {
2496 DWORD srcLen;
2497
2498 FIXME("(%s,%p,%d) STUB\n", debugstr_w(url), translatedUrl, maxChars);
2499
2500 if (!url)
2501 return E_FAIL;
2502
2503 srcLen = lstrlenW(url) + 1;
2504
2505 /* For now just copy the URL directly */
2506 lstrcpynW(translatedUrl, url, (maxChars < srcLen) ? maxChars : srcLen);
2507
2508 return S_OK;
2509 }
A free Windows-compatible Operating System