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