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