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