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