4 * Copyright 2000 Huw D M Davies for CodeWeavers.
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.
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.
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
26 HMODULE WINAPI
MLLoadLibraryW(LPCWSTR
,HMODULE
,DWORD
);
27 BOOL WINAPI
MLFreeLibrary(HMODULE
);
28 HRESULT WINAPI
MLBuildResURLW(LPCWSTR
,HMODULE
,DWORD
,LPCWSTR
,LPWSTR
,DWORD
);
30 static inline WCHAR
*heap_strdupAtoW(const char *str
)
37 len
= MultiByteToWideChar(CP_ACP
, 0, str
, -1, NULL
, 0);
38 ret
= HeapAlloc(GetProcessHeap(), 0, len
*sizeof(WCHAR
));
39 MultiByteToWideChar(CP_ACP
, 0, str
, -1, ret
, len
);
45 /* The following schemes were identified in the native version of
46 * SHLWAPI.DLL version 5.50
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}},
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) */
94 static const CHAR hexDigits
[] = "0123456789ABCDEF";
96 static const WCHAR fileW
[] = {'f','i','l','e','\0'};
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 };
120 static DWORD
get_scheme_code(LPCWSTR scheme
, DWORD scheme_len
)
124 for(i
=0; i
< sizeof(shlwapi_schemes
)/sizeof(shlwapi_schemes
[0]); i
++) {
125 if(scheme_len
== strlenW(shlwapi_schemes
[i
].scheme_name
)
126 && !memicmpW(scheme
, shlwapi_schemes
[i
].scheme_name
, scheme_len
))
127 return shlwapi_schemes
[i
].scheme_number
;
130 return URL_SCHEME_UNKNOWN
;
133 /*************************************************************************
136 * Parse a Url into its constituent parts.
140 * y [O] Undocumented structure holding the parsed information
143 * Success: S_OK. y contains the parsed Url details.
144 * Failure: An HRESULT error code.
146 HRESULT WINAPI
ParseURLA(LPCSTR x
, PARSEDURLA
*y
)
148 WCHAR scheme
[INTERNET_MAX_SCHEME_LENGTH
];
152 TRACE("%s %p\n", debugstr_a(x
), y
);
154 if(y
->cbSize
!= sizeof(*y
))
157 while(*ptr
&& (isalnum(*ptr
) || *ptr
== '-'))
160 if (*ptr
!= ':' || ptr
<= x
+1) {
161 y
->pszProtocol
= NULL
;
162 return URL_E_INVALID_SYNTAX
;
166 y
->cchProtocol
= ptr
-x
;
167 y
->pszSuffix
= ptr
+1;
168 y
->cchSuffix
= strlen(y
->pszSuffix
);
170 len
= MultiByteToWideChar(CP_ACP
, 0, x
, ptr
-x
,
171 scheme
, sizeof(scheme
)/sizeof(WCHAR
));
172 y
->nScheme
= get_scheme_code(scheme
, len
);
177 /*************************************************************************
180 * Unicode version of ParseURLA.
182 HRESULT WINAPI
ParseURLW(LPCWSTR x
, PARSEDURLW
*y
)
184 const WCHAR
*ptr
= x
;
186 TRACE("%s %p\n", debugstr_w(x
), y
);
188 if(y
->cbSize
!= sizeof(*y
))
191 while(*ptr
&& (isalnumW(*ptr
) || *ptr
== '-'))
194 if (*ptr
!= ':' || ptr
<= x
+1) {
195 y
->pszProtocol
= NULL
;
196 return URL_E_INVALID_SYNTAX
;
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
);
208 /*************************************************************************
209 * UrlCanonicalizeA [SHLWAPI.@]
211 * Canonicalize a Url.
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.
220 * Success: S_OK. The pszCanonicalized contains the converted Url.
221 * Failure: E_POINTER, if *pcchCanonicalized is too small.
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
232 HRESULT WINAPI
UrlCanonicalizeA(LPCSTR pszUrl
, LPSTR pszCanonicalized
,
233 LPDWORD pcchCanonicalized
, DWORD dwFlags
)
235 LPWSTR url
, canonical
;
238 TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_a(pszUrl
), pszCanonicalized
,
239 pcchCanonicalized
, dwFlags
, pcchCanonicalized
? *pcchCanonicalized
: -1);
241 if(!pszUrl
|| !pszCanonicalized
|| !pcchCanonicalized
|| !*pcchCanonicalized
)
244 url
= heap_strdupAtoW(pszUrl
);
245 canonical
= HeapAlloc(GetProcessHeap(), 0, *pcchCanonicalized
*sizeof(WCHAR
));
246 if(!url
|| !canonical
) {
247 HeapFree(GetProcessHeap(), 0, url
);
248 HeapFree(GetProcessHeap(), 0, canonical
);
249 return E_OUTOFMEMORY
;
252 ret
= UrlCanonicalizeW(url
, canonical
, pcchCanonicalized
, dwFlags
);
254 WideCharToMultiByte(CP_ACP
, 0, canonical
, -1, pszCanonicalized
,
255 *pcchCanonicalized
+1, NULL
, NULL
);
257 HeapFree(GetProcessHeap(), 0, url
);
258 HeapFree(GetProcessHeap(), 0, canonical
);
262 /*************************************************************************
263 * UrlCanonicalizeW [SHLWAPI.@]
265 * See UrlCanonicalizeA.
267 HRESULT WINAPI
UrlCanonicalizeW(LPCWSTR pszUrl
, LPWSTR pszCanonicalized
,
268 LPDWORD pcchCanonicalized
, DWORD dwFlags
)
273 LPWSTR lpszUrlCpy
, url
, wk2
, mp
, mp2
;
275 DWORD nByteLen
, nLen
, nWkLen
;
279 static const WCHAR wszFile
[] = {'f','i','l','e',':'};
280 static const WCHAR wszRes
[] = {'r','e','s',':'};
281 static const WCHAR wszHttp
[] = {'h','t','t','p',':'};
282 static const WCHAR wszLocalhost
[] = {'l','o','c','a','l','h','o','s','t'};
283 static const WCHAR wszFilePrefix
[] = {'f','i','l','e',':','/','/','/'};
285 TRACE("(%s, %p, %p, 0x%08x) *pcchCanonicalized: %d\n", debugstr_w(pszUrl
), pszCanonicalized
,
286 pcchCanonicalized
, dwFlags
, pcchCanonicalized
? *pcchCanonicalized
: -1);
288 if(!pszUrl
|| !pszCanonicalized
|| !pcchCanonicalized
|| !*pcchCanonicalized
)
292 *pszCanonicalized
= 0;
296 /* Remove '\t' characters from URL */
297 nByteLen
= (strlenW(pszUrl
) + 1) * sizeof(WCHAR
); /* length in bytes */
298 url
= HeapAlloc(GetProcessHeap(), 0, nByteLen
);
300 return E_OUTOFMEMORY
;
310 /* Allocate memory for simplified URL (before escaping) */
311 nByteLen
= (wk2
-url
)*sizeof(WCHAR
);
312 lpszUrlCpy
= HeapAlloc(GetProcessHeap(), 0,
313 nByteLen
+sizeof(wszFilePrefix
)+sizeof(WCHAR
));
315 HeapFree(GetProcessHeap(), 0, url
);
316 return E_OUTOFMEMORY
;
319 is_file_url
= !strncmpW(wszFile
, url
, sizeof(wszFile
)/sizeof(WCHAR
));
321 if ((nByteLen
>= sizeof(wszHttp
) &&
322 !memcmp(wszHttp
, url
, sizeof(wszHttp
))) || is_file_url
)
325 if((dwFlags
& (URL_FILE_USE_PATHURL
| URL_WININET_COMPATIBILITY
)) && is_file_url
)
328 if(nByteLen
>= sizeof(wszRes
) && !memcmp(wszRes
, url
, sizeof(wszRes
))) {
329 dwFlags
&= ~URL_FILE_USE_PATHURL
;
336 * 1 have 2[+] alnum 2,3
337 * 2 have scheme (found :) 4,6,3
338 * 3 failed (no location)
340 * 5 have 1[+] alnum 6,3
341 * 6 have location (found /) save root location
348 if(url
[1] == ':') { /* Assume path */
349 memcpy(wk2
, wszFilePrefix
, sizeof(wszFilePrefix
));
350 wk2
+= sizeof(wszFilePrefix
)/sizeof(WCHAR
);
351 if (dwFlags
& (URL_FILE_USE_PATHURL
| URL_WININET_COMPATIBILITY
))
357 dwFlags
|= URL_ESCAPE_UNSAFE
;
360 } else if(url
[0] == '/') {
368 if (!isalnumW(*wk1
)) {state
= 3; break;}
370 if (!isalnumW(*wk1
)) {state
= 3; break;}
376 if (*wk1
++ == ':') state
= 2;
380 if (*wk1
!= '/') {state
= 6; break;}
382 if((dwFlags
& URL_FILE_USE_PATHURL
) && nByteLen
>= sizeof(wszLocalhost
)
384 && !memcmp(wszLocalhost
, wk1
, sizeof(wszLocalhost
))){
385 wk1
+= sizeof(wszLocalhost
)/sizeof(WCHAR
);
386 while(*wk1
== '\\' && (dwFlags
& URL_FILE_USE_PATHURL
))
390 if(*wk1
== '/' && (dwFlags
& URL_FILE_USE_PATHURL
)){
392 }else if(is_file_url
){
393 const WCHAR
*body
= wk1
;
398 if(isalnumW(*body
) && *(body
+1) == ':'){
399 if(!(dwFlags
& (URL_WININET_COMPATIBILITY
| URL_FILE_USE_PATHURL
))){
406 if(dwFlags
& URL_WININET_COMPATIBILITY
){
407 if(*wk1
== '/' && *(wk1
+1) != '/'){
414 if(*wk1
== '/' && *(wk1
+1) != '/'){
427 nWkLen
= strlenW(wk1
);
428 memcpy(wk2
, wk1
, (nWkLen
+ 1) * sizeof(WCHAR
));
435 if(*mp
== '/' || *mp
== '\\')
442 if (!isalnumW(*wk1
) && (*wk1
!= '-') && (*wk1
!= '.') && (*wk1
!= ':'))
444 while(isalnumW(*wk1
) || (*wk1
== '-') || (*wk1
== '.') || (*wk1
== ':'))
455 if (*wk1
!= '/' && *wk1
!= '\\') {state
= 3; break;}
456 while(*wk1
== '/' || *wk1
== '\\') {
466 if(dwFlags
& URL_DONT_SIMPLIFY
) {
471 /* Now at root location, cannot back up any more. */
472 /* "root" will point at the '/' */
476 mp
= strchrW(wk1
, '/');
477 mp2
= strchrW(wk1
, '\\');
478 if(mp2
&& (!mp
|| mp2
< mp
))
481 nWkLen
= strlenW(wk1
);
482 memcpy(wk2
, wk1
, (nWkLen
+ 1) * sizeof(WCHAR
));
489 memcpy(wk2
, wk1
, nLen
* sizeof(WCHAR
));
499 while (*wk1
== '.') {
500 TRACE("found '/.'\n");
501 if (wk1
[1] == '/' || wk1
[1] == '\\') {
502 /* case of /./ -> skip the ./ */
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
))
515 if (mp
&& (mp
>= root
)) {
516 /* found valid backup point */
518 if(wk1
[2] != '/' && wk1
[2] != '\\')
524 /* did not find point, restore '/' */
536 FIXME("how did we get here - state=%d\n", state
);
537 HeapFree(GetProcessHeap(), 0, lpszUrlCpy
);
538 HeapFree(GetProcessHeap(), 0, url
);
542 TRACE("Simplified, orig <%s>, simple <%s>\n",
543 debugstr_w(pszUrl
), debugstr_w(lpszUrlCpy
));
545 nLen
= lstrlenW(lpszUrlCpy
);
546 while ((nLen
> 0) && ((lpszUrlCpy
[nLen
-1] <= ' ')))
547 lpszUrlCpy
[--nLen
]=0;
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
);
554 if((EscapeFlags
= dwFlags
& (URL_ESCAPE_UNSAFE
|
555 URL_ESCAPE_SPACES_ONLY
|
557 URL_DONT_ESCAPE_EXTRA_INFO
|
558 URL_ESCAPE_SEGMENT_ONLY
))) {
559 EscapeFlags
&= ~URL_ESCAPE_UNSAFE
;
560 hr
= UrlEscapeW(lpszUrlCpy
, pszCanonicalized
, pcchCanonicalized
,
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
));
570 *pcchCanonicalized
= nLen
;
573 HeapFree(GetProcessHeap(), 0, lpszUrlCpy
);
574 HeapFree(GetProcessHeap(), 0, url
);
577 TRACE("result %s\n", debugstr_w(pszCanonicalized
));
582 /*************************************************************************
583 * UrlCombineA [SHLWAPI.@]
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"
595 * Success: S_OK. pszCombined contains the combined Url, pcchCombined
596 * contains its length.
597 * Failure: An HRESULT error code indicating the error.
599 HRESULT WINAPI
UrlCombineA(LPCSTR pszBase
, LPCSTR pszRelative
,
600 LPSTR pszCombined
, LPDWORD pcchCombined
,
603 LPWSTR base
, relative
, combined
;
604 DWORD ret
, len
, len2
;
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
);
610 if(!pszBase
|| !pszRelative
|| !pcchCombined
)
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
;
618 MultiByteToWideChar(CP_ACP
, 0, pszBase
, -1, base
, INTERNET_MAX_URL_LENGTH
);
619 MultiByteToWideChar(CP_ACP
, 0, pszRelative
, -1, relative
, INTERNET_MAX_URL_LENGTH
);
622 ret
= UrlCombineW(base
, relative
, pszCombined
?combined
:NULL
, &len
, dwFlags
);
625 HeapFree(GetProcessHeap(), 0, base
);
629 len2
= WideCharToMultiByte(CP_ACP
, 0, combined
, len
, NULL
, 0, NULL
, NULL
);
630 if (len2
> *pcchCombined
) {
631 *pcchCombined
= len2
;
632 HeapFree(GetProcessHeap(), 0, base
);
635 WideCharToMultiByte(CP_ACP
, 0, combined
, len
+1, pszCombined
, (*pcchCombined
)+1,
637 *pcchCombined
= len2
;
638 HeapFree(GetProcessHeap(), 0, base
);
642 /*************************************************************************
643 * UrlCombineW [SHLWAPI.@]
647 HRESULT WINAPI
UrlCombineW(LPCWSTR pszBase
, LPCWSTR pszRelative
,
648 LPWSTR pszCombined
, LPDWORD pcchCombined
,
651 PARSEDURLW base
, relative
;
652 DWORD myflags
, sizeloc
= 0;
653 DWORD i
, len
, res1
, res2
, process_case
= 0;
654 LPWSTR work
, preliminary
, mbase
, mrelative
;
655 static const WCHAR myfilestr
[] = {'f','i','l','e',':','/','/','/','\0'};
656 static const WCHAR fragquerystr
[] = {'#','?',0};
659 TRACE("(base %s, Relative %s, Combine size %d, flags %08x)\n",
660 debugstr_w(pszBase
),debugstr_w(pszRelative
),
661 pcchCombined
?*pcchCombined
:0,dwFlags
);
663 if(!pszBase
|| !pszRelative
|| !pcchCombined
)
666 base
.cbSize
= sizeof(base
);
667 relative
.cbSize
= sizeof(relative
);
669 /* Get space for duplicates of the input and the output */
670 preliminary
= HeapAlloc(GetProcessHeap(), 0, (3*INTERNET_MAX_URL_LENGTH
) *
672 mbase
= preliminary
+ INTERNET_MAX_URL_LENGTH
;
673 mrelative
= mbase
+ INTERNET_MAX_URL_LENGTH
;
676 /* Canonicalize the base input prior to looking for the scheme */
677 myflags
= dwFlags
& (URL_DONT_SIMPLIFY
| URL_UNESCAPE
);
678 len
= INTERNET_MAX_URL_LENGTH
;
679 UrlCanonicalizeW(pszBase
, mbase
, &len
, myflags
);
681 /* Canonicalize the relative input prior to looking for the scheme */
682 len
= INTERNET_MAX_URL_LENGTH
;
683 UrlCanonicalizeW(pszRelative
, mrelative
, &len
, myflags
);
685 /* See if the base has a scheme */
686 res1
= ParseURLW(mbase
, &base
);
688 /* if pszBase has no scheme, then return pszRelative */
689 TRACE("no scheme detected in Base\n");
693 BOOL manual_search
= FALSE
;
695 work
= (LPWSTR
)base
.pszProtocol
;
696 for(i
=0; i
<base
.cchProtocol
; i
++)
697 work
[i
] = tolowerW(work
[i
]);
699 /* mk is a special case */
700 if(base
.nScheme
== URL_SCHEME_MK
) {
701 static const WCHAR wsz
[] = {':',':',0};
703 WCHAR
*ptr
= strstrW(base
.pszSuffix
, wsz
);
708 delta
= ptr
-base
.pszSuffix
;
709 base
.cchProtocol
+= delta
;
710 base
.pszSuffix
+= delta
;
711 base
.cchSuffix
-= delta
;
714 /* get size of location field (if it exists) */
715 work
= (LPWSTR
)base
.pszSuffix
;
717 if (*work
++ == '/') {
718 if (*work
++ == '/') {
719 /* At this point have start of location and
720 * it ends at next '/' or end of string.
722 while(*work
&& (*work
!= '/')) work
++;
723 sizeloc
= (DWORD
)(work
- base
.pszSuffix
);
728 /* If there is a '?', then the remaining part can only contain a
729 * query string or fragment, so start looking for the last leaf
730 * from the '?'. Otherwise, if there is a '#' and the characters
731 * immediately preceding it are ".htm[l]", then begin looking for
732 * the last leaf starting from the '#'. Otherwise the '#' is not
733 * meaningful and just start looking from the end. */
734 if ((work
= strpbrkW(base
.pszSuffix
+ sizeloc
, fragquerystr
))) {
735 const WCHAR htmlW
[] = {'.','h','t','m','l',0};
736 const int len_htmlW
= 5;
737 const WCHAR htmW
[] = {'.','h','t','m',0};
738 const int len_htmW
= 4;
740 if (*work
== '?' || base
.nScheme
== URL_SCHEME_HTTP
|| base
.nScheme
== URL_SCHEME_HTTPS
)
741 manual_search
= TRUE
;
742 else if (work
- base
.pszSuffix
> len_htmW
) {
744 if (strncmpiW(work
, htmW
, len_htmW
) == 0)
745 manual_search
= TRUE
;
749 if (!manual_search
&&
750 work
- base
.pszSuffix
> len_htmlW
) {
752 if (strncmpiW(work
, htmlW
, len_htmlW
) == 0)
753 manual_search
= TRUE
;
759 /* search backwards starting from the current position */
760 while (*work
!= '/' && work
> base
.pszSuffix
+ sizeloc
)
762 base
.cchSuffix
= work
- base
.pszSuffix
+ 1;
764 /* search backwards starting from the end of the string */
765 work
= strrchrW((base
.pszSuffix
+sizeloc
), '/');
767 len
= (DWORD
)(work
- base
.pszSuffix
+ 1);
768 base
.cchSuffix
= len
;
770 base
.cchSuffix
= sizeloc
;
775 * .pszSuffix points to location (starting with '//')
776 * .cchSuffix length of location (above) and rest less the last
778 * sizeloc length of location (above) up to but not including
782 res2
= ParseURLW(mrelative
, &relative
);
784 /* no scheme in pszRelative */
785 TRACE("no scheme detected in Relative\n");
786 relative
.pszSuffix
= mrelative
; /* case 3,4,5 depends on this */
787 relative
.cchSuffix
= strlenW(mrelative
);
788 if (*pszRelative
== ':') {
789 /* case that is either left alone or uses pszBase */
790 if (dwFlags
& URL_PLUGGABLE_PROTOCOL
) {
797 if (isalnumW(*mrelative
) && (*(mrelative
+ 1) == ':')) {
798 /* case that becomes "file:///" */
799 strcpyW(preliminary
, myfilestr
);
803 if ((*mrelative
== '/') && (*(mrelative
+1) == '/')) {
804 /* pszRelative has location and rest */
808 if (*mrelative
== '/') {
809 /* case where pszRelative is root to location */
813 if (*mrelative
== '#') {
814 if(!(work
= strchrW(base
.pszSuffix
+base
.cchSuffix
, '#')))
815 work
= (LPWSTR
)base
.pszSuffix
+ strlenW(base
.pszSuffix
);
817 memcpy(preliminary
, base
.pszProtocol
, (work
-base
.pszProtocol
)*sizeof(WCHAR
));
818 preliminary
[work
-base
.pszProtocol
] = '\0';
822 process_case
= (*base
.pszSuffix
== '/' || base
.nScheme
== URL_SCHEME_MK
) ? 5 : 3;
825 work
= (LPWSTR
)relative
.pszProtocol
;
826 for(i
=0; i
<relative
.cchProtocol
; i
++)
827 work
[i
] = tolowerW(work
[i
]);
830 /* handle cases where pszRelative has scheme */
831 if ((base
.cchProtocol
== relative
.cchProtocol
) &&
832 (strncmpW(base
.pszProtocol
, relative
.pszProtocol
, base
.cchProtocol
) == 0)) {
834 /* since the schemes are the same */
835 if ((*relative
.pszSuffix
== '/') && (*(relative
.pszSuffix
+1) == '/')) {
836 /* case where pszRelative replaces location and following */
840 if (*relative
.pszSuffix
== '/') {
841 /* case where pszRelative is root to location */
845 /* replace either just location if base's location starts with a
846 * slash or otherwise everything */
847 process_case
= (*base
.pszSuffix
== '/') ? 5 : 1;
850 if ((*relative
.pszSuffix
== '/') && (*(relative
.pszSuffix
+1) == '/')) {
851 /* case where pszRelative replaces scheme, location,
852 * and following and handles PLUGGABLE
859 } while(FALSE
); /* a little trick to allow easy exit from nested if's */
862 switch (process_case
) {
865 * Return pszRelative appended to what ever is in pszCombined,
866 * (which may the string "file:///"
868 strcatW(preliminary
, mrelative
);
871 case 2: /* case where pszRelative replaces scheme, and location */
872 strcpyW(preliminary
, mrelative
);
876 * Return the pszBase scheme with pszRelative. Basically
877 * keeps the scheme and replaces the domain and following.
879 memcpy(preliminary
, base
.pszProtocol
, (base
.cchProtocol
+ 1)*sizeof(WCHAR
));
880 work
= preliminary
+ base
.cchProtocol
+ 1;
881 strcpyW(work
, relative
.pszSuffix
);
885 * Return the pszBase scheme and location but everything
886 * after the location is pszRelative. (Replace document
889 memcpy(preliminary
, base
.pszProtocol
, (base
.cchProtocol
+1+sizeloc
)*sizeof(WCHAR
));
890 work
= preliminary
+ base
.cchProtocol
+ 1 + sizeloc
;
891 if (dwFlags
& URL_PLUGGABLE_PROTOCOL
)
893 strcpyW(work
, relative
.pszSuffix
);
897 * Return the pszBase without its document (if any) and
898 * append pszRelative after its scheme.
900 memcpy(preliminary
, base
.pszProtocol
,
901 (base
.cchProtocol
+1+base
.cchSuffix
)*sizeof(WCHAR
));
902 work
= preliminary
+ base
.cchProtocol
+1+base
.cchSuffix
- 1;
905 if (relative
.pszSuffix
[0] == '.' && relative
.pszSuffix
[1] == 0)
908 strcpyW(work
, relative
.pszSuffix
);
912 FIXME("How did we get here????? process_case=%d\n", process_case
);
917 /* Reuse mrelative as temp storage as it's already allocated and not needed anymore */
918 if(*pcchCombined
== 0)
920 ret
= UrlCanonicalizeW(preliminary
, mrelative
, pcchCombined
, (dwFlags
& ~URL_FILE_USE_PATHURL
));
921 if(SUCCEEDED(ret
) && pszCombined
) {
922 lstrcpyW(pszCombined
, mrelative
);
924 TRACE("return-%d len=%d, %s\n",
925 process_case
, *pcchCombined
, debugstr_w(pszCombined
));
927 HeapFree(GetProcessHeap(), 0, preliminary
);
931 /*************************************************************************
932 * UrlEscapeA [SHLWAPI.@]
935 HRESULT WINAPI
UrlEscapeA(
941 WCHAR bufW
[INTERNET_MAX_URL_LENGTH
];
942 WCHAR
*escapedW
= bufW
;
945 DWORD lenW
= sizeof(bufW
)/sizeof(WCHAR
), lenA
;
947 if (!pszEscaped
|| !pcchEscaped
|| !*pcchEscaped
)
950 if(!RtlCreateUnicodeStringFromAsciiz(&urlW
, pszUrl
))
952 if(dwFlags
& URL_ESCAPE_AS_UTF8
) {
953 RtlFreeUnicodeString(&urlW
);
956 if((ret
= UrlEscapeW(urlW
.Buffer
, escapedW
, &lenW
, dwFlags
)) == E_POINTER
) {
957 escapedW
= HeapAlloc(GetProcessHeap(), 0, lenW
* sizeof(WCHAR
));
958 ret
= UrlEscapeW(urlW
.Buffer
, escapedW
, &lenW
, dwFlags
);
961 RtlUnicodeToMultiByteSize(&lenA
, escapedW
, lenW
* sizeof(WCHAR
));
962 if(*pcchEscaped
> lenA
) {
963 RtlUnicodeToMultiByteN(pszEscaped
, *pcchEscaped
- 1, &lenA
, escapedW
, lenW
* sizeof(WCHAR
));
964 pszEscaped
[lenA
] = 0;
967 *pcchEscaped
= lenA
+ 1;
971 if(escapedW
!= bufW
) HeapFree(GetProcessHeap(), 0, escapedW
);
972 RtlFreeUnicodeString(&urlW
);
976 #define WINE_URL_BASH_AS_SLASH 0x01
977 #define WINE_URL_COLLAPSE_SLASHES 0x02
978 #define WINE_URL_ESCAPE_SLASH 0x04
979 #define WINE_URL_ESCAPE_HASH 0x08
980 #define WINE_URL_ESCAPE_QUESTION 0x10
981 #define WINE_URL_STOP_ON_HASH 0x20
982 #define WINE_URL_STOP_ON_QUESTION 0x40
984 static inline BOOL
URL_NeedEscapeW(WCHAR ch
, DWORD flags
, DWORD int_flags
)
986 if (flags
& URL_ESCAPE_SPACES_ONLY
)
989 if ((flags
& URL_ESCAPE_PERCENT
) && (ch
== '%'))
992 if ((flags
& URL_ESCAPE_AS_UTF8
) && (ch
>= 0x80))
995 if (ch
<= 31 || (ch
>= 127 && ch
<= 255) )
1017 return !!(int_flags
& WINE_URL_ESCAPE_SLASH
);
1019 return !!(int_flags
& WINE_URL_ESCAPE_QUESTION
);
1021 return !!(int_flags
& WINE_URL_ESCAPE_HASH
);
1028 /*************************************************************************
1029 * UrlEscapeW [SHLWAPI.@]
1031 * Converts unsafe characters in a Url into escape sequences.
1034 * pszUrl [I] Url to modify
1035 * pszEscaped [O] Destination for modified Url
1036 * pcchEscaped [I/O] Length of pszUrl, destination for length of pszEscaped
1037 * dwFlags [I] URL_ flags from "shlwapi.h"
1040 * Success: S_OK. pszEscaped contains the escaped Url, pcchEscaped
1041 * contains its length.
1042 * Failure: E_POINTER, if pszEscaped is not large enough. In this case
1043 * pcchEscaped is set to the required length.
1045 * Converts unsafe characters into their escape sequences.
1048 * - By default this function stops converting at the first '?' or
1050 * - If dwFlags contains URL_ESCAPE_SPACES_ONLY then only spaces are
1051 * converted, but the conversion continues past a '?' or '#'.
1052 * - Note that this function did not work well (or at all) in shlwapi version 4.
1055 * Only the following flags are implemented:
1056 *| URL_ESCAPE_SPACES_ONLY
1057 *| URL_DONT_ESCAPE_EXTRA_INFO
1058 *| URL_ESCAPE_SEGMENT_ONLY
1059 *| URL_ESCAPE_PERCENT
1061 HRESULT WINAPI
UrlEscapeW(
1064 LPDWORD pcchEscaped
,
1068 DWORD needed
= 0, ret
;
1069 BOOL stop_escaping
= FALSE
;
1070 WCHAR next
[12], *dst
, *dst_ptr
;
1072 PARSEDURLW parsed_url
;
1075 static const WCHAR localhost
[] = {'l','o','c','a','l','h','o','s','t',0};
1077 TRACE("(%p(%s) %p %p 0x%08x)\n", pszUrl
, debugstr_w(pszUrl
),
1078 pszEscaped
, pcchEscaped
, dwFlags
);
1080 if(!pszUrl
|| !pcchEscaped
|| !pszEscaped
|| *pcchEscaped
== 0)
1081 return E_INVALIDARG
;
1083 if(dwFlags
& ~(URL_ESCAPE_SPACES_ONLY
|
1084 URL_ESCAPE_SEGMENT_ONLY
|
1085 URL_DONT_ESCAPE_EXTRA_INFO
|
1086 URL_ESCAPE_PERCENT
|
1087 URL_ESCAPE_AS_UTF8
))
1088 FIXME("Unimplemented flags: %08x\n", dwFlags
);
1090 dst_ptr
= dst
= HeapAlloc(GetProcessHeap(), 0, *pcchEscaped
*sizeof(WCHAR
));
1092 return E_OUTOFMEMORY
;
1095 if (dwFlags
& URL_ESCAPE_SPACES_ONLY
)
1096 /* if SPACES_ONLY specified, reset the other controls */
1097 dwFlags
&= ~(URL_DONT_ESCAPE_EXTRA_INFO
|
1098 URL_ESCAPE_PERCENT
|
1099 URL_ESCAPE_SEGMENT_ONLY
);
1102 /* if SPACES_ONLY *not* specified the assume DONT_ESCAPE_EXTRA_INFO */
1103 dwFlags
|= URL_DONT_ESCAPE_EXTRA_INFO
;
1107 if(dwFlags
& URL_ESCAPE_SEGMENT_ONLY
) {
1108 int_flags
= WINE_URL_ESCAPE_QUESTION
| WINE_URL_ESCAPE_HASH
| WINE_URL_ESCAPE_SLASH
;
1110 parsed_url
.cbSize
= sizeof(parsed_url
);
1111 if(ParseURLW(pszUrl
, &parsed_url
) != S_OK
)
1112 parsed_url
.nScheme
= URL_SCHEME_INVALID
;
1114 TRACE("scheme = %d (%s)\n", parsed_url
.nScheme
, debugstr_wn(parsed_url
.pszProtocol
, parsed_url
.cchProtocol
));
1116 if(dwFlags
& URL_DONT_ESCAPE_EXTRA_INFO
)
1117 int_flags
= WINE_URL_STOP_ON_HASH
| WINE_URL_STOP_ON_QUESTION
;
1119 switch(parsed_url
.nScheme
) {
1120 case URL_SCHEME_FILE
:
1121 int_flags
|= WINE_URL_BASH_AS_SLASH
| WINE_URL_COLLAPSE_SLASHES
| WINE_URL_ESCAPE_HASH
;
1122 int_flags
&= ~WINE_URL_STOP_ON_HASH
;
1125 case URL_SCHEME_HTTP
:
1126 case URL_SCHEME_HTTPS
:
1127 int_flags
|= WINE_URL_BASH_AS_SLASH
;
1128 if(parsed_url
.pszSuffix
[0] != '/' && parsed_url
.pszSuffix
[0] != '\\')
1129 int_flags
|= WINE_URL_ESCAPE_SLASH
;
1132 case URL_SCHEME_MAILTO
:
1133 int_flags
|= WINE_URL_ESCAPE_SLASH
| WINE_URL_ESCAPE_QUESTION
| WINE_URL_ESCAPE_HASH
;
1134 int_flags
&= ~(WINE_URL_STOP_ON_QUESTION
| WINE_URL_STOP_ON_HASH
);
1137 case URL_SCHEME_INVALID
:
1140 case URL_SCHEME_FTP
:
1142 if(parsed_url
.pszSuffix
[0] != '/')
1143 int_flags
|= WINE_URL_ESCAPE_SLASH
;
1148 for(src
= pszUrl
; *src
; ) {
1152 if((int_flags
& WINE_URL_COLLAPSE_SLASHES
) && src
== pszUrl
+ parsed_url
.cchProtocol
+ 1) {
1153 int localhost_len
= sizeof(localhost
)/sizeof(WCHAR
) - 1;
1154 while(cur
== '/' || cur
== '\\') {
1158 if(slashes
== 2 && !strncmpiW(src
, localhost
, localhost_len
)) { /* file://localhost/ -> file:/// */
1159 if(*(src
+ localhost_len
) == '/' || *(src
+ localhost_len
) == '\\')
1160 src
+= localhost_len
+ 1;
1167 next
[0] = next
[1] = next
[2] = '/';
1174 next
[0] = next
[1] = '/';
1181 if(cur
== '#' && (int_flags
& WINE_URL_STOP_ON_HASH
))
1182 stop_escaping
= TRUE
;
1184 if(cur
== '?' && (int_flags
& WINE_URL_STOP_ON_QUESTION
))
1185 stop_escaping
= TRUE
;
1187 if(cur
== '\\' && (int_flags
& WINE_URL_BASH_AS_SLASH
) && !stop_escaping
) cur
= '/';
1189 if(URL_NeedEscapeW(cur
, dwFlags
, int_flags
) && stop_escaping
== FALSE
) {
1190 if(dwFlags
& URL_ESCAPE_AS_UTF8
) {
1193 if ((cur
>= 0xd800 && cur
<= 0xdfff) &&
1194 (src
[1] >= 0xdc00 && src
[1] <= 0xdfff))
1197 len
= WideCharToMultiByte( CP_UTF8
, 0, src
, 2,
1198 utf
, sizeof(utf
), NULL
, NULL
);
1200 len
= WideCharToMultiByte( CP_UTF8
, WC_ERR_INVALID_CHARS
, src
, 2,
1201 utf
, sizeof(utf
), NULL
, NULL
);
1207 len
= WideCharToMultiByte( CP_UTF8
, 0, &cur
, 1,
1208 utf
, sizeof(utf
), NULL
, NULL
);
1210 len
= WideCharToMultiByte( CP_UTF8
, WC_ERR_INVALID_CHARS
, &cur
, 1,
1211 utf
, sizeof(utf
), NULL
, NULL
);
1221 for(i
= 0; i
< len
; i
++) {
1223 next
[i
*3+1] = hexDigits
[(utf
[i
] >> 4) & 0xf];
1224 next
[i
*3+2] = hexDigits
[utf
[i
] & 0xf];
1229 next
[1] = hexDigits
[(cur
>> 4) & 0xf];
1230 next
[2] = hexDigits
[cur
& 0xf];
1240 if(needed
+ len
<= *pcchEscaped
) {
1241 memcpy(dst
, next
, len
*sizeof(WCHAR
));
1247 if(needed
< *pcchEscaped
) {
1249 memcpy(pszEscaped
, dst_ptr
, (needed
+1)*sizeof(WCHAR
));
1253 needed
++; /* add one for the '\0' */
1256 *pcchEscaped
= needed
;
1258 HeapFree(GetProcessHeap(), 0, dst_ptr
);
1263 /*************************************************************************
1264 * UrlUnescapeA [SHLWAPI.@]
1266 * Converts Url escape sequences back to ordinary characters.
1269 * pszUrl [I/O] Url to convert
1270 * pszUnescaped [O] Destination for converted Url
1271 * pcchUnescaped [I/O] Size of output string
1272 * dwFlags [I] URL_ESCAPE_ Flags from "shlwapi.h"
1275 * Success: S_OK. The converted value is in pszUnescaped, or in pszUrl if
1276 * dwFlags includes URL_ESCAPE_INPLACE.
1277 * Failure: E_POINTER if the converted Url is bigger than pcchUnescaped. In
1278 * this case pcchUnescaped is set to the size required.
1280 * If dwFlags includes URL_DONT_ESCAPE_EXTRA_INFO, the conversion stops at
1281 * the first occurrence of either a '?' or '#' character.
1283 HRESULT WINAPI
UrlUnescapeA(
1286 LPDWORD pcchUnescaped
,
1293 BOOL stop_unescaping
= FALSE
;
1295 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_a(pszUrl
), pszUnescaped
,
1296 pcchUnescaped
, dwFlags
);
1298 if (!pszUrl
) return E_INVALIDARG
;
1300 if(dwFlags
& URL_UNESCAPE_INPLACE
)
1304 if (!pszUnescaped
|| !pcchUnescaped
) return E_INVALIDARG
;
1308 for(src
= pszUrl
, needed
= 0; *src
; src
++, needed
++) {
1309 if(dwFlags
& URL_DONT_UNESCAPE_EXTRA_INFO
&&
1310 (*src
== '#' || *src
== '?')) {
1311 stop_unescaping
= TRUE
;
1313 } else if(*src
== '%' && isxdigit(*(src
+ 1)) && isxdigit(*(src
+ 2))
1314 && stop_unescaping
== FALSE
) {
1317 memcpy(buf
, src
+ 1, 2);
1319 ih
= strtol(buf
, NULL
, 16);
1321 src
+= 2; /* Advance to end of escape */
1325 if(dwFlags
& URL_UNESCAPE_INPLACE
|| needed
< *pcchUnescaped
)
1329 if(dwFlags
& URL_UNESCAPE_INPLACE
|| needed
< *pcchUnescaped
) {
1333 needed
++; /* add one for the '\0' */
1336 if(!(dwFlags
& URL_UNESCAPE_INPLACE
))
1337 *pcchUnescaped
= needed
;
1340 TRACE("result %s\n", (dwFlags
& URL_UNESCAPE_INPLACE
) ?
1341 debugstr_a(pszUrl
) : debugstr_a(pszUnescaped
));
1347 /*************************************************************************
1348 * UrlUnescapeW [SHLWAPI.@]
1352 HRESULT WINAPI
UrlUnescapeW(
1354 LPWSTR pszUnescaped
,
1355 LPDWORD pcchUnescaped
,
1362 BOOL stop_unescaping
= FALSE
;
1364 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszUrl
), pszUnescaped
,
1365 pcchUnescaped
, dwFlags
);
1367 if(!pszUrl
) return E_INVALIDARG
;
1369 if(dwFlags
& URL_UNESCAPE_INPLACE
)
1373 if (!pszUnescaped
|| !pcchUnescaped
) return E_INVALIDARG
;
1377 for(src
= pszUrl
, needed
= 0; *src
; src
++, needed
++) {
1378 if(dwFlags
& URL_DONT_UNESCAPE_EXTRA_INFO
&&
1379 (*src
== '#' || *src
== '?')) {
1380 stop_unescaping
= TRUE
;
1382 } else if(*src
== '%' && isxdigitW(*(src
+ 1)) && isxdigitW(*(src
+ 2))
1383 && stop_unescaping
== FALSE
) {
1385 WCHAR buf
[5] = {'0','x',0};
1386 memcpy(buf
+ 2, src
+ 1, 2*sizeof(WCHAR
));
1388 StrToIntExW(buf
, STIF_SUPPORT_HEX
, &ih
);
1390 src
+= 2; /* Advance to end of escape */
1394 if(dwFlags
& URL_UNESCAPE_INPLACE
|| needed
< *pcchUnescaped
)
1398 if(dwFlags
& URL_UNESCAPE_INPLACE
|| needed
< *pcchUnescaped
) {
1402 needed
++; /* add one for the '\0' */
1405 if(!(dwFlags
& URL_UNESCAPE_INPLACE
))
1406 *pcchUnescaped
= needed
;
1409 TRACE("result %s\n", (dwFlags
& URL_UNESCAPE_INPLACE
) ?
1410 debugstr_w(pszUrl
) : debugstr_w(pszUnescaped
));
1416 /*************************************************************************
1417 * UrlGetLocationA [SHLWAPI.@]
1419 * Get the location from a Url.
1422 * pszUrl [I] Url to get the location from
1425 * A pointer to the start of the location in pszUrl, or NULL if there is
1429 * - MSDN erroneously states that "The location is the segment of the Url
1430 * starting with a '?' or '#' character". Neither V4 nor V5 of shlwapi.dll
1431 * stop at '?' and always return a NULL in this case.
1432 * - MSDN also erroneously states that "If a file URL has a query string,
1433 * the returned string is the query string". In all tested cases, if the
1434 * Url starts with "fi" then a NULL is returned. V5 gives the following results:
1437 *| NULL file://aa/b/cd#hohoh
1438 *| #hohoh http://aa/b/cd#hohoh
1439 *| NULL fi://aa/b/cd#hohoh
1440 *| #hohoh ff://aa/b/cd#hohoh
1442 LPCSTR WINAPI
UrlGetLocationA(
1448 base
.cbSize
= sizeof(base
);
1449 res1
= ParseURLA(pszUrl
, &base
);
1450 if (res1
) return NULL
; /* invalid scheme */
1452 /* if scheme is file: then never return pointer */
1453 if (strncmp(base
.pszProtocol
, "file", min(4,base
.cchProtocol
)) == 0) return NULL
;
1455 /* Look for '#' and return its addr */
1456 return strchr(base
.pszSuffix
, '#');
1459 /*************************************************************************
1460 * UrlGetLocationW [SHLWAPI.@]
1462 * See UrlGetLocationA.
1464 LPCWSTR WINAPI
UrlGetLocationW(
1470 base
.cbSize
= sizeof(base
);
1471 res1
= ParseURLW(pszUrl
, &base
);
1472 if (res1
) return NULL
; /* invalid scheme */
1474 /* if scheme is file: then never return pointer */
1475 if (strncmpW(base
.pszProtocol
, fileW
, min(4,base
.cchProtocol
)) == 0) return NULL
;
1477 /* Look for '#' and return its addr */
1478 return strchrW(base
.pszSuffix
, '#');
1481 /*************************************************************************
1482 * UrlCompareA [SHLWAPI.@]
1487 * pszUrl1 [I] First Url to compare
1488 * pszUrl2 [I] Url to compare to pszUrl1
1489 * fIgnoreSlash [I] TRUE = compare only up to a final slash
1492 * less than zero, zero, or greater than zero indicating pszUrl2 is greater
1493 * than, equal to, or less than pszUrl1 respectively.
1495 INT WINAPI
UrlCompareA(
1500 INT ret
, len
, len1
, len2
;
1503 return strcmp(pszUrl1
, pszUrl2
);
1504 len1
= strlen(pszUrl1
);
1505 if (pszUrl1
[len1
-1] == '/') len1
--;
1506 len2
= strlen(pszUrl2
);
1507 if (pszUrl2
[len2
-1] == '/') len2
--;
1509 return strncmp(pszUrl1
, pszUrl2
, len1
);
1510 len
= min(len1
, len2
);
1511 ret
= strncmp(pszUrl1
, pszUrl2
, len
);
1512 if (ret
) return ret
;
1513 if (len1
> len2
) return 1;
1517 /*************************************************************************
1518 * UrlCompareW [SHLWAPI.@]
1522 INT WINAPI
UrlCompareW(
1528 size_t len
, len1
, len2
;
1531 return strcmpW(pszUrl1
, pszUrl2
);
1532 len1
= strlenW(pszUrl1
);
1533 if (pszUrl1
[len1
-1] == '/') len1
--;
1534 len2
= strlenW(pszUrl2
);
1535 if (pszUrl2
[len2
-1] == '/') len2
--;
1537 return strncmpW(pszUrl1
, pszUrl2
, len1
);
1538 len
= min(len1
, len2
);
1539 ret
= strncmpW(pszUrl1
, pszUrl2
, len
);
1540 if (ret
) return ret
;
1541 if (len1
> len2
) return 1;
1545 /*************************************************************************
1546 * HashData [SHLWAPI.@]
1548 * Hash an input block into a variable sized digest.
1551 * lpSrc [I] Input block
1552 * nSrcLen [I] Length of lpSrc
1553 * lpDest [I] Output for hash digest
1554 * nDestLen [I] Length of lpDest
1557 * Success: TRUE. lpDest is filled with the computed hash value.
1558 * Failure: FALSE, if any argument is invalid.
1560 HRESULT WINAPI
HashData(const unsigned char *lpSrc
, DWORD nSrcLen
,
1561 unsigned char *lpDest
, DWORD nDestLen
)
1563 INT srcCount
= nSrcLen
- 1, destCount
= nDestLen
- 1;
1565 if (!lpSrc
|| !lpDest
)
1566 return E_INVALIDARG
;
1568 while (destCount
>= 0)
1570 lpDest
[destCount
] = (destCount
& 0xff);
1574 while (srcCount
>= 0)
1576 destCount
= nDestLen
- 1;
1577 while (destCount
>= 0)
1579 lpDest
[destCount
] = HashDataLookup
[lpSrc
[srcCount
] ^ lpDest
[destCount
]];
1587 /*************************************************************************
1588 * UrlHashA [SHLWAPI.@]
1590 * Produce a Hash from a Url.
1593 * pszUrl [I] Url to hash
1594 * lpDest [O] Destinationh for hash
1595 * nDestLen [I] Length of lpDest
1598 * Success: S_OK. lpDest is filled with the computed hash value.
1599 * Failure: E_INVALIDARG, if any argument is invalid.
1601 HRESULT WINAPI
UrlHashA(LPCSTR pszUrl
, unsigned char *lpDest
, DWORD nDestLen
)
1603 if (IsBadStringPtrA(pszUrl
, -1) || IsBadWritePtr(lpDest
, nDestLen
))
1604 return E_INVALIDARG
;
1606 HashData((const BYTE
*)pszUrl
, (int)strlen(pszUrl
), lpDest
, nDestLen
);
1610 /*************************************************************************
1611 * UrlHashW [SHLWAPI.@]
1615 HRESULT WINAPI
UrlHashW(LPCWSTR pszUrl
, unsigned char *lpDest
, DWORD nDestLen
)
1617 char szUrl
[MAX_PATH
];
1619 TRACE("(%s,%p,%d)\n",debugstr_w(pszUrl
), lpDest
, nDestLen
);
1621 if (IsBadStringPtrW(pszUrl
, -1) || IsBadWritePtr(lpDest
, nDestLen
))
1622 return E_INVALIDARG
;
1624 /* Win32 hashes the data as an ASCII string, presumably so that both A+W
1625 * return the same digests for the same URL.
1627 WideCharToMultiByte(CP_ACP
, 0, pszUrl
, -1, szUrl
, MAX_PATH
, NULL
, NULL
);
1628 HashData((const BYTE
*)szUrl
, (int)strlen(szUrl
), lpDest
, nDestLen
);
1632 /*************************************************************************
1633 * UrlApplySchemeA [SHLWAPI.@]
1635 * Apply a scheme to a Url.
1638 * pszIn [I] Url to apply scheme to
1639 * pszOut [O] Destination for modified Url
1640 * pcchOut [I/O] Length of pszOut/destination for length of pszOut
1641 * dwFlags [I] URL_ flags from "shlwapi.h"
1644 * Success: S_OK: pszOut contains the modified Url, pcchOut contains its length.
1645 * Failure: An HRESULT error code describing the error.
1647 HRESULT WINAPI
UrlApplySchemeA(LPCSTR pszIn
, LPSTR pszOut
, LPDWORD pcchOut
, DWORD dwFlags
)
1653 TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_a(pszIn
),
1654 pszOut
, pcchOut
, pcchOut
? *pcchOut
: 0, dwFlags
);
1656 if (!pszIn
|| !pszOut
|| !pcchOut
) return E_INVALIDARG
;
1658 in
= HeapAlloc(GetProcessHeap(), 0,
1659 (2*INTERNET_MAX_URL_LENGTH
) * sizeof(WCHAR
));
1660 out
= in
+ INTERNET_MAX_URL_LENGTH
;
1662 MultiByteToWideChar(CP_ACP
, 0, pszIn
, -1, in
, INTERNET_MAX_URL_LENGTH
);
1663 len
= INTERNET_MAX_URL_LENGTH
;
1665 ret
= UrlApplySchemeW(in
, out
, &len
, dwFlags
);
1667 HeapFree(GetProcessHeap(), 0, in
);
1671 len
= WideCharToMultiByte(CP_ACP
, 0, out
, -1, NULL
, 0, NULL
, NULL
);
1672 if (len
> *pcchOut
) {
1677 WideCharToMultiByte(CP_ACP
, 0, out
, -1, pszOut
, *pcchOut
, NULL
, NULL
);
1682 HeapFree(GetProcessHeap(), 0, in
);
1686 static HRESULT
URL_GuessScheme(LPCWSTR pszIn
, LPWSTR pszOut
, LPDWORD pcchOut
)
1691 DWORD value_len
, data_len
, dwType
, i
;
1692 WCHAR reg_path
[MAX_PATH
];
1693 WCHAR value
[MAX_PATH
], data
[MAX_PATH
];
1696 MultiByteToWideChar(CP_ACP
, 0,
1697 "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes",
1698 -1, reg_path
, MAX_PATH
);
1699 RegOpenKeyExW(HKEY_LOCAL_MACHINE
, reg_path
, 0, 1, &newkey
);
1701 while(value_len
= data_len
= MAX_PATH
,
1702 RegEnumValueW(newkey
, index
, value
, &value_len
,
1703 0, &dwType
, (LPVOID
)data
, &data_len
) == 0) {
1704 TRACE("guess %d %s is %s\n",
1705 index
, debugstr_w(value
), debugstr_w(data
));
1708 for(i
=0; i
<value_len
; i
++) {
1711 /* remember that TRUE is not-equal */
1712 j
= ChrCmpIW(Wxx
, Wyy
);
1715 if ((i
== value_len
) && !j
) {
1716 if (strlenW(data
) + strlenW(pszIn
) + 1 > *pcchOut
) {
1717 *pcchOut
= strlenW(data
) + strlenW(pszIn
) + 1;
1718 RegCloseKey(newkey
);
1721 strcpyW(pszOut
, data
);
1722 strcatW(pszOut
, pszIn
);
1723 *pcchOut
= strlenW(pszOut
);
1724 TRACE("matched and set to %s\n", debugstr_w(pszOut
));
1725 RegCloseKey(newkey
);
1730 RegCloseKey(newkey
);
1734 static HRESULT
URL_CreateFromPath(LPCWSTR pszPath
, LPWSTR pszUrl
, LPDWORD pcchUrl
)
1739 WCHAR file_colonW
[] = {'f','i','l','e',':',0};
1740 WCHAR three_slashesW
[] = {'/','/','/',0};
1741 PARSEDURLW parsed_url
;
1743 parsed_url
.cbSize
= sizeof(parsed_url
);
1744 if(ParseURLW(pszPath
, &parsed_url
) == S_OK
) {
1745 if(parsed_url
.nScheme
!= URL_SCHEME_INVALID
&& parsed_url
.cchProtocol
> 1) {
1746 needed
= strlenW(pszPath
);
1747 if (needed
>= *pcchUrl
) {
1748 *pcchUrl
= needed
+ 1;
1757 pszNewUrl
= HeapAlloc(GetProcessHeap(), 0, (strlenW(pszPath
) + 9) * sizeof(WCHAR
)); /* "file:///" + pszPath_len + 1 */
1758 strcpyW(pszNewUrl
, file_colonW
);
1759 if(isalphaW(pszPath
[0]) && pszPath
[1] == ':')
1760 strcatW(pszNewUrl
, three_slashesW
);
1761 strcatW(pszNewUrl
, pszPath
);
1762 ret
= UrlEscapeW(pszNewUrl
, pszUrl
, pcchUrl
, URL_ESCAPE_PERCENT
);
1763 HeapFree(GetProcessHeap(), 0, pszNewUrl
);
1767 static HRESULT
URL_ApplyDefault(LPCWSTR pszIn
, LPWSTR pszOut
, LPDWORD pcchOut
)
1770 DWORD data_len
, dwType
;
1771 WCHAR data
[MAX_PATH
];
1773 static const WCHAR prefix_keyW
[] =
1774 {'S','o','f','t','w','a','r','e',
1775 '\\','M','i','c','r','o','s','o','f','t',
1776 '\\','W','i','n','d','o','w','s',
1777 '\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',
1779 '\\','D','e','f','a','u','l','t','P','r','e','f','i','x',0};
1781 /* get and prepend default */
1782 RegOpenKeyExW(HKEY_LOCAL_MACHINE
, prefix_keyW
, 0, 1, &newkey
);
1783 data_len
= sizeof(data
);
1784 RegQueryValueExW(newkey
, NULL
, 0, &dwType
, (LPBYTE
)data
, &data_len
);
1785 RegCloseKey(newkey
);
1786 if (strlenW(data
) + strlenW(pszIn
) + 1 > *pcchOut
) {
1787 *pcchOut
= strlenW(data
) + strlenW(pszIn
) + 1;
1790 strcpyW(pszOut
, data
);
1791 strcatW(pszOut
, pszIn
);
1792 *pcchOut
= strlenW(pszOut
);
1793 TRACE("used default %s\n", debugstr_w(pszOut
));
1797 /*************************************************************************
1798 * UrlApplySchemeW [SHLWAPI.@]
1800 * See UrlApplySchemeA.
1802 HRESULT WINAPI
UrlApplySchemeW(LPCWSTR pszIn
, LPWSTR pszOut
, LPDWORD pcchOut
, DWORD dwFlags
)
1804 PARSEDURLW in_scheme
;
1808 TRACE("(%s, %p, %p:out size %d, 0x%08x)\n", debugstr_w(pszIn
),
1809 pszOut
, pcchOut
, pcchOut
? *pcchOut
: 0, dwFlags
);
1811 if (!pszIn
|| !pszOut
|| !pcchOut
) return E_INVALIDARG
;
1813 if (dwFlags
& URL_APPLY_GUESSFILE
) {
1814 if (*pcchOut
> 1 && ':' == pszIn
[1]) {
1816 ret
= URL_CreateFromPath(pszIn
, pszOut
, &res1
);
1817 if (ret
== S_OK
|| ret
== E_POINTER
){
1821 else if (ret
== S_FALSE
)
1828 in_scheme
.cbSize
= sizeof(in_scheme
);
1829 /* See if the base has a scheme */
1830 res1
= ParseURLW(pszIn
, &in_scheme
);
1832 /* no scheme in input, need to see if we need to guess */
1833 if (dwFlags
& URL_APPLY_GUESSSCHEME
) {
1834 if ((ret
= URL_GuessScheme(pszIn
, pszOut
, pcchOut
)) != E_FAIL
)
1839 /* If we are here, then either invalid scheme,
1840 * or no scheme and can't/failed guess.
1842 if ( ( ((res1
== 0) && (dwFlags
& URL_APPLY_FORCEAPPLY
)) ||
1844 (dwFlags
& URL_APPLY_DEFAULT
)) {
1845 /* find and apply default scheme */
1846 return URL_ApplyDefault(pszIn
, pszOut
, pcchOut
);
1852 /*************************************************************************
1853 * UrlIsA [SHLWAPI.@]
1855 * Determine if a Url is of a certain class.
1858 * pszUrl [I] Url to check
1859 * Urlis [I] URLIS_ constant from "shlwapi.h"
1862 * TRUE if pszUrl belongs to the class type in Urlis.
1865 BOOL WINAPI
UrlIsA(LPCSTR pszUrl
, URLIS Urlis
)
1871 TRACE("(%s %d)\n", debugstr_a(pszUrl
), Urlis
);
1879 base
.cbSize
= sizeof(base
);
1880 res1
= ParseURLA(pszUrl
, &base
);
1881 if (res1
) return FALSE
; /* invalid scheme */
1882 switch (base
.nScheme
)
1884 case URL_SCHEME_MAILTO
:
1885 case URL_SCHEME_SHELL
:
1886 case URL_SCHEME_JAVASCRIPT
:
1887 case URL_SCHEME_VBSCRIPT
:
1888 case URL_SCHEME_ABOUT
:
1894 return (CompareStringA(LOCALE_INVARIANT
, NORM_IGNORECASE
, pszUrl
, 5,
1895 "file:", 5) == CSTR_EQUAL
);
1897 case URLIS_DIRECTORY
:
1898 last
= pszUrl
+ strlen(pszUrl
) - 1;
1899 return (last
>= pszUrl
&& (*last
== '/' || *last
== '\\' ));
1902 return PathIsURLA(pszUrl
);
1904 case URLIS_NOHISTORY
:
1905 case URLIS_APPLIABLE
:
1906 case URLIS_HASQUERY
:
1908 FIXME("(%s %d): stub\n", debugstr_a(pszUrl
), Urlis
);
1913 /*************************************************************************
1914 * UrlIsW [SHLWAPI.@]
1918 BOOL WINAPI
UrlIsW(LPCWSTR pszUrl
, URLIS Urlis
)
1920 static const WCHAR file_colon
[] = { 'f','i','l','e',':',0 };
1925 TRACE("(%s %d)\n", debugstr_w(pszUrl
), Urlis
);
1933 base
.cbSize
= sizeof(base
);
1934 res1
= ParseURLW(pszUrl
, &base
);
1935 if (res1
) return FALSE
; /* invalid scheme */
1936 switch (base
.nScheme
)
1938 case URL_SCHEME_MAILTO
:
1939 case URL_SCHEME_SHELL
:
1940 case URL_SCHEME_JAVASCRIPT
:
1941 case URL_SCHEME_VBSCRIPT
:
1942 case URL_SCHEME_ABOUT
:
1948 return (CompareStringW(LOCALE_INVARIANT
, NORM_IGNORECASE
, pszUrl
, 5,
1949 file_colon
, 5) == CSTR_EQUAL
);
1951 case URLIS_DIRECTORY
:
1952 last
= pszUrl
+ strlenW(pszUrl
) - 1;
1953 return (last
>= pszUrl
&& (*last
== '/' || *last
== '\\'));
1956 return PathIsURLW(pszUrl
);
1958 case URLIS_NOHISTORY
:
1959 case URLIS_APPLIABLE
:
1960 case URLIS_HASQUERY
:
1962 FIXME("(%s %d): stub\n", debugstr_w(pszUrl
), Urlis
);
1967 /*************************************************************************
1968 * UrlIsNoHistoryA [SHLWAPI.@]
1970 * Determine if a Url should not be stored in the users history list.
1973 * pszUrl [I] Url to check
1976 * TRUE, if pszUrl should be excluded from the history list,
1979 BOOL WINAPI
UrlIsNoHistoryA(LPCSTR pszUrl
)
1981 return UrlIsA(pszUrl
, URLIS_NOHISTORY
);
1984 /*************************************************************************
1985 * UrlIsNoHistoryW [SHLWAPI.@]
1987 * See UrlIsNoHistoryA.
1989 BOOL WINAPI
UrlIsNoHistoryW(LPCWSTR pszUrl
)
1991 return UrlIsW(pszUrl
, URLIS_NOHISTORY
);
1994 /*************************************************************************
1995 * UrlIsOpaqueA [SHLWAPI.@]
1997 * Determine if a Url is opaque.
2000 * pszUrl [I] Url to check
2003 * TRUE if pszUrl is opaque,
2007 * An opaque Url is one that does not start with "<protocol>://".
2009 BOOL WINAPI
UrlIsOpaqueA(LPCSTR pszUrl
)
2011 return UrlIsA(pszUrl
, URLIS_OPAQUE
);
2014 /*************************************************************************
2015 * UrlIsOpaqueW [SHLWAPI.@]
2019 BOOL WINAPI
UrlIsOpaqueW(LPCWSTR pszUrl
)
2021 return UrlIsW(pszUrl
, URLIS_OPAQUE
);
2024 /*************************************************************************
2025 * Scans for characters of type "type" and when not matching found,
2026 * returns pointer to it and length in size.
2028 * Characters tested based on RFC 1738
2030 static LPCWSTR
URL_ScanID(LPCWSTR start
, LPDWORD size
, WINE_URL_SCAN_TYPE type
)
2032 static DWORD alwayszero
= 0;
2041 if ( (islowerW(*start
) && isalphaW(*start
)) ||
2060 if ( isalphaW(*start
) ||
2062 /* user/password only characters */
2067 /* *extra* characters */
2074 /* *safe* characters */
2083 } else if (*start
== '%') {
2084 if (isxdigitW(*(start
+1)) &&
2085 isxdigitW(*(start
+2))) {
2097 if (isdigitW(*start
)) {
2108 if (isalnumW(*start
) ||
2121 FIXME("unknown type %d\n", type
);
2122 return (LPWSTR
)&alwayszero
;
2124 /* TRACE("scanned %d characters next char %p<%c>\n",
2125 *size, start, *start); */
2129 /*************************************************************************
2130 * Attempt to parse URL into pieces.
2132 static LONG
URL_ParseUrl(LPCWSTR pszUrl
, WINE_PARSE_URL
*pl
)
2136 memset(pl
, 0, sizeof(WINE_PARSE_URL
));
2137 pl
->pScheme
= pszUrl
;
2138 work
= URL_ScanID(pl
->pScheme
, &pl
->szScheme
, SCHEME
);
2139 if (!*work
|| (*work
!= ':')) goto ErrorExit
;
2141 if ((*work
!= '/') || (*(work
+1) != '/')) goto SuccessExit
;
2142 pl
->pUserName
= work
+ 2;
2143 work
= URL_ScanID(pl
->pUserName
, &pl
->szUserName
, USERPASS
);
2144 if (*work
== ':' ) {
2145 /* parse password */
2147 pl
->pPassword
= work
;
2148 work
= URL_ScanID(pl
->pPassword
, &pl
->szPassword
, USERPASS
);
2150 /* what we just parsed must be the hostname and port
2151 * so reset pointers and clear then let it parse */
2152 pl
->szUserName
= pl
->szPassword
= 0;
2153 work
= pl
->pUserName
- 1;
2154 pl
->pUserName
= pl
->pPassword
= 0;
2156 } else if (*work
== '@') {
2160 } else if (!*work
|| (*work
== '/') || (*work
== '.')) {
2161 /* what was parsed was hostname, so reset pointers and let it parse */
2162 pl
->szUserName
= pl
->szPassword
= 0;
2163 work
= pl
->pUserName
- 1;
2164 pl
->pUserName
= pl
->pPassword
= 0;
2165 } else goto ErrorExit
;
2167 /* now start parsing hostname or hostnumber */
2169 pl
->pHostName
= work
;
2170 work
= URL_ScanID(pl
->pHostName
, &pl
->szHostName
, HOST
);
2175 work
= URL_ScanID(pl
->pPort
, &pl
->szPort
, PORT
);
2178 /* see if query string */
2179 pl
->pQuery
= strchrW(work
, '?');
2180 if (pl
->pQuery
) pl
->szQuery
= strlenW(pl
->pQuery
);
2183 TRACE("parse successful: scheme=%p(%d), user=%p(%d), pass=%p(%d), host=%p(%d), port=%p(%d), query=%p(%d)\n",
2184 pl
->pScheme
, pl
->szScheme
,
2185 pl
->pUserName
, pl
->szUserName
,
2186 pl
->pPassword
, pl
->szPassword
,
2187 pl
->pHostName
, pl
->szHostName
,
2188 pl
->pPort
, pl
->szPort
,
2189 pl
->pQuery
, pl
->szQuery
);
2192 FIXME("failed to parse %s\n", debugstr_w(pszUrl
));
2193 return E_INVALIDARG
;
2196 /*************************************************************************
2197 * UrlGetPartA [SHLWAPI.@]
2199 * Retrieve part of a Url.
2202 * pszIn [I] Url to parse
2203 * pszOut [O] Destination for part of pszIn requested
2204 * pcchOut [I] Size of pszOut
2205 * [O] length of pszOut string EXCLUDING '\0' if S_OK, otherwise
2206 * needed size of pszOut INCLUDING '\0'.
2207 * dwPart [I] URL_PART_ enum from "shlwapi.h"
2208 * dwFlags [I] URL_ flags from "shlwapi.h"
2211 * Success: S_OK. pszOut contains the part requested, pcchOut contains its length.
2212 * Failure: An HRESULT error code describing the error.
2214 HRESULT WINAPI
UrlGetPartA(LPCSTR pszIn
, LPSTR pszOut
, LPDWORD pcchOut
,
2215 DWORD dwPart
, DWORD dwFlags
)
2218 DWORD ret
, len
, len2
;
2220 if(!pszIn
|| !pszOut
|| !pcchOut
|| *pcchOut
<= 0)
2221 return E_INVALIDARG
;
2223 in
= HeapAlloc(GetProcessHeap(), 0,
2224 (2*INTERNET_MAX_URL_LENGTH
) * sizeof(WCHAR
));
2225 out
= in
+ INTERNET_MAX_URL_LENGTH
;
2227 MultiByteToWideChar(CP_ACP
, 0, pszIn
, -1, in
, INTERNET_MAX_URL_LENGTH
);
2229 len
= INTERNET_MAX_URL_LENGTH
;
2230 ret
= UrlGetPartW(in
, out
, &len
, dwPart
, dwFlags
);
2233 HeapFree(GetProcessHeap(), 0, in
);
2237 len2
= WideCharToMultiByte(CP_ACP
, 0, out
, len
, NULL
, 0, NULL
, NULL
);
2238 if (len2
> *pcchOut
) {
2240 HeapFree(GetProcessHeap(), 0, in
);
2243 len2
= WideCharToMultiByte(CP_ACP
, 0, out
, len
+1, pszOut
, *pcchOut
, NULL
, NULL
);
2245 HeapFree(GetProcessHeap(), 0, in
);
2249 /*************************************************************************
2250 * UrlGetPartW [SHLWAPI.@]
2254 HRESULT WINAPI
UrlGetPartW(LPCWSTR pszIn
, LPWSTR pszOut
, LPDWORD pcchOut
,
2255 DWORD dwPart
, DWORD dwFlags
)
2259 DWORD scheme
, size
, schsize
;
2260 LPCWSTR addr
, schaddr
;
2262 TRACE("(%s %p %p(%d) %08x %08x)\n",
2263 debugstr_w(pszIn
), pszOut
, pcchOut
, *pcchOut
, dwPart
, dwFlags
);
2265 if(!pszIn
|| !pszOut
|| !pcchOut
|| *pcchOut
<= 0)
2266 return E_INVALIDARG
;
2270 addr
= strchrW(pszIn
, ':');
2272 scheme
= URL_SCHEME_UNKNOWN
;
2274 scheme
= get_scheme_code(pszIn
, addr
-pszIn
);
2276 ret
= URL_ParseUrl(pszIn
, &pl
);
2279 case URL_PART_SCHEME
:
2288 case URL_PART_HOSTNAME
:
2290 case URL_SCHEME_FTP
:
2291 case URL_SCHEME_HTTP
:
2292 case URL_SCHEME_GOPHER
:
2293 case URL_SCHEME_TELNET
:
2294 case URL_SCHEME_FILE
:
2295 case URL_SCHEME_HTTPS
:
2302 if(scheme
==URL_SCHEME_FILE
&& (!pl
.szHostName
||
2303 (pl
.szHostName
==1 && *(pl
.pHostName
+1)==':'))) {
2308 if (!pl
.szHostName
) {
2312 addr
= pl
.pHostName
;
2313 size
= pl
.szHostName
;
2316 case URL_PART_USERNAME
:
2317 if (!pl
.szUserName
) {
2321 addr
= pl
.pUserName
;
2322 size
= pl
.szUserName
;
2325 case URL_PART_PASSWORD
:
2326 if (!pl
.szPassword
) {
2330 addr
= pl
.pPassword
;
2331 size
= pl
.szPassword
;
2343 case URL_PART_QUERY
:
2354 return E_INVALIDARG
;
2357 if (dwFlags
== URL_PARTFLAG_KEEPSCHEME
) {
2358 if(!pl
.pScheme
|| !pl
.szScheme
) {
2362 schaddr
= pl
.pScheme
;
2363 schsize
= pl
.szScheme
;
2364 if (*pcchOut
< schsize
+ size
+ 2) {
2365 *pcchOut
= schsize
+ size
+ 2;
2368 memcpy(pszOut
, schaddr
, schsize
*sizeof(WCHAR
));
2369 pszOut
[schsize
] = ':';
2370 memcpy(pszOut
+schsize
+1, addr
, size
*sizeof(WCHAR
));
2371 pszOut
[schsize
+1+size
] = 0;
2372 *pcchOut
= schsize
+ 1 + size
;
2375 if (*pcchOut
< size
+ 1) {*pcchOut
= size
+1; return E_POINTER
;}
2376 memcpy(pszOut
, addr
, size
*sizeof(WCHAR
));
2380 TRACE("len=%d %s\n", *pcchOut
, debugstr_w(pszOut
));
2385 /*************************************************************************
2386 * PathIsURLA [SHLWAPI.@]
2388 * Check if the given path is a Url.
2391 * lpszPath [I] Path to check.
2394 * TRUE if lpszPath is a Url.
2395 * FALSE if lpszPath is NULL or not a Url.
2397 BOOL WINAPI
PathIsURLA(LPCSTR lpstrPath
)
2402 TRACE("%s\n", debugstr_a(lpstrPath
));
2404 if (!lpstrPath
|| !*lpstrPath
) return FALSE
;
2407 base
.cbSize
= sizeof(base
);
2408 hres
= ParseURLA(lpstrPath
, &base
);
2409 return hres
== S_OK
&& (base
.nScheme
!= URL_SCHEME_INVALID
);
2412 /*************************************************************************
2413 * PathIsURLW [SHLWAPI.@]
2417 BOOL WINAPI
PathIsURLW(LPCWSTR lpstrPath
)
2422 TRACE("%s\n", debugstr_w(lpstrPath
));
2424 if (!lpstrPath
|| !*lpstrPath
) return FALSE
;
2427 base
.cbSize
= sizeof(base
);
2428 hres
= ParseURLW(lpstrPath
, &base
);
2429 return hres
== S_OK
&& (base
.nScheme
!= URL_SCHEME_INVALID
);
2432 /*************************************************************************
2433 * UrlCreateFromPathA [SHLWAPI.@]
2435 * See UrlCreateFromPathW
2437 HRESULT WINAPI
UrlCreateFromPathA(LPCSTR pszPath
, LPSTR pszUrl
, LPDWORD pcchUrl
, DWORD dwReserved
)
2439 WCHAR bufW
[INTERNET_MAX_URL_LENGTH
];
2441 UNICODE_STRING pathW
;
2443 DWORD lenW
= sizeof(bufW
)/sizeof(WCHAR
), lenA
;
2445 if(!RtlCreateUnicodeStringFromAsciiz(&pathW
, pszPath
))
2446 return E_INVALIDARG
;
2447 if((ret
= UrlCreateFromPathW(pathW
.Buffer
, urlW
, &lenW
, dwReserved
)) == E_POINTER
) {
2448 urlW
= HeapAlloc(GetProcessHeap(), 0, lenW
* sizeof(WCHAR
));
2449 ret
= UrlCreateFromPathW(pathW
.Buffer
, urlW
, &lenW
, dwReserved
);
2451 if(ret
== S_OK
|| ret
== S_FALSE
) {
2452 RtlUnicodeToMultiByteSize(&lenA
, urlW
, lenW
* sizeof(WCHAR
));
2453 if(*pcchUrl
> lenA
) {
2454 RtlUnicodeToMultiByteN(pszUrl
, *pcchUrl
- 1, &lenA
, urlW
, lenW
* sizeof(WCHAR
));
2458 *pcchUrl
= lenA
+ 1;
2462 if(urlW
!= bufW
) HeapFree(GetProcessHeap(), 0, urlW
);
2463 RtlFreeUnicodeString(&pathW
);
2467 /*************************************************************************
2468 * UrlCreateFromPathW [SHLWAPI.@]
2470 * Create a Url from a file path.
2473 * pszPath [I] Path to convert
2474 * pszUrl [O] Destination for the converted Url
2475 * pcchUrl [I/O] Length of pszUrl
2476 * dwReserved [I] Reserved, must be 0
2479 * Success: S_OK pszUrl contains the converted path, S_FALSE if the path is already a Url
2480 * Failure: An HRESULT error code.
2482 HRESULT WINAPI
UrlCreateFromPathW(LPCWSTR pszPath
, LPWSTR pszUrl
, LPDWORD pcchUrl
, DWORD dwReserved
)
2486 TRACE("(%s, %p, %p, 0x%08x)\n", debugstr_w(pszPath
), pszUrl
, pcchUrl
, dwReserved
);
2488 /* Validate arguments */
2489 if (dwReserved
!= 0)
2490 return E_INVALIDARG
;
2491 if (!pszUrl
|| !pcchUrl
)
2492 return E_INVALIDARG
;
2494 ret
= URL_CreateFromPath(pszPath
, pszUrl
, pcchUrl
);
2497 strcpyW(pszUrl
, pszPath
);
2502 /*************************************************************************
2503 * SHAutoComplete [SHLWAPI.@]
2505 * Enable auto-completion for an edit control.
2508 * hwndEdit [I] Handle of control to enable auto-completion for
2509 * dwFlags [I] SHACF_ flags from "shlwapi.h"
2512 * Success: S_OK. Auto-completion is enabled for the control.
2513 * Failure: An HRESULT error code indicating the error.
2515 HRESULT WINAPI
SHAutoComplete(HWND hwndEdit
, DWORD dwFlags
)
2521 /*************************************************************************
2522 * MLBuildResURLA [SHLWAPI.405]
2524 * Create a Url pointing to a resource in a module.
2527 * lpszLibName [I] Name of the module containing the resource
2528 * hMod [I] Callers module handle
2529 * dwFlags [I] Undocumented flags for loading the module
2530 * lpszRes [I] Resource name
2531 * lpszDest [O] Destination for resulting Url
2532 * dwDestLen [I] Length of lpszDest
2535 * Success: S_OK. lpszDest contains the resource Url.
2536 * Failure: E_INVALIDARG, if any argument is invalid, or
2537 * E_FAIL if dwDestLen is too small.
2539 HRESULT WINAPI
MLBuildResURLA(LPCSTR lpszLibName
, HMODULE hMod
, DWORD dwFlags
,
2540 LPCSTR lpszRes
, LPSTR lpszDest
, DWORD dwDestLen
)
2542 WCHAR szLibName
[MAX_PATH
], szRes
[MAX_PATH
], szDest
[MAX_PATH
];
2546 MultiByteToWideChar(CP_ACP
, 0, lpszLibName
, -1, szLibName
, sizeof(szLibName
)/sizeof(WCHAR
));
2549 MultiByteToWideChar(CP_ACP
, 0, lpszRes
, -1, szRes
, sizeof(szRes
)/sizeof(WCHAR
));
2551 if (dwDestLen
> sizeof(szLibName
)/sizeof(WCHAR
))
2552 dwDestLen
= sizeof(szLibName
)/sizeof(WCHAR
);
2554 hRet
= MLBuildResURLW(lpszLibName
? szLibName
: NULL
, hMod
, dwFlags
,
2555 lpszRes
? szRes
: NULL
, lpszDest
? szDest
: NULL
, dwDestLen
);
2556 if (SUCCEEDED(hRet
) && lpszDest
)
2557 WideCharToMultiByte(CP_ACP
, 0, szDest
, -1, lpszDest
, dwDestLen
, NULL
, NULL
);
2562 /*************************************************************************
2563 * MLBuildResURLA [SHLWAPI.406]
2565 * See MLBuildResURLA.
2567 HRESULT WINAPI
MLBuildResURLW(LPCWSTR lpszLibName
, HMODULE hMod
, DWORD dwFlags
,
2568 LPCWSTR lpszRes
, LPWSTR lpszDest
, DWORD dwDestLen
)
2570 static const WCHAR szRes
[] = { 'r','e','s',':','/','/','\0' };
2571 #define szResLen ((sizeof(szRes) - sizeof(WCHAR))/sizeof(WCHAR))
2572 HRESULT hRet
= E_FAIL
;
2574 TRACE("(%s,%p,0x%08x,%s,%p,%d)\n", debugstr_w(lpszLibName
), hMod
, dwFlags
,
2575 debugstr_w(lpszRes
), lpszDest
, dwDestLen
);
2577 if (!lpszLibName
|| !hMod
|| hMod
== INVALID_HANDLE_VALUE
|| !lpszRes
||
2578 !lpszDest
|| (dwFlags
&& dwFlags
!= 2))
2579 return E_INVALIDARG
;
2581 if (dwDestLen
>= szResLen
+ 1)
2583 dwDestLen
-= (szResLen
+ 1);
2584 memcpy(lpszDest
, szRes
, sizeof(szRes
));
2586 hMod
= MLLoadLibraryW(lpszLibName
, hMod
, dwFlags
);
2590 WCHAR szBuff
[MAX_PATH
];
2593 len
= GetModuleFileNameW(hMod
, szBuff
, sizeof(szBuff
)/sizeof(WCHAR
));
2594 if (len
&& len
< sizeof(szBuff
)/sizeof(WCHAR
))
2596 DWORD dwPathLen
= strlenW(szBuff
) + 1;
2598 if (dwDestLen
>= dwPathLen
)
2602 dwDestLen
-= dwPathLen
;
2603 memcpy(lpszDest
+ szResLen
, szBuff
, dwPathLen
* sizeof(WCHAR
));
2605 dwResLen
= strlenW(lpszRes
) + 1;
2606 if (dwDestLen
>= dwResLen
+ 1)
2608 lpszDest
[szResLen
+ dwPathLen
-1] = '/';
2609 memcpy(lpszDest
+ szResLen
+ dwPathLen
, lpszRes
, dwResLen
* sizeof(WCHAR
));
2614 MLFreeLibrary(hMod
);
2620 /***********************************************************************
2621 * UrlFixupW [SHLWAPI.462]
2623 * Checks the scheme part of a URL and attempts to correct misspellings.
2626 * lpszUrl [I] Pointer to the URL to be corrected
2627 * lpszTranslatedUrl [O] Pointer to a buffer to store corrected URL
2628 * dwMaxChars [I] Maximum size of corrected URL
2631 * success: S_OK if URL corrected or already correct
2632 * failure: S_FALSE if unable to correct / COM error code if other error
2635 HRESULT WINAPI
UrlFixupW(LPCWSTR url
, LPWSTR translatedUrl
, DWORD maxChars
)
2639 FIXME("(%s,%p,%d) STUB\n", debugstr_w(url
), translatedUrl
, maxChars
);
2644 srcLen
= lstrlenW(url
) + 1;
2646 /* For now just copy the URL directly */
2647 lstrcpynW(translatedUrl
, url
, (maxChars
< srcLen
) ? maxChars
: srcLen
);
2652 /*************************************************************************
2653 * IsInternetESCEnabled [SHLWAPI.@]
2655 BOOL WINAPI
IsInternetESCEnabled(void)