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