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