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