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