2 * Copyright 2010 Jacek Caban for CodeWeavers
3 * Copyright 2010 Thomas Mullaly
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 #include "urlmon_main.h"
21 #include "wine/debug.h"
23 #define NO_SHLWAPI_REG
28 #define UINT_MAX 0xffffffff
29 #define USHORT_MAX 0xffff
31 #define URI_DISPLAY_NO_ABSOLUTE_URI 0x1
32 #define URI_DISPLAY_NO_DEFAULT_PORT_AUTH 0x2
34 #define ALLOW_NULL_TERM_SCHEME 0x01
35 #define ALLOW_NULL_TERM_USER_NAME 0x02
36 #define ALLOW_NULL_TERM_PASSWORD 0x04
37 #define ALLOW_BRACKETLESS_IP_LITERAL 0x08
38 #define SKIP_IP_FUTURE_CHECK 0x10
39 #define IGNORE_PORT_DELIMITER 0x20
41 #define RAW_URI_FORCE_PORT_DISP 0x1
42 #define RAW_URI_CONVERT_TO_DOS_PATH 0x2
44 #define COMBINE_URI_FORCE_FLAG_USE 0x1
46 WINE_DEFAULT_DEBUG_CHANNEL(urlmon
);
48 static const IID IID_IUriObj
= {0x4b364760,0x9f51,0x11df,{0x98,0x1c,0x08,0x00,0x20,0x0c,0x9a,0x66}};
52 IUriBuilderFactory IUriBuilderFactory_iface
;
58 /* Information about the canonicalized URI's buffer. */
62 BOOL display_modifiers
;
67 URL_SCHEME scheme_type
;
75 Uri_HOST_TYPE host_type
;
98 IUriBuilder IUriBuilder_iface
;
102 DWORD modified_props
;
135 /* IPv6 addresses can hold up to 8 h16 components. */
139 /* An IPv6 can have 1 elision ("::"). */
140 const WCHAR
*elision
;
142 /* An IPv6 can contain 1 IPv4 address as the last 32bits of the address. */
155 BOOL has_implicit_scheme
;
156 BOOL has_implicit_ip
;
161 URL_SCHEME scheme_type
;
163 const WCHAR
*username
;
166 const WCHAR
*password
;
171 Uri_HOST_TYPE host_type
;
174 ipv6_address ipv6_address
;
187 const WCHAR
*fragment
;
191 static const CHAR hexDigits
[] = "0123456789ABCDEF";
193 /* List of scheme types/scheme names that are recognized by the IUri interface as of IE 7. */
194 static const struct {
196 WCHAR scheme_name
[16];
197 } recognized_schemes
[] = {
198 {URL_SCHEME_FTP
, {'f','t','p',0}},
199 {URL_SCHEME_HTTP
, {'h','t','t','p',0}},
200 {URL_SCHEME_GOPHER
, {'g','o','p','h','e','r',0}},
201 {URL_SCHEME_MAILTO
, {'m','a','i','l','t','o',0}},
202 {URL_SCHEME_NEWS
, {'n','e','w','s',0}},
203 {URL_SCHEME_NNTP
, {'n','n','t','p',0}},
204 {URL_SCHEME_TELNET
, {'t','e','l','n','e','t',0}},
205 {URL_SCHEME_WAIS
, {'w','a','i','s',0}},
206 {URL_SCHEME_FILE
, {'f','i','l','e',0}},
207 {URL_SCHEME_MK
, {'m','k',0}},
208 {URL_SCHEME_HTTPS
, {'h','t','t','p','s',0}},
209 {URL_SCHEME_SHELL
, {'s','h','e','l','l',0}},
210 {URL_SCHEME_SNEWS
, {'s','n','e','w','s',0}},
211 {URL_SCHEME_LOCAL
, {'l','o','c','a','l',0}},
212 {URL_SCHEME_JAVASCRIPT
, {'j','a','v','a','s','c','r','i','p','t',0}},
213 {URL_SCHEME_VBSCRIPT
, {'v','b','s','c','r','i','p','t',0}},
214 {URL_SCHEME_ABOUT
, {'a','b','o','u','t',0}},
215 {URL_SCHEME_RES
, {'r','e','s',0}},
216 {URL_SCHEME_MSSHELLROOTED
, {'m','s','-','s','h','e','l','l','-','r','o','o','t','e','d',0}},
217 {URL_SCHEME_MSSHELLIDLIST
, {'m','s','-','s','h','e','l','l','-','i','d','l','i','s','t',0}},
218 {URL_SCHEME_MSHELP
, {'h','c','p',0}},
219 {URL_SCHEME_WILDCARD
, {'*',0}}
222 /* List of default ports Windows recognizes. */
223 static const struct {
226 } default_ports
[] = {
227 {URL_SCHEME_FTP
, 21},
228 {URL_SCHEME_HTTP
, 80},
229 {URL_SCHEME_GOPHER
, 70},
230 {URL_SCHEME_NNTP
, 119},
231 {URL_SCHEME_TELNET
, 23},
232 {URL_SCHEME_WAIS
, 210},
233 {URL_SCHEME_HTTPS
, 443},
236 /* List of 3 character top level domain names Windows seems to recognize.
237 * There might be more, but, these are the only ones I've found so far.
239 static const struct {
241 } recognized_tlds
[] = {
251 static Uri
*get_uri_obj(IUri
*uri
)
256 hres
= IUri_QueryInterface(uri
, &IID_IUriObj
, (void**)&ret
);
257 return SUCCEEDED(hres
) ? ret
: NULL
;
260 static inline BOOL
is_alpha(WCHAR val
) {
261 return ((val
>= 'a' && val
<= 'z') || (val
>= 'A' && val
<= 'Z'));
264 static inline BOOL
is_num(WCHAR val
) {
265 return (val
>= '0' && val
<= '9');
268 static inline BOOL
is_drive_path(const WCHAR
*str
) {
269 return (is_alpha(str
[0]) && (str
[1] == ':' || str
[1] == '|'));
272 static inline BOOL
is_unc_path(const WCHAR
*str
) {
273 return (str
[0] == '\\' && str
[0] == '\\');
276 static inline BOOL
is_forbidden_dos_path_char(WCHAR val
) {
277 return (val
== '>' || val
== '<' || val
== '\"');
280 /* A URI is implicitly a file path if it begins with
281 * a drive letter (eg X:) or starts with "\\" (UNC path).
283 static inline BOOL
is_implicit_file_path(const WCHAR
*str
) {
284 return (is_unc_path(str
) || (is_alpha(str
[0]) && str
[1] == ':'));
287 /* Checks if the URI is a hierarchical URI. A hierarchical
288 * URI is one that has "//" after the scheme.
290 static BOOL
check_hierarchical(const WCHAR
**ptr
) {
291 const WCHAR
*start
= *ptr
;
306 /* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" */
307 static inline BOOL
is_unreserved(WCHAR val
) {
308 return (is_alpha(val
) || is_num(val
) || val
== '-' || val
== '.' ||
309 val
== '_' || val
== '~');
312 /* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
313 * / "*" / "+" / "," / ";" / "="
315 static inline BOOL
is_subdelim(WCHAR val
) {
316 return (val
== '!' || val
== '$' || val
== '&' ||
317 val
== '\'' || val
== '(' || val
== ')' ||
318 val
== '*' || val
== '+' || val
== ',' ||
319 val
== ';' || val
== '=');
322 /* gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" */
323 static inline BOOL
is_gendelim(WCHAR val
) {
324 return (val
== ':' || val
== '/' || val
== '?' ||
325 val
== '#' || val
== '[' || val
== ']' ||
329 /* Characters that delimit the end of the authority
330 * section of a URI. Sometimes a '\\' is considered
331 * an authority delimeter.
333 static inline BOOL
is_auth_delim(WCHAR val
, BOOL acceptSlash
) {
334 return (val
== '#' || val
== '/' || val
== '?' ||
335 val
== '\0' || (acceptSlash
&& val
== '\\'));
338 /* reserved = gen-delims / sub-delims */
339 static inline BOOL
is_reserved(WCHAR val
) {
340 return (is_subdelim(val
) || is_gendelim(val
));
343 static inline BOOL
is_hexdigit(WCHAR val
) {
344 return ((val
>= 'a' && val
<= 'f') ||
345 (val
>= 'A' && val
<= 'F') ||
346 (val
>= '0' && val
<= '9'));
349 static inline BOOL
is_path_delim(WCHAR val
) {
350 return (!val
|| val
== '#' || val
== '?');
353 static inline BOOL
is_slash(WCHAR c
)
355 return c
== '/' || c
== '\\';
358 static BOOL
is_default_port(URL_SCHEME scheme
, DWORD port
) {
361 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
362 if(default_ports
[i
].scheme
== scheme
&& default_ports
[i
].port
)
369 /* List of schemes types Windows seems to expect to be hierarchical. */
370 static inline BOOL
is_hierarchical_scheme(URL_SCHEME type
) {
371 return(type
== URL_SCHEME_HTTP
|| type
== URL_SCHEME_FTP
||
372 type
== URL_SCHEME_GOPHER
|| type
== URL_SCHEME_NNTP
||
373 type
== URL_SCHEME_TELNET
|| type
== URL_SCHEME_WAIS
||
374 type
== URL_SCHEME_FILE
|| type
== URL_SCHEME_HTTPS
||
375 type
== URL_SCHEME_RES
);
378 /* Checks if 'flags' contains an invalid combination of Uri_CREATE flags. */
379 static inline BOOL
has_invalid_flag_combination(DWORD flags
) {
380 return((flags
& Uri_CREATE_DECODE_EXTRA_INFO
&& flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
) ||
381 (flags
& Uri_CREATE_CANONICALIZE
&& flags
& Uri_CREATE_NO_CANONICALIZE
) ||
382 (flags
& Uri_CREATE_CRACK_UNKNOWN_SCHEMES
&& flags
& Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
) ||
383 (flags
& Uri_CREATE_PRE_PROCESS_HTML_URI
&& flags
& Uri_CREATE_NO_PRE_PROCESS_HTML_URI
) ||
384 (flags
& Uri_CREATE_IE_SETTINGS
&& flags
& Uri_CREATE_NO_IE_SETTINGS
));
387 /* Applies each default Uri_CREATE flags to 'flags' if it
388 * doesn't cause a flag conflict.
390 static void apply_default_flags(DWORD
*flags
) {
391 if(!(*flags
& Uri_CREATE_NO_CANONICALIZE
))
392 *flags
|= Uri_CREATE_CANONICALIZE
;
393 if(!(*flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
))
394 *flags
|= Uri_CREATE_DECODE_EXTRA_INFO
;
395 if(!(*flags
& Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
))
396 *flags
|= Uri_CREATE_CRACK_UNKNOWN_SCHEMES
;
397 if(!(*flags
& Uri_CREATE_NO_PRE_PROCESS_HTML_URI
))
398 *flags
|= Uri_CREATE_PRE_PROCESS_HTML_URI
;
399 if(!(*flags
& Uri_CREATE_IE_SETTINGS
))
400 *flags
|= Uri_CREATE_NO_IE_SETTINGS
;
403 /* Determines if the URI is hierarchical using the information already parsed into
404 * data and using the current location of parsing in the URI string.
406 * Windows considers a URI hierarchical if on of the following is true:
407 * A.) It's a wildcard scheme.
408 * B.) It's an implicit file scheme.
409 * C.) It's a known hierarchical scheme and it has two '\\' after the scheme name.
410 * (the '\\' will be converted into "//" during canonicalization).
411 * D.) It's not a relative URI and "//" appears after the scheme name.
413 static inline BOOL
is_hierarchical_uri(const WCHAR
**ptr
, const parse_data
*data
) {
414 const WCHAR
*start
= *ptr
;
416 if(data
->scheme_type
== URL_SCHEME_WILDCARD
)
418 else if(data
->scheme_type
== URL_SCHEME_FILE
&& data
->has_implicit_scheme
)
420 else if(is_hierarchical_scheme(data
->scheme_type
) && (*ptr
)[0] == '\\' && (*ptr
)[1] == '\\') {
423 } else if(!data
->is_relative
&& check_hierarchical(ptr
))
430 /* Checks if the two Uri's are logically equivalent. It's a simple
431 * comparison, since they are both of type Uri, and it can access
432 * the properties of each Uri directly without the need to go
433 * through the "IUri_Get*" interface calls.
435 static BOOL
are_equal_simple(const Uri
*a
, const Uri
*b
) {
436 if(a
->scheme_type
== b
->scheme_type
) {
437 const BOOL known_scheme
= a
->scheme_type
!= URL_SCHEME_UNKNOWN
;
438 const BOOL are_hierarchical
=
439 (a
->authority_start
> -1 && b
->authority_start
> -1);
441 if(a
->scheme_type
== URL_SCHEME_FILE
) {
442 if(a
->canon_len
== b
->canon_len
)
443 return !StrCmpIW(a
->canon_uri
, b
->canon_uri
);
446 /* Only compare the scheme names (if any) if their unknown scheme types. */
448 if((a
->scheme_start
> -1 && b
->scheme_start
> -1) &&
449 (a
->scheme_len
== b
->scheme_len
)) {
450 /* Make sure the schemes are the same. */
451 if(StrCmpNW(a
->canon_uri
+a
->scheme_start
, b
->canon_uri
+b
->scheme_start
, a
->scheme_len
))
453 } else if(a
->scheme_len
!= b
->scheme_len
)
454 /* One of the Uri's has a scheme name, while the other doesn't. */
458 /* If they have a userinfo component, perform case sensitive compare. */
459 if((a
->userinfo_start
> -1 && b
->userinfo_start
> -1) &&
460 (a
->userinfo_len
== b
->userinfo_len
)) {
461 if(StrCmpNW(a
->canon_uri
+a
->userinfo_start
, b
->canon_uri
+b
->userinfo_start
, a
->userinfo_len
))
463 } else if(a
->userinfo_len
!= b
->userinfo_len
)
464 /* One of the Uri's had a userinfo, while the other one doesn't. */
467 /* Check if they have a host name. */
468 if((a
->host_start
> -1 && b
->host_start
> -1) &&
469 (a
->host_len
== b
->host_len
)) {
470 /* Perform a case insensitive compare if they are a known scheme type. */
472 if(StrCmpNIW(a
->canon_uri
+a
->host_start
, b
->canon_uri
+b
->host_start
, a
->host_len
))
474 } else if(StrCmpNW(a
->canon_uri
+a
->host_start
, b
->canon_uri
+b
->host_start
, a
->host_len
))
476 } else if(a
->host_len
!= b
->host_len
)
477 /* One of the Uri's had a host, while the other one didn't. */
480 if(a
->has_port
&& b
->has_port
) {
481 if(a
->port
!= b
->port
)
483 } else if(a
->has_port
|| b
->has_port
)
484 /* One had a port, while the other one didn't. */
487 /* Windows is weird with how it handles paths. For example
488 * One URI could be "http://google.com" (after canonicalization)
489 * and one could be "http://google.com/" and the IsEqual function
490 * would still evaluate to TRUE, but, only if they are both hierarchical
493 if((a
->path_start
> -1 && b
->path_start
> -1) &&
494 (a
->path_len
== b
->path_len
)) {
495 if(StrCmpNW(a
->canon_uri
+a
->path_start
, b
->canon_uri
+b
->path_start
, a
->path_len
))
497 } else if(are_hierarchical
&& a
->path_len
== -1 && b
->path_len
== 0) {
498 if(*(a
->canon_uri
+a
->path_start
) != '/')
500 } else if(are_hierarchical
&& b
->path_len
== 1 && a
->path_len
== 0) {
501 if(*(b
->canon_uri
+b
->path_start
) != '/')
503 } else if(a
->path_len
!= b
->path_len
)
506 /* Compare the query strings of the two URIs. */
507 if((a
->query_start
> -1 && b
->query_start
> -1) &&
508 (a
->query_len
== b
->query_len
)) {
509 if(StrCmpNW(a
->canon_uri
+a
->query_start
, b
->canon_uri
+b
->query_start
, a
->query_len
))
511 } else if(a
->query_len
!= b
->query_len
)
514 if((a
->fragment_start
> -1 && b
->fragment_start
> -1) &&
515 (a
->fragment_len
== b
->fragment_len
)) {
516 if(StrCmpNW(a
->canon_uri
+a
->fragment_start
, b
->canon_uri
+b
->fragment_start
, a
->fragment_len
))
518 } else if(a
->fragment_len
!= b
->fragment_len
)
521 /* If we get here, the two URIs are equivalent. */
528 /* Computes the size of the given IPv6 address.
529 * Each h16 component is 16bits, if there is an IPv4 address, it's
530 * 32bits. If there's an elision it can be 16bits to 128bits, depending
531 * on the number of other components.
533 * Modeled after google-url's CheckIPv6ComponentsSize function
535 static void compute_ipv6_comps_size(ipv6_address
*address
) {
536 address
->components_size
= address
->h16_count
* 2;
539 /* IPv4 address is 4 bytes. */
540 address
->components_size
+= 4;
542 if(address
->elision
) {
543 /* An elision can be anywhere from 2 bytes up to 16 bytes.
544 * It size depends on the size of the h16 and IPv4 components.
546 address
->elision_size
= 16 - address
->components_size
;
547 if(address
->elision_size
< 2)
548 address
->elision_size
= 2;
550 address
->elision_size
= 0;
553 /* Taken from dlls/jscript/lex.c */
554 static int hex_to_int(WCHAR val
) {
555 if(val
>= '0' && val
<= '9')
557 else if(val
>= 'a' && val
<= 'f')
558 return val
- 'a' + 10;
559 else if(val
>= 'A' && val
<= 'F')
560 return val
- 'A' + 10;
565 /* Helper function for converting a percent encoded string
566 * representation of a WCHAR value into its actual WCHAR value. If
567 * the two characters following the '%' aren't valid hex values then
568 * this function returns the NULL character.
571 * "%2E" will result in '.' being returned by this function.
573 static WCHAR
decode_pct_val(const WCHAR
*ptr
) {
576 if(*ptr
== '%' && is_hexdigit(*(ptr
+ 1)) && is_hexdigit(*(ptr
+ 2))) {
577 INT a
= hex_to_int(*(ptr
+ 1));
578 INT b
= hex_to_int(*(ptr
+ 2));
587 /* Helper function for percent encoding a given character
588 * and storing the encoded value into a given buffer (dest).
590 * It's up to the calling function to ensure that there is
591 * at least enough space in 'dest' for the percent encoded
592 * value to be stored (so dest + 3 spaces available).
594 static inline void pct_encode_val(WCHAR val
, WCHAR
*dest
) {
596 dest
[1] = hexDigits
[(val
>> 4) & 0xf];
597 dest
[2] = hexDigits
[val
& 0xf];
600 /* Scans the range of characters [str, end] and returns the last occurrence
601 * of 'ch' or returns NULL.
603 static const WCHAR
*str_last_of(const WCHAR
*str
, const WCHAR
*end
, WCHAR ch
) {
604 const WCHAR
*ptr
= end
;
615 /* Attempts to parse the domain name from the host.
617 * This function also includes the Top-level Domain (TLD) name
618 * of the host when it tries to find the domain name. If it finds
619 * a valid domain name it will assign 'domain_start' the offset
620 * into 'host' where the domain name starts.
622 * It's implied that if there is a domain name its range is:
623 * [host+domain_start, host+host_len).
625 static void find_domain_name(const WCHAR
*host
, DWORD host_len
,
627 const WCHAR
*last_tld
, *sec_last_tld
, *end
;
629 end
= host
+host_len
-1;
633 /* There has to be at least enough room for a '.' followed by a
634 * 3 character TLD for a domain to even exist in the host name.
639 last_tld
= str_last_of(host
, end
, '.');
641 /* http://hostname -> has no domain name. */
644 sec_last_tld
= str_last_of(host
, last_tld
-1, '.');
646 /* If the '.' is at the beginning of the host there
647 * has to be at least 3 characters in the TLD for it
649 * Ex: .com -> .com as the domain name.
650 * .co -> has no domain name.
652 if(last_tld
-host
== 0) {
653 if(end
-(last_tld
-1) < 3)
655 } else if(last_tld
-host
== 3) {
658 /* If there's three characters in front of last_tld and
659 * they are on the list of recognized TLDs, then this
660 * host doesn't have a domain (since the host only contains
662 * Ex: edu.uk -> has no domain name.
663 * foo.uk -> foo.uk as the domain name.
665 for(i
= 0; i
< sizeof(recognized_tlds
)/sizeof(recognized_tlds
[0]); ++i
) {
666 if(!StrCmpNIW(host
, recognized_tlds
[i
].tld_name
, 3))
669 } else if(last_tld
-host
< 3)
670 /* Anything less than 3 characters is considered part
672 * Ex: ak.uk -> Has no domain name.
676 /* Otherwise the domain name is the whole host name. */
678 } else if(end
+1-last_tld
> 3) {
679 /* If the last_tld has more than 3 characters, then it's automatically
680 * considered the TLD of the domain name.
681 * Ex: www.winehq.org.uk.test -> uk.test as the domain name.
683 *domain_start
= (sec_last_tld
+1)-host
;
684 } else if(last_tld
- (sec_last_tld
+1) < 4) {
686 /* If the sec_last_tld is 3 characters long it HAS to be on the list of
687 * recognized to still be considered part of the TLD name, otherwise
688 * its considered the domain name.
689 * Ex: www.google.com.uk -> google.com.uk as the domain name.
690 * www.google.foo.uk -> foo.uk as the domain name.
692 if(last_tld
- (sec_last_tld
+1) == 3) {
693 for(i
= 0; i
< sizeof(recognized_tlds
)/sizeof(recognized_tlds
[0]); ++i
) {
694 if(!StrCmpNIW(sec_last_tld
+1, recognized_tlds
[i
].tld_name
, 3)) {
695 const WCHAR
*domain
= str_last_of(host
, sec_last_tld
-1, '.');
700 *domain_start
= (domain
+1) - host
;
701 TRACE("Found domain name %s\n", debugstr_wn(host
+*domain_start
,
702 (host
+host_len
)-(host
+*domain_start
)));
707 *domain_start
= (sec_last_tld
+1)-host
;
709 /* Since the sec_last_tld is less than 3 characters it's considered
711 * Ex: www.google.fo.uk -> google.fo.uk as the domain name.
713 const WCHAR
*domain
= str_last_of(host
, sec_last_tld
-1, '.');
718 *domain_start
= (domain
+1) - host
;
721 /* The second to last TLD has more than 3 characters making it
723 * Ex: www.google.test.us -> test.us as the domain name.
725 *domain_start
= (sec_last_tld
+1)-host
;
728 TRACE("Found domain name %s\n", debugstr_wn(host
+*domain_start
,
729 (host
+host_len
)-(host
+*domain_start
)));
732 /* Removes the dot segments from a hierarchical URIs path component. This
733 * function performs the removal in place.
735 * This function returns the new length of the path string.
737 static DWORD
remove_dot_segments(WCHAR
*path
, DWORD path_len
) {
739 const WCHAR
*in
= out
;
740 const WCHAR
*end
= out
+ path_len
;
744 /* Move the first path segment in the input buffer to the end of
745 * the output buffer, and any subsequent characters up to, including
746 * the next "/" character (if any) or the end of the input buffer.
748 while(in
< end
&& !is_slash(*in
))
758 /* Handle ending "/." */
765 if(is_slash(in
[1])) {
770 /* If we don't have "/../" or ending "/.." */
771 if(in
[1] != '.' || (in
+ 2 != end
&& !is_slash(in
[2])))
774 /* Find the slash preceding out pointer and move out pointer to it */
775 if(out
> path
+1 && is_slash(*--out
))
777 while(out
> path
&& !is_slash(*(--out
)));
787 TRACE("(%p %d): Path after dot segments removed %s len=%d\n", path
, path_len
,
788 debugstr_wn(path
, len
), len
);
792 /* Attempts to find the file extension in a given path. */
793 static INT
find_file_extension(const WCHAR
*path
, DWORD path_len
) {
796 for(end
= path
+path_len
-1; end
>= path
&& *end
!= '/' && *end
!= '\\'; --end
) {
804 /* Computes the location where the elision should occur in the IPv6
805 * address using the numerical values of each component stored in
806 * 'values'. If the address shouldn't contain an elision then 'index'
807 * is assigned -1 as it's value. Otherwise 'index' will contain the
808 * starting index (into values) where the elision should be, and 'count'
809 * will contain the number of cells the elision covers.
812 * Windows will expand an elision if the elision only represents 1 h16
813 * component of the address.
815 * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
817 * If the IPv6 address contains an IPv4 address, the IPv4 address is also
818 * considered for being included as part of an elision if all its components
821 * Ex: [1:2:3:4:5:6:0.0.0.0] -> [1:2:3:4:5:6::]
823 static void compute_elision_location(const ipv6_address
*address
, const USHORT values
[8],
824 INT
*index
, DWORD
*count
) {
825 DWORD i
, max_len
, cur_len
;
826 INT max_index
, cur_index
;
828 max_len
= cur_len
= 0;
829 max_index
= cur_index
= -1;
830 for(i
= 0; i
< 8; ++i
) {
831 BOOL check_ipv4
= (address
->ipv4
&& i
== 6);
832 BOOL is_end
= (check_ipv4
|| i
== 7);
835 /* Check if the IPv4 address contains only zeros. */
836 if(values
[i
] == 0 && values
[i
+1] == 0) {
843 } else if(values
[i
] == 0) {
850 if(is_end
|| values
[i
] != 0) {
851 /* We only consider it for an elision if it's
852 * more than 1 component long.
854 if(cur_len
> 1 && cur_len
> max_len
) {
855 /* Found the new elision location. */
857 max_index
= cur_index
;
860 /* Reset the current range for the next range of zeros. */
870 /* Removes all the leading and trailing white spaces or
871 * control characters from the URI and removes all control
872 * characters inside of the URI string.
874 static BSTR
pre_process_uri(LPCWSTR uri
) {
877 const WCHAR
*start
, *end
;
883 /* Skip leading controls and whitespace. */
884 while(iscntrlW(*start
) || isspaceW(*start
)) ++start
;
888 /* URI consisted only of control/whitespace. */
889 ret
= SysAllocStringLen(NULL
, 0);
891 while(iscntrlW(*end
) || isspaceW(*end
)) --end
;
893 buf
= heap_alloc(((end
+1)-start
)*sizeof(WCHAR
));
897 for(ptr
= buf
; start
< end
+1; ++start
) {
898 if(!iscntrlW(*start
))
902 ret
= SysAllocStringLen(buf
, ptr
-buf
);
909 /* Converts the specified IPv4 address into an uint value.
911 * This function assumes that the IPv4 address has already been validated.
913 static UINT
ipv4toui(const WCHAR
*ip
, DWORD len
) {
915 DWORD comp_value
= 0;
918 for(ptr
= ip
; ptr
< ip
+len
; ++ptr
) {
924 comp_value
= comp_value
*10 + (*ptr
-'0');
933 /* Converts an IPv4 address in numerical form into it's fully qualified
934 * string form. This function returns the number of characters written
935 * to 'dest'. If 'dest' is NULL this function will return the number of
936 * characters that would have been written.
938 * It's up to the caller to ensure there's enough space in 'dest' for the
941 static DWORD
ui2ipv4(WCHAR
*dest
, UINT address
) {
942 static const WCHAR formatW
[] =
943 {'%','u','.','%','u','.','%','u','.','%','u',0};
947 digits
[0] = (address
>> 24) & 0xff;
948 digits
[1] = (address
>> 16) & 0xff;
949 digits
[2] = (address
>> 8) & 0xff;
950 digits
[3] = address
& 0xff;
954 ret
= sprintfW(tmp
, formatW
, digits
[0], digits
[1], digits
[2], digits
[3]);
956 ret
= sprintfW(dest
, formatW
, digits
[0], digits
[1], digits
[2], digits
[3]);
961 static DWORD
ui2str(WCHAR
*dest
, UINT value
) {
962 static const WCHAR formatW
[] = {'%','u',0};
967 ret
= sprintfW(tmp
, formatW
, value
);
969 ret
= sprintfW(dest
, formatW
, value
);
974 /* Converts an h16 component (from an IPv6 address) into it's
977 * This function assumes that the h16 component has already been validated.
979 static USHORT
h16tous(h16 component
) {
983 for(i
= 0; i
< component
.len
; ++i
) {
985 ret
+= hex_to_int(component
.str
[i
]);
991 /* Converts an IPv6 address into its 128 bits (16 bytes) numerical value.
993 * This function assumes that the ipv6_address has already been validated.
995 static BOOL
ipv6_to_number(const ipv6_address
*address
, USHORT number
[8]) {
996 DWORD i
, cur_component
= 0;
997 BOOL already_passed_elision
= FALSE
;
999 for(i
= 0; i
< address
->h16_count
; ++i
) {
1000 if(address
->elision
) {
1001 if(address
->components
[i
].str
> address
->elision
&& !already_passed_elision
) {
1002 /* Means we just passed the elision and need to add its values to
1003 * 'number' before we do anything else.
1006 for(j
= 0; j
< address
->elision_size
; j
+=2)
1007 number
[cur_component
++] = 0;
1009 already_passed_elision
= TRUE
;
1013 number
[cur_component
++] = h16tous(address
->components
[i
]);
1016 /* Case when the elision appears after the h16 components. */
1017 if(!already_passed_elision
&& address
->elision
) {
1018 for(i
= 0; i
< address
->elision_size
; i
+=2)
1019 number
[cur_component
++] = 0;
1023 UINT value
= ipv4toui(address
->ipv4
, address
->ipv4_len
);
1025 if(cur_component
!= 6) {
1026 ERR("(%p %p): Failed sanity check with %d\n", address
, number
, cur_component
);
1030 number
[cur_component
++] = (value
>> 16) & 0xffff;
1031 number
[cur_component
] = value
& 0xffff;
1037 /* Checks if the characters pointed to by 'ptr' are
1038 * a percent encoded data octet.
1040 * pct-encoded = "%" HEXDIG HEXDIG
1042 static BOOL
check_pct_encoded(const WCHAR
**ptr
) {
1043 const WCHAR
*start
= *ptr
;
1049 if(!is_hexdigit(**ptr
)) {
1055 if(!is_hexdigit(**ptr
)) {
1064 /* dec-octet = DIGIT ; 0-9
1065 * / %x31-39 DIGIT ; 10-99
1066 * / "1" 2DIGIT ; 100-199
1067 * / "2" %x30-34 DIGIT ; 200-249
1068 * / "25" %x30-35 ; 250-255
1070 static BOOL
check_dec_octet(const WCHAR
**ptr
) {
1071 const WCHAR
*c1
, *c2
, *c3
;
1074 /* A dec-octet must be at least 1 digit long. */
1075 if(*c1
< '0' || *c1
> '9')
1081 /* Since the 1 digit requirment was meet, it doesn't
1082 * matter if this is a DIGIT value, it's considered a
1085 if(*c2
< '0' || *c2
> '9')
1091 /* Same explanation as above. */
1092 if(*c3
< '0' || *c3
> '9')
1095 /* Anything > 255 isn't a valid IP dec-octet. */
1096 if(*c1
>= '2' && *c2
>= '5' && *c3
>= '5') {
1105 /* Checks if there is an implicit IPv4 address in the host component of the URI.
1106 * The max value of an implicit IPv4 address is UINT_MAX.
1109 * "234567" would be considered an implicit IPv4 address.
1111 static BOOL
check_implicit_ipv4(const WCHAR
**ptr
, UINT
*val
) {
1112 const WCHAR
*start
= *ptr
;
1116 while(is_num(**ptr
)) {
1117 ret
= ret
*10 + (**ptr
- '0');
1119 if(ret
> UINT_MAX
) {
1133 /* Checks if the string contains an IPv4 address.
1135 * This function has a strict mode or a non-strict mode of operation
1136 * When 'strict' is set to FALSE this function will return TRUE if
1137 * the string contains at least 'dec-octet "." dec-octet' since partial
1138 * IPv4 addresses will be normalized out into full IPv4 addresses. When
1139 * 'strict' is set this function expects there to be a full IPv4 address.
1141 * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
1143 static BOOL
check_ipv4address(const WCHAR
**ptr
, BOOL strict
) {
1144 const WCHAR
*start
= *ptr
;
1146 if(!check_dec_octet(ptr
)) {
1157 if(!check_dec_octet(ptr
)) {
1171 if(!check_dec_octet(ptr
)) {
1185 if(!check_dec_octet(ptr
)) {
1190 /* Found a four digit ip address. */
1193 /* Tries to parse the scheme name of the URI.
1195 * scheme = ALPHA *(ALPHA | NUM | '+' | '-' | '.') as defined by RFC 3896.
1196 * NOTE: Windows accepts a number as the first character of a scheme.
1198 static BOOL
parse_scheme_name(const WCHAR
**ptr
, parse_data
*data
, DWORD extras
) {
1199 const WCHAR
*start
= *ptr
;
1201 data
->scheme
= NULL
;
1202 data
->scheme_len
= 0;
1205 if(**ptr
== '*' && *ptr
== start
) {
1206 /* Might have found a wildcard scheme. If it is the next
1207 * char has to be a ':' for it to be a valid URI
1211 } else if(!is_num(**ptr
) && !is_alpha(**ptr
) && **ptr
!= '+' &&
1212 **ptr
!= '-' && **ptr
!= '.')
1221 /* Schemes must end with a ':' */
1222 if(**ptr
!= ':' && !((extras
& ALLOW_NULL_TERM_SCHEME
) && !**ptr
)) {
1227 data
->scheme
= start
;
1228 data
->scheme_len
= *ptr
- start
;
1234 /* Tries to deduce the corresponding URL_SCHEME for the given URI. Stores
1235 * the deduced URL_SCHEME in data->scheme_type.
1237 static BOOL
parse_scheme_type(parse_data
*data
) {
1238 /* If there's scheme data then see if it's a recognized scheme. */
1239 if(data
->scheme
&& data
->scheme_len
) {
1242 for(i
= 0; i
< sizeof(recognized_schemes
)/sizeof(recognized_schemes
[0]); ++i
) {
1243 if(lstrlenW(recognized_schemes
[i
].scheme_name
) == data
->scheme_len
) {
1244 /* Has to be a case insensitive compare. */
1245 if(!StrCmpNIW(recognized_schemes
[i
].scheme_name
, data
->scheme
, data
->scheme_len
)) {
1246 data
->scheme_type
= recognized_schemes
[i
].scheme
;
1252 /* If we get here it means it's not a recognized scheme. */
1253 data
->scheme_type
= URL_SCHEME_UNKNOWN
;
1255 } else if(data
->is_relative
) {
1256 /* Relative URI's have no scheme. */
1257 data
->scheme_type
= URL_SCHEME_UNKNOWN
;
1260 /* Should never reach here! what happened... */
1261 FIXME("(%p): Unable to determine scheme type for URI %s\n", data
, debugstr_w(data
->uri
));
1266 /* Tries to parse (or deduce) the scheme_name of a URI. If it can't
1267 * parse a scheme from the URI it will try to deduce the scheme_name and scheme_type
1268 * using the flags specified in 'flags' (if any). Flags that affect how this function
1269 * operates are the Uri_CREATE_ALLOW_* flags.
1271 * All parsed/deduced information will be stored in 'data' when the function returns.
1273 * Returns TRUE if it was able to successfully parse the information.
1275 static BOOL
parse_scheme(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1276 static const WCHAR fileW
[] = {'f','i','l','e',0};
1277 static const WCHAR wildcardW
[] = {'*',0};
1279 /* First check to see if the uri could implicitly be a file path. */
1280 if(is_implicit_file_path(*ptr
)) {
1281 if(flags
& Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME
) {
1282 data
->scheme
= fileW
;
1283 data
->scheme_len
= lstrlenW(fileW
);
1284 data
->has_implicit_scheme
= TRUE
;
1286 TRACE("(%p %p %x): URI is an implicit file path.\n", ptr
, data
, flags
);
1288 /* Window's does not consider anything that can implicitly be a file
1289 * path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set...
1291 TRACE("(%p %p %x): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n",
1295 } else if(!parse_scheme_name(ptr
, data
, extras
)) {
1296 /* No Scheme was found, this means it could be:
1297 * a) an implicit Wildcard scheme
1301 if(flags
& Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME
) {
1302 data
->scheme
= wildcardW
;
1303 data
->scheme_len
= lstrlenW(wildcardW
);
1304 data
->has_implicit_scheme
= TRUE
;
1306 TRACE("(%p %p %x): URI is an implicit wildcard scheme.\n", ptr
, data
, flags
);
1307 } else if (flags
& Uri_CREATE_ALLOW_RELATIVE
) {
1308 data
->is_relative
= TRUE
;
1309 TRACE("(%p %p %x): URI is relative.\n", ptr
, data
, flags
);
1311 TRACE("(%p %p %x): Malformed URI found. Unable to deduce scheme name.\n", ptr
, data
, flags
);
1316 if(!data
->is_relative
)
1317 TRACE("(%p %p %x): Found scheme=%s scheme_len=%d\n", ptr
, data
, flags
,
1318 debugstr_wn(data
->scheme
, data
->scheme_len
), data
->scheme_len
);
1320 if(!parse_scheme_type(data
))
1323 TRACE("(%p %p %x): Assigned %d as the URL_SCHEME.\n", ptr
, data
, flags
, data
->scheme_type
);
1327 static BOOL
parse_username(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1328 data
->username
= *ptr
;
1330 while(**ptr
!= ':' && **ptr
!= '@') {
1332 if(!check_pct_encoded(ptr
)) {
1333 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1334 *ptr
= data
->username
;
1335 data
->username
= NULL
;
1340 } else if(extras
& ALLOW_NULL_TERM_USER_NAME
&& !**ptr
)
1342 else if(is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)) {
1343 *ptr
= data
->username
;
1344 data
->username
= NULL
;
1351 data
->username_len
= *ptr
- data
->username
;
1355 static BOOL
parse_password(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1356 data
->password
= *ptr
;
1358 while(**ptr
!= '@') {
1360 if(!check_pct_encoded(ptr
)) {
1361 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1362 *ptr
= data
->password
;
1363 data
->password
= NULL
;
1368 } else if(extras
& ALLOW_NULL_TERM_PASSWORD
&& !**ptr
)
1370 else if(is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)) {
1371 *ptr
= data
->password
;
1372 data
->password
= NULL
;
1379 data
->password_len
= *ptr
- data
->password
;
1383 /* Parses the userinfo part of the URI (if it exists). The userinfo field of
1384 * a URI can consist of "username:password@", or just "username@".
1387 * userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
1390 * 1) If there is more than one ':' in the userinfo part of the URI Windows
1391 * uses the first occurrence of ':' to delimit the username and password
1395 * ftp://user:pass:word@winehq.org
1397 * Would yield, "user" as the username and "pass:word" as the password.
1399 * 2) Windows allows any character to appear in the "userinfo" part of
1400 * a URI, as long as it's not an authority delimeter character set.
1402 static void parse_userinfo(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1403 const WCHAR
*start
= *ptr
;
1405 if(!parse_username(ptr
, data
, flags
, 0)) {
1406 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr
, data
, flags
);
1412 if(!parse_password(ptr
, data
, flags
, 0)) {
1414 data
->username
= NULL
;
1415 data
->username_len
= 0;
1416 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr
, data
, flags
);
1423 data
->username
= NULL
;
1424 data
->username_len
= 0;
1425 data
->password
= NULL
;
1426 data
->password_len
= 0;
1428 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr
, data
, flags
);
1433 TRACE("(%p %p %x): Found username %s len=%d.\n", ptr
, data
, flags
,
1434 debugstr_wn(data
->username
, data
->username_len
), data
->username_len
);
1437 TRACE("(%p %p %x): Found password %s len=%d.\n", ptr
, data
, flags
,
1438 debugstr_wn(data
->password
, data
->password_len
), data
->password_len
);
1443 /* Attempts to parse a port from the URI.
1446 * Windows seems to have a cap on what the maximum value
1447 * for a port can be. The max value is USHORT_MAX.
1451 static BOOL
parse_port(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1455 while(!is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)) {
1456 if(!is_num(**ptr
)) {
1462 port
= port
*10 + (**ptr
-'0');
1464 if(port
> USHORT_MAX
) {
1473 data
->has_port
= TRUE
;
1474 data
->port_value
= port
;
1475 data
->port_len
= *ptr
- data
->port
;
1477 TRACE("(%p %p %x): Found port %s len=%d value=%u\n", ptr
, data
, flags
,
1478 debugstr_wn(data
->port
, data
->port_len
), data
->port_len
, data
->port_value
);
1482 /* Attempts to parse a IPv4 address from the URI.
1485 * Window's normalizes IPv4 addresses, This means there's three
1486 * possibilities for the URI to contain an IPv4 address.
1487 * 1) A well formed address (ex. 192.2.2.2).
1488 * 2) A partially formed address. For example "192.0" would
1489 * normalize to "192.0.0.0" during canonicalization.
1490 * 3) An implicit IPv4 address. For example "256" would
1491 * normalize to "0.0.1.0" during canonicalization. Also
1492 * note that the maximum value for an implicit IP address
1493 * is UINT_MAX, if the value in the URI exceeds this then
1494 * it is not considered an IPv4 address.
1496 static BOOL
parse_ipv4address(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1497 const BOOL is_unknown
= data
->scheme_type
== URL_SCHEME_UNKNOWN
;
1500 if(!check_ipv4address(ptr
, FALSE
)) {
1501 if(!check_implicit_ipv4(ptr
, &data
->implicit_ipv4
)) {
1502 TRACE("(%p %p %x): URI didn't contain anything looking like an IPv4 address.\n",
1508 data
->has_implicit_ip
= TRUE
;
1511 /* Check if what we found is the only part of the host name (if it isn't
1512 * we don't have an IPv4 address).
1516 if(!parse_port(ptr
, data
, flags
)) {
1521 } else if(!is_auth_delim(**ptr
, !is_unknown
)) {
1522 /* Found more data which belongs the host, so this isn't an IPv4. */
1525 data
->has_implicit_ip
= FALSE
;
1529 data
->host_len
= *ptr
- data
->host
;
1530 data
->host_type
= Uri_HOST_IPV4
;
1532 TRACE("(%p %p %x): IPv4 address found. host=%s host_len=%d host_type=%d\n",
1533 ptr
, data
, flags
, debugstr_wn(data
->host
, data
->host_len
),
1534 data
->host_len
, data
->host_type
);
1538 /* Attempts to parse the reg-name from the URI.
1540 * Because of the way Windows handles ':' this function also
1541 * handles parsing the port.
1543 * reg-name = *( unreserved / pct-encoded / sub-delims )
1546 * Windows allows everything, but, the characters in "auth_delims" and ':'
1547 * to appear in a reg-name, unless it's an unknown scheme type then ':' is
1548 * allowed to appear (even if a valid port isn't after it).
1550 * Windows doesn't like host names which start with '[' and end with ']'
1551 * and don't contain a valid IP literal address in between them.
1553 * On Windows if an '[' is encountered in the host name the ':' no longer
1554 * counts as a delimiter until you reach the next ']' or an "authority delimeter".
1556 * A reg-name CAN be empty.
1558 static BOOL
parse_reg_name(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1559 const BOOL has_start_bracket
= **ptr
== '[';
1560 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
1561 const BOOL is_res
= data
->scheme_type
== URL_SCHEME_RES
;
1562 BOOL inside_brackets
= has_start_bracket
;
1564 /* res URIs don't have ports. */
1565 BOOL ignore_col
= (extras
& IGNORE_PORT_DELIMITER
) || is_res
;
1567 /* We have to be careful with file schemes. */
1568 if(data
->scheme_type
== URL_SCHEME_FILE
) {
1569 /* This is because an implicit file scheme could be "C:\\test" and it
1570 * would trick this function into thinking the host is "C", when after
1571 * canonicalization the host would end up being an empty string. A drive
1572 * path can also have a '|' instead of a ':' after the drive letter.
1574 if(is_drive_path(*ptr
)) {
1575 /* Regular old drive paths don't have a host type (or host name). */
1576 data
->host_type
= Uri_HOST_UNKNOWN
;
1580 } else if(is_unc_path(*ptr
))
1581 /* Skip past the "\\" of a UNC path. */
1587 /* For res URIs, everything before the first '/' is
1588 * considered the host.
1590 while((!is_res
&& !is_auth_delim(**ptr
, known_scheme
)) ||
1591 (is_res
&& **ptr
&& **ptr
!= '/')) {
1592 if(**ptr
== ':' && !ignore_col
) {
1593 /* We can ignore ':' if were inside brackets.*/
1594 if(!inside_brackets
) {
1595 const WCHAR
*tmp
= (*ptr
)++;
1597 /* Attempt to parse the port. */
1598 if(!parse_port(ptr
, data
, flags
)) {
1599 /* Windows expects there to be a valid port for known scheme types. */
1600 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1603 TRACE("(%p %p %x %x): Expected valid port\n", ptr
, data
, flags
, extras
);
1606 /* Windows gives up on trying to parse a port when it
1607 * encounters 1 invalid port.
1611 data
->host_len
= tmp
- data
->host
;
1615 } else if(**ptr
== '%' && (known_scheme
&& !is_res
)) {
1616 /* Has to be a legit % encoded value. */
1617 if(!check_pct_encoded(ptr
)) {
1623 } else if(is_res
&& is_forbidden_dos_path_char(**ptr
)) {
1627 } else if(**ptr
== ']')
1628 inside_brackets
= FALSE
;
1629 else if(**ptr
== '[')
1630 inside_brackets
= TRUE
;
1635 if(has_start_bracket
) {
1636 /* Make sure the last character of the host wasn't a ']'. */
1637 if(*(*ptr
-1) == ']') {
1638 TRACE("(%p %p %x %x): Expected an IP literal inside of the host\n",
1639 ptr
, data
, flags
, extras
);
1646 /* Don't overwrite our length if we found a port earlier. */
1648 data
->host_len
= *ptr
- data
->host
;
1650 /* If the host is empty, then it's an unknown host type. */
1651 if(data
->host_len
== 0 || is_res
)
1652 data
->host_type
= Uri_HOST_UNKNOWN
;
1654 data
->host_type
= Uri_HOST_DNS
;
1656 TRACE("(%p %p %x %x): Parsed reg-name. host=%s len=%d\n", ptr
, data
, flags
, extras
,
1657 debugstr_wn(data
->host
, data
->host_len
), data
->host_len
);
1661 /* Attempts to parse an IPv6 address out of the URI.
1663 * IPv6address = 6( h16 ":" ) ls32
1664 * / "::" 5( h16 ":" ) ls32
1665 * / [ h16 ] "::" 4( h16 ":" ) ls32
1666 * / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
1667 * / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
1668 * / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
1669 * / [ *4( h16 ":" ) h16 ] "::" ls32
1670 * / [ *5( h16 ":" ) h16 ] "::" h16
1671 * / [ *6( h16 ":" ) h16 ] "::"
1673 * ls32 = ( h16 ":" h16 ) / IPv4address
1674 * ; least-significant 32 bits of address.
1677 * ; 16 bits of address represented in hexadecimal.
1679 * Modeled after google-url's 'DoParseIPv6' function.
1681 static BOOL
parse_ipv6address(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1682 const WCHAR
*start
, *cur_start
;
1685 start
= cur_start
= *ptr
;
1686 memset(&ip
, 0, sizeof(ipv6_address
));
1689 /* Check if we're on the last character of the host. */
1690 BOOL is_end
= (is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)
1693 BOOL is_split
= (**ptr
== ':');
1694 BOOL is_elision
= (is_split
&& !is_end
&& *(*ptr
+1) == ':');
1696 /* Check if we're at the end of a component, or
1697 * if we're at the end of the IPv6 address.
1699 if(is_split
|| is_end
) {
1702 cur_len
= *ptr
- cur_start
;
1704 /* h16 can't have a length > 4. */
1708 TRACE("(%p %p %x): h16 component to long.\n",
1714 /* An h16 component can't have the length of 0 unless
1715 * the elision is at the beginning of the address, or
1716 * at the end of the address.
1718 if(!((*ptr
== start
&& is_elision
) ||
1719 (is_end
&& (*ptr
-2) == ip
.elision
))) {
1721 TRACE("(%p %p %x): IPv6 component cannot have a length of 0.\n",
1728 /* An IPv6 address can have no more than 8 h16 components. */
1729 if(ip
.h16_count
>= 8) {
1731 TRACE("(%p %p %x): Not a IPv6 address, to many h16 components.\n",
1736 ip
.components
[ip
.h16_count
].str
= cur_start
;
1737 ip
.components
[ip
.h16_count
].len
= cur_len
;
1739 TRACE("(%p %p %x): Found h16 component %s, len=%d, h16_count=%d\n",
1740 ptr
, data
, flags
, debugstr_wn(cur_start
, cur_len
), cur_len
,
1750 /* A IPv6 address can only have 1 elision ('::'). */
1754 TRACE("(%p %p %x): IPv6 address cannot have 2 elisions.\n",
1766 if(!check_ipv4address(ptr
, TRUE
)) {
1767 if(!is_hexdigit(**ptr
)) {
1768 /* Not a valid character for an IPv6 address. */
1773 /* Found an IPv4 address. */
1774 ip
.ipv4
= cur_start
;
1775 ip
.ipv4_len
= *ptr
- cur_start
;
1777 TRACE("(%p %p %x): Found an attached IPv4 address %s len=%d.\n",
1778 ptr
, data
, flags
, debugstr_wn(ip
.ipv4
, ip
.ipv4_len
),
1781 /* IPv4 addresses can only appear at the end of a IPv6. */
1787 compute_ipv6_comps_size(&ip
);
1789 /* Make sure the IPv6 address adds up to 16 bytes. */
1790 if(ip
.components_size
+ ip
.elision_size
!= 16) {
1792 TRACE("(%p %p %x): Invalid IPv6 address, did not add up to 16 bytes.\n",
1797 if(ip
.elision_size
== 2) {
1798 /* For some reason on Windows if an elision that represents
1799 * only 1 h16 component is encountered at the very begin or
1800 * end of an IPv6 address, Windows does not consider it a
1801 * valid IPv6 address.
1803 * Ex: [::2:3:4:5:6:7] is not valid, even though the sum
1804 * of all the components == 128bits.
1806 if(ip
.elision
< ip
.components
[0].str
||
1807 ip
.elision
> ip
.components
[ip
.h16_count
-1].str
) {
1809 TRACE("(%p %p %x): Invalid IPv6 address. Detected elision of 2 bytes at the beginning or end of the address.\n",
1815 data
->host_type
= Uri_HOST_IPV6
;
1816 data
->has_ipv6
= TRUE
;
1817 data
->ipv6_address
= ip
;
1819 TRACE("(%p %p %x): Found valid IPv6 literal %s len=%d\n",
1820 ptr
, data
, flags
, debugstr_wn(start
, *ptr
-start
),
1825 /* IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" ) */
1826 static BOOL
parse_ipvfuture(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1827 const WCHAR
*start
= *ptr
;
1829 /* IPvFuture has to start with a 'v' or 'V'. */
1830 if(**ptr
!= 'v' && **ptr
!= 'V')
1833 /* Following the v there must be at least 1 hex digit. */
1835 if(!is_hexdigit(**ptr
)) {
1841 while(is_hexdigit(**ptr
))
1844 /* End of the hexdigit sequence must be a '.' */
1851 if(!is_unreserved(**ptr
) && !is_subdelim(**ptr
) && **ptr
!= ':') {
1857 while(is_unreserved(**ptr
) || is_subdelim(**ptr
) || **ptr
== ':')
1860 data
->host_type
= Uri_HOST_UNKNOWN
;
1862 TRACE("(%p %p %x): Parsed IPvFuture address %s len=%d\n", ptr
, data
, flags
,
1863 debugstr_wn(start
, *ptr
-start
), (int)(*ptr
-start
));
1868 /* IP-literal = "[" ( IPv6address / IPvFuture ) "]" */
1869 static BOOL
parse_ip_literal(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1872 if(**ptr
!= '[' && !(extras
& ALLOW_BRACKETLESS_IP_LITERAL
)) {
1875 } else if(**ptr
== '[')
1878 if(!parse_ipv6address(ptr
, data
, flags
)) {
1879 if(extras
& SKIP_IP_FUTURE_CHECK
|| !parse_ipvfuture(ptr
, data
, flags
)) {
1886 if(**ptr
!= ']' && !(extras
& ALLOW_BRACKETLESS_IP_LITERAL
)) {
1890 } else if(!**ptr
&& extras
& ALLOW_BRACKETLESS_IP_LITERAL
) {
1891 /* The IP literal didn't contain brackets and was followed by
1892 * a NULL terminator, so no reason to even check the port.
1894 data
->host_len
= *ptr
- data
->host
;
1901 /* If a valid port is not found, then let it trickle down to
1904 if(!parse_port(ptr
, data
, flags
)) {
1910 data
->host_len
= *ptr
- data
->host
;
1915 /* Parses the host information from the URI.
1917 * host = IP-literal / IPv4address / reg-name
1919 static BOOL
parse_host(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1920 if(!parse_ip_literal(ptr
, data
, flags
, extras
)) {
1921 if(!parse_ipv4address(ptr
, data
, flags
)) {
1922 if(!parse_reg_name(ptr
, data
, flags
, extras
)) {
1923 TRACE("(%p %p %x %x): Malformed URI, Unknown host type.\n",
1924 ptr
, data
, flags
, extras
);
1933 /* Parses the authority information from the URI.
1935 * authority = [ userinfo "@" ] host [ ":" port ]
1937 static BOOL
parse_authority(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1938 parse_userinfo(ptr
, data
, flags
);
1940 /* Parsing the port will happen during one of the host parsing
1941 * routines (if the URI has a port).
1943 if(!parse_host(ptr
, data
, flags
, 0))
1949 /* Attempts to parse the path information of a hierarchical URI. */
1950 static BOOL
parse_path_hierarchical(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1951 const WCHAR
*start
= *ptr
;
1952 static const WCHAR slash
[] = {'/',0};
1953 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
1955 if(is_path_delim(**ptr
)) {
1956 if(data
->scheme_type
== URL_SCHEME_WILDCARD
) {
1957 /* Wildcard schemes don't get a '/' attached if their path is
1962 } else if(!(flags
& Uri_CREATE_NO_CANONICALIZE
)) {
1963 /* If the path component is empty, then a '/' is added. */
1968 while(!is_path_delim(**ptr
)) {
1969 if(**ptr
== '%' && data
->scheme_type
!= URL_SCHEME_UNKNOWN
&& !is_file
) {
1970 if(!check_pct_encoded(ptr
)) {
1975 } else if(is_forbidden_dos_path_char(**ptr
) && is_file
&&
1976 (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
1977 /* File schemes with USE_DOS_PATH set aren't allowed to have
1978 * a '<' or '>' or '\"' appear in them.
1982 } else if(**ptr
== '\\') {
1983 /* Not allowed to have a backslash if NO_CANONICALIZE is set
1984 * and the scheme is known type (but not a file scheme).
1986 if(flags
& Uri_CREATE_NO_CANONICALIZE
) {
1987 if(data
->scheme_type
!= URL_SCHEME_FILE
&&
1988 data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1998 /* The only time a URI doesn't have a path is when
1999 * the NO_CANONICALIZE flag is set and the raw URI
2000 * didn't contain one.
2007 data
->path_len
= *ptr
- start
;
2012 TRACE("(%p %p %x): Parsed path %s len=%d\n", ptr
, data
, flags
,
2013 debugstr_wn(data
->path
, data
->path_len
), data
->path_len
);
2015 TRACE("(%p %p %x): The URI contained no path\n", ptr
, data
, flags
);
2020 /* Parses the path of a opaque URI (much less strict then the parser
2021 * for a hierarchical URI).
2024 * Windows allows invalid % encoded data to appear in opaque URI paths
2025 * for unknown scheme types.
2027 * File schemes with USE_DOS_PATH set aren't allowed to have '<', '>', or '\"'
2030 static BOOL
parse_path_opaque(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2031 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2032 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
2036 while(!is_path_delim(**ptr
)) {
2037 if(**ptr
== '%' && known_scheme
) {
2038 if(!check_pct_encoded(ptr
)) {
2044 } else if(is_forbidden_dos_path_char(**ptr
) && is_file
&&
2045 (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
2054 data
->path_len
= *ptr
- data
->path
;
2055 TRACE("(%p %p %x): Parsed opaque URI path %s len=%d\n", ptr
, data
, flags
,
2056 debugstr_wn(data
->path
, data
->path_len
), data
->path_len
);
2060 /* Determines how the URI should be parsed after the scheme information.
2062 * If the scheme is followed, by "//" then, it is treated as an hierarchical URI
2063 * which then the authority and path information will be parsed out. Otherwise, the
2064 * URI will be treated as an opaque URI which the authority information is not parsed
2067 * RFC 3896 definition of hier-part:
2069 * hier-part = "//" authority path-abempty
2074 * MSDN opaque URI definition:
2075 * scheme ":" path [ "#" fragment ]
2078 * If the URI is of an unknown scheme type and has a "//" following the scheme then it
2079 * is treated as a hierarchical URI, but, if the CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is
2080 * set then it is considered an opaque URI reguardless of what follows the scheme information
2081 * (per MSDN documentation).
2083 static BOOL
parse_hierpart(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2084 const WCHAR
*start
= *ptr
;
2086 /* Checks if the authority information needs to be parsed. */
2087 if(is_hierarchical_uri(ptr
, data
)) {
2088 /* Only treat it as a hierarchical URI if the scheme_type is known or
2089 * the Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is not set.
2091 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
||
2092 !(flags
& Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
)) {
2093 TRACE("(%p %p %x): Treating URI as an hierarchical URI.\n", ptr
, data
, flags
);
2094 data
->is_opaque
= FALSE
;
2096 /* TODO: Handle hierarchical URI's, parse authority then parse the path. */
2097 if(!parse_authority(ptr
, data
, flags
))
2100 return parse_path_hierarchical(ptr
, data
, flags
);
2102 /* Reset ptr to it's starting position so opaque path parsing
2103 * begins at the correct location.
2108 /* If it reaches here, then the URI will be treated as an opaque
2112 TRACE("(%p %p %x): Treating URI as an opaque URI.\n", ptr
, data
, flags
);
2114 data
->is_opaque
= TRUE
;
2115 if(!parse_path_opaque(ptr
, data
, flags
))
2121 /* Attempts to parse the query string from the URI.
2124 * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
2125 * data is allowed appear in the query string. For unknown scheme types
2126 * invalid percent encoded data is allowed to appear reguardless.
2128 static BOOL
parse_query(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2129 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2132 TRACE("(%p %p %x): URI didn't contain a query string.\n", ptr
, data
, flags
);
2139 while(**ptr
&& **ptr
!= '#') {
2140 if(**ptr
== '%' && known_scheme
&&
2141 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
2142 if(!check_pct_encoded(ptr
)) {
2153 data
->query_len
= *ptr
- data
->query
;
2155 TRACE("(%p %p %x): Parsed query string %s len=%d\n", ptr
, data
, flags
,
2156 debugstr_wn(data
->query
, data
->query_len
), data
->query_len
);
2160 /* Attempts to parse the fragment from the URI.
2163 * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
2164 * data is allowed appear in the query string. For unknown scheme types
2165 * invalid percent encoded data is allowed to appear reguardless.
2167 static BOOL
parse_fragment(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2168 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2171 TRACE("(%p %p %x): URI didn't contain a fragment.\n", ptr
, data
, flags
);
2175 data
->fragment
= *ptr
;
2179 if(**ptr
== '%' && known_scheme
&&
2180 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
2181 if(!check_pct_encoded(ptr
)) {
2182 *ptr
= data
->fragment
;
2183 data
->fragment
= NULL
;
2192 data
->fragment_len
= *ptr
- data
->fragment
;
2194 TRACE("(%p %p %x): Parsed fragment %s len=%d\n", ptr
, data
, flags
,
2195 debugstr_wn(data
->fragment
, data
->fragment_len
), data
->fragment_len
);
2199 /* Parses and validates the components of the specified by data->uri
2200 * and stores the information it parses into 'data'.
2202 * Returns TRUE if it successfully parsed the URI. False otherwise.
2204 static BOOL
parse_uri(parse_data
*data
, DWORD flags
) {
2211 TRACE("(%p %x): BEGINNING TO PARSE URI %s.\n", data
, flags
, debugstr_w(data
->uri
));
2213 if(!parse_scheme(pptr
, data
, flags
, 0))
2216 if(!parse_hierpart(pptr
, data
, flags
))
2219 if(!parse_query(pptr
, data
, flags
))
2222 if(!parse_fragment(pptr
, data
, flags
))
2225 TRACE("(%p %x): FINISHED PARSING URI.\n", data
, flags
);
2229 static BOOL
canonicalize_username(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2232 if(!data
->username
) {
2233 uri
->userinfo_start
= -1;
2237 uri
->userinfo_start
= uri
->canon_len
;
2238 for(ptr
= data
->username
; ptr
< data
->username
+data
->username_len
; ++ptr
) {
2240 /* Only decode % encoded values for known scheme types. */
2241 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
2242 /* See if the value really needs decoded. */
2243 WCHAR val
= decode_pct_val(ptr
);
2244 if(is_unreserved(val
)) {
2246 uri
->canon_uri
[uri
->canon_len
] = val
;
2250 /* Move pass the hex characters. */
2255 } else if(!is_reserved(*ptr
) && !is_unreserved(*ptr
) && *ptr
!= '\\') {
2256 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2259 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
)) {
2261 pct_encode_val(*ptr
, uri
->canon_uri
+ uri
->canon_len
);
2263 uri
->canon_len
+= 3;
2269 /* Nothing special, so just copy the character over. */
2270 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2277 static BOOL
canonicalize_password(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2280 if(!data
->password
) {
2281 uri
->userinfo_split
= -1;
2285 if(uri
->userinfo_start
== -1)
2286 /* Has a password, but, doesn't have a username. */
2287 uri
->userinfo_start
= uri
->canon_len
;
2289 uri
->userinfo_split
= uri
->canon_len
- uri
->userinfo_start
;
2291 /* Add the ':' to the userinfo component. */
2293 uri
->canon_uri
[uri
->canon_len
] = ':';
2296 for(ptr
= data
->password
; ptr
< data
->password
+data
->password_len
; ++ptr
) {
2298 /* Only decode % encoded values for known scheme types. */
2299 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
2300 /* See if the value really needs decoded. */
2301 WCHAR val
= decode_pct_val(ptr
);
2302 if(is_unreserved(val
)) {
2304 uri
->canon_uri
[uri
->canon_len
] = val
;
2308 /* Move pass the hex characters. */
2313 } else if(!is_reserved(*ptr
) && !is_unreserved(*ptr
) && *ptr
!= '\\') {
2314 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2317 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
)) {
2319 pct_encode_val(*ptr
, uri
->canon_uri
+ uri
->canon_len
);
2321 uri
->canon_len
+= 3;
2327 /* Nothing special, so just copy the character over. */
2328 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2335 /* Canonicalizes the userinfo of the URI represented by the parse_data.
2337 * Canonicalization of the userinfo is a simple process. If there are any percent
2338 * encoded characters that fall in the "unreserved" character set, they are decoded
2339 * to their actual value. If a character is not in the "unreserved" or "reserved" sets
2340 * then it is percent encoded. Other than that the characters are copied over without
2343 static BOOL
canonicalize_userinfo(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2344 uri
->userinfo_start
= uri
->userinfo_split
= -1;
2345 uri
->userinfo_len
= 0;
2347 if(!data
->username
&& !data
->password
)
2348 /* URI doesn't have userinfo, so nothing to do here. */
2351 if(!canonicalize_username(data
, uri
, flags
, computeOnly
))
2354 if(!canonicalize_password(data
, uri
, flags
, computeOnly
))
2357 uri
->userinfo_len
= uri
->canon_len
- uri
->userinfo_start
;
2359 TRACE("(%p %p %x %d): Canonicalized userinfo, userinfo_start=%d, userinfo=%s, userinfo_split=%d userinfo_len=%d.\n",
2360 data
, uri
, flags
, computeOnly
, uri
->userinfo_start
, debugstr_wn(uri
->canon_uri
+ uri
->userinfo_start
, uri
->userinfo_len
),
2361 uri
->userinfo_split
, uri
->userinfo_len
);
2363 /* Now insert the '@' after the userinfo. */
2365 uri
->canon_uri
[uri
->canon_len
] = '@';
2371 /* Attempts to canonicalize a reg_name.
2373 * Things that happen:
2374 * 1) If Uri_CREATE_NO_CANONICALIZE flag is not set, then the reg_name is
2375 * lower cased. Unless it's an unknown scheme type, which case it's
2376 * no lower cased reguardless.
2378 * 2) Unreserved % encoded characters are decoded for known
2381 * 3) Forbidden characters are % encoded as long as
2382 * Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS flag is not set and
2383 * it isn't an unknown scheme type.
2385 * 4) If it's a file scheme and the host is "localhost" it's removed.
2387 * 5) If it's a file scheme and Uri_CREATE_FILE_USE_DOS_PATH is set,
2388 * then the UNC path characters are added before the host name.
2390 static BOOL
canonicalize_reg_name(const parse_data
*data
, Uri
*uri
,
2391 DWORD flags
, BOOL computeOnly
) {
2392 static const WCHAR localhostW
[] =
2393 {'l','o','c','a','l','h','o','s','t',0};
2395 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2397 if(data
->scheme_type
== URL_SCHEME_FILE
&&
2398 data
->host_len
== lstrlenW(localhostW
)) {
2399 if(!StrCmpNIW(data
->host
, localhostW
, data
->host_len
)) {
2400 uri
->host_start
= -1;
2402 uri
->host_type
= Uri_HOST_UNKNOWN
;
2407 if(data
->scheme_type
== URL_SCHEME_FILE
&& flags
& Uri_CREATE_FILE_USE_DOS_PATH
) {
2409 uri
->canon_uri
[uri
->canon_len
] = '\\';
2410 uri
->canon_uri
[uri
->canon_len
+1] = '\\';
2412 uri
->canon_len
+= 2;
2413 uri
->authority_start
= uri
->canon_len
;
2416 uri
->host_start
= uri
->canon_len
;
2418 for(ptr
= data
->host
; ptr
< data
->host
+data
->host_len
; ++ptr
) {
2419 if(*ptr
== '%' && known_scheme
) {
2420 WCHAR val
= decode_pct_val(ptr
);
2421 if(is_unreserved(val
)) {
2422 /* If NO_CANONICALZE is not set, then windows lower cases the
2425 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
) && isupperW(val
)) {
2427 uri
->canon_uri
[uri
->canon_len
] = tolowerW(val
);
2430 uri
->canon_uri
[uri
->canon_len
] = val
;
2434 /* Skip past the % encoded character. */
2438 /* Just copy the % over. */
2440 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2443 } else if(*ptr
== '\\') {
2444 /* Only unknown scheme types could have made it here with a '\\' in the host name. */
2446 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2448 } else if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) &&
2449 !is_unreserved(*ptr
) && !is_reserved(*ptr
) && known_scheme
) {
2451 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
2453 /* The percent encoded value gets lower cased also. */
2454 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
)) {
2455 uri
->canon_uri
[uri
->canon_len
+1] = tolowerW(uri
->canon_uri
[uri
->canon_len
+1]);
2456 uri
->canon_uri
[uri
->canon_len
+2] = tolowerW(uri
->canon_uri
[uri
->canon_len
+2]);
2460 uri
->canon_len
+= 3;
2463 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
) && known_scheme
)
2464 uri
->canon_uri
[uri
->canon_len
] = tolowerW(*ptr
);
2466 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2473 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2476 TRACE("(%p %p %x %d): Canonicalize reg_name=%s len=%d\n", data
, uri
, flags
,
2477 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2481 find_domain_name(uri
->canon_uri
+uri
->host_start
, uri
->host_len
,
2482 &(uri
->domain_offset
));
2487 /* Attempts to canonicalize an implicit IPv4 address. */
2488 static BOOL
canonicalize_implicit_ipv4address(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2489 uri
->host_start
= uri
->canon_len
;
2491 TRACE("%u\n", data
->implicit_ipv4
);
2492 /* For unknown scheme types Window's doesn't convert
2493 * the value into an IP address, but, it still considers
2494 * it an IPv4 address.
2496 if(data
->scheme_type
== URL_SCHEME_UNKNOWN
) {
2498 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2499 uri
->canon_len
+= data
->host_len
;
2502 uri
->canon_len
+= ui2ipv4(uri
->canon_uri
+uri
->canon_len
, data
->implicit_ipv4
);
2504 uri
->canon_len
+= ui2ipv4(NULL
, data
->implicit_ipv4
);
2507 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2508 uri
->host_type
= Uri_HOST_IPV4
;
2511 TRACE("%p %p %x %d): Canonicalized implicit IP address=%s len=%d\n",
2512 data
, uri
, flags
, computeOnly
,
2513 debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2519 /* Attempts to canonicalize an IPv4 address.
2521 * If the parse_data represents a URI that has an implicit IPv4 address
2522 * (ex. http://256/, this function will convert 256 into 0.0.1.0). If
2523 * the implicit IP address exceeds the value of UINT_MAX (maximum value
2524 * for an IPv4 address) it's canonicalized as if were a reg-name.
2526 * If the parse_data contains a partial or full IPv4 address it normalizes it.
2527 * A partial IPv4 address is something like "192.0" and would be normalized to
2528 * "192.0.0.0". With a full (or partial) IPv4 address like "192.002.01.003" would
2529 * be normalized to "192.2.1.3".
2532 * Window's ONLY normalizes IPv4 address for known scheme types (one that isn't
2533 * URL_SCHEME_UNKNOWN). For unknown scheme types, it simply copies the data from
2534 * the original URI into the canonicalized URI, but, it still recognizes URI's
2535 * host type as HOST_IPV4.
2537 static BOOL
canonicalize_ipv4address(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2538 if(data
->has_implicit_ip
)
2539 return canonicalize_implicit_ipv4address(data
, uri
, flags
, computeOnly
);
2541 uri
->host_start
= uri
->canon_len
;
2543 /* Windows only normalizes for known scheme types. */
2544 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
2545 /* parse_data contains a partial or full IPv4 address, so normalize it. */
2546 DWORD i
, octetDigitCount
= 0, octetCount
= 0;
2547 BOOL octetHasDigit
= FALSE
;
2549 for(i
= 0; i
< data
->host_len
; ++i
) {
2550 if(data
->host
[i
] == '0' && !octetHasDigit
) {
2551 /* Can ignore leading zeros if:
2552 * 1) It isn't the last digit of the octet.
2553 * 2) i+1 != data->host_len
2556 if(octetDigitCount
== 2 ||
2557 i
+1 == data
->host_len
||
2558 data
->host
[i
+1] == '.') {
2560 uri
->canon_uri
[uri
->canon_len
] = data
->host
[i
];
2562 TRACE("Adding zero\n");
2564 } else if(data
->host
[i
] == '.') {
2566 uri
->canon_uri
[uri
->canon_len
] = data
->host
[i
];
2569 octetDigitCount
= 0;
2570 octetHasDigit
= FALSE
;
2574 uri
->canon_uri
[uri
->canon_len
] = data
->host
[i
];
2578 octetHasDigit
= TRUE
;
2582 /* Make sure the canonicalized IP address has 4 dec-octets.
2583 * If doesn't add "0" ones until there is 4;
2585 for( ; octetCount
< 3; ++octetCount
) {
2587 uri
->canon_uri
[uri
->canon_len
] = '.';
2588 uri
->canon_uri
[uri
->canon_len
+1] = '0';
2591 uri
->canon_len
+= 2;
2594 /* Windows doesn't normalize addresses in unknown schemes. */
2596 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2597 uri
->canon_len
+= data
->host_len
;
2600 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2602 TRACE("(%p %p %x %d): Canonicalized IPv4 address, ip=%s len=%d\n",
2603 data
, uri
, flags
, computeOnly
,
2604 debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2611 /* Attempts to canonicalize the IPv6 address of the URI.
2613 * Multiple things happen during the canonicalization of an IPv6 address:
2614 * 1) Any leading zero's in an h16 component are removed.
2615 * Ex: [0001:0022::] -> [1:22::]
2617 * 2) The longest sequence of zero h16 components are compressed
2618 * into a "::" (elision). If there's a tie, the first is choosen.
2620 * Ex: [0:0:0:0:1:6:7:8] -> [::1:6:7:8]
2621 * [0:0:0:0:1:2::] -> [::1:2:0:0]
2622 * [0:0:1:2:0:0:7:8] -> [::1:2:0:0:7:8]
2624 * 3) If an IPv4 address is attached to the IPv6 address, it's
2626 * Ex: [::001.002.022.000] -> [::1.2.22.0]
2628 * 4) If an elision is present, but, only represents 1 h16 component
2631 * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
2633 * 5) If the IPv6 address contains an IPv4 address and there exists
2634 * at least 1 non-zero h16 component the IPv4 address is converted
2635 * into two h16 components, otherwise it's normalized and kept as is.
2637 * Ex: [::192.200.003.4] -> [::192.200.3.4]
2638 * [ffff::192.200.003.4] -> [ffff::c0c8:3041]
2641 * For unknown scheme types Windows simply copies the address over without any
2644 * IPv4 address can be included in an elision if all its components are 0's.
2646 static BOOL
canonicalize_ipv6address(const parse_data
*data
, Uri
*uri
,
2647 DWORD flags
, BOOL computeOnly
) {
2648 uri
->host_start
= uri
->canon_len
;
2650 if(data
->scheme_type
== URL_SCHEME_UNKNOWN
) {
2652 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2653 uri
->canon_len
+= data
->host_len
;
2657 DWORD i
, elision_len
;
2659 if(!ipv6_to_number(&(data
->ipv6_address
), values
)) {
2660 TRACE("(%p %p %x %d): Failed to compute numerical value for IPv6 address.\n",
2661 data
, uri
, flags
, computeOnly
);
2666 uri
->canon_uri
[uri
->canon_len
] = '[';
2669 /* Find where the elision should occur (if any). */
2670 compute_elision_location(&(data
->ipv6_address
), values
, &elision_start
, &elision_len
);
2672 TRACE("%p %p %x %d): Elision starts at %d, len=%u\n", data
, uri
, flags
,
2673 computeOnly
, elision_start
, elision_len
);
2675 for(i
= 0; i
< 8; ++i
) {
2676 BOOL in_elision
= (elision_start
> -1 && i
>= elision_start
&&
2677 i
< elision_start
+elision_len
);
2678 BOOL do_ipv4
= (i
== 6 && data
->ipv6_address
.ipv4
&& !in_elision
&&
2679 data
->ipv6_address
.h16_count
== 0);
2681 if(i
== elision_start
) {
2683 uri
->canon_uri
[uri
->canon_len
] = ':';
2684 uri
->canon_uri
[uri
->canon_len
+1] = ':';
2686 uri
->canon_len
+= 2;
2689 /* We can ignore the current component if we're in the elision. */
2693 /* We only add a ':' if we're not at i == 0, or when we're at
2694 * the very end of elision range since the ':' colon was handled
2695 * earlier. Otherwise we would end up with ":::" after elision.
2697 if(i
!= 0 && !(elision_start
> -1 && i
== elision_start
+elision_len
)) {
2699 uri
->canon_uri
[uri
->canon_len
] = ':';
2707 /* Combine the two parts of the IPv4 address values. */
2713 len
= ui2ipv4(uri
->canon_uri
+uri
->canon_len
, val
);
2715 len
= ui2ipv4(NULL
, val
);
2717 uri
->canon_len
+= len
;
2720 /* Write a regular h16 component to the URI. */
2722 /* Short circuit for the trivial case. */
2723 if(values
[i
] == 0) {
2725 uri
->canon_uri
[uri
->canon_len
] = '0';
2728 static const WCHAR formatW
[] = {'%','x',0};
2731 uri
->canon_len
+= sprintfW(uri
->canon_uri
+uri
->canon_len
,
2732 formatW
, values
[i
]);
2735 uri
->canon_len
+= sprintfW(tmp
, formatW
, values
[i
]);
2741 /* Add the closing ']'. */
2743 uri
->canon_uri
[uri
->canon_len
] = ']';
2747 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2750 TRACE("(%p %p %x %d): Canonicalized IPv6 address %s, len=%d\n", data
, uri
, flags
,
2751 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2757 /* Attempts to canonicalize the host of the URI (if any). */
2758 static BOOL
canonicalize_host(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2759 uri
->host_start
= -1;
2761 uri
->domain_offset
= -1;
2764 switch(data
->host_type
) {
2766 uri
->host_type
= Uri_HOST_DNS
;
2767 if(!canonicalize_reg_name(data
, uri
, flags
, computeOnly
))
2772 uri
->host_type
= Uri_HOST_IPV4
;
2773 if(!canonicalize_ipv4address(data
, uri
, flags
, computeOnly
))
2778 if(!canonicalize_ipv6address(data
, uri
, flags
, computeOnly
))
2781 uri
->host_type
= Uri_HOST_IPV6
;
2783 case Uri_HOST_UNKNOWN
:
2784 if(data
->host_len
> 0 || data
->scheme_type
!= URL_SCHEME_FILE
) {
2785 uri
->host_start
= uri
->canon_len
;
2787 /* Nothing happens to unknown host types. */
2789 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2790 uri
->canon_len
+= data
->host_len
;
2791 uri
->host_len
= data
->host_len
;
2794 uri
->host_type
= Uri_HOST_UNKNOWN
;
2797 FIXME("(%p %p %x %d): Canonicalization for host type %d not supported.\n", data
,
2798 uri
, flags
, computeOnly
, data
->host_type
);
2806 static BOOL
canonicalize_port(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2807 BOOL has_default_port
= FALSE
;
2808 USHORT default_port
= 0;
2811 uri
->port_offset
= -1;
2813 /* Check if the scheme has a default port. */
2814 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
2815 if(default_ports
[i
].scheme
== data
->scheme_type
) {
2816 has_default_port
= TRUE
;
2817 default_port
= default_ports
[i
].port
;
2822 uri
->has_port
= data
->has_port
|| has_default_port
;
2825 * 1) Has a port which is the default port.
2826 * 2) Has a port (not the default).
2827 * 3) Doesn't have a port, but, scheme has a default port.
2830 if(has_default_port
&& data
->has_port
&& data
->port_value
== default_port
) {
2831 /* If it's the default port and this flag isn't set, don't do anything. */
2832 if(flags
& Uri_CREATE_NO_CANONICALIZE
) {
2833 uri
->port_offset
= uri
->canon_len
-uri
->authority_start
;
2835 uri
->canon_uri
[uri
->canon_len
] = ':';
2839 /* Copy the original port over. */
2841 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->port
, data
->port_len
*sizeof(WCHAR
));
2842 uri
->canon_len
+= data
->port_len
;
2845 uri
->canon_len
+= ui2str(uri
->canon_uri
+uri
->canon_len
, data
->port_value
);
2847 uri
->canon_len
+= ui2str(NULL
, data
->port_value
);
2851 uri
->port
= default_port
;
2852 } else if(data
->has_port
) {
2853 uri
->port_offset
= uri
->canon_len
-uri
->authority_start
;
2855 uri
->canon_uri
[uri
->canon_len
] = ':';
2858 if(flags
& Uri_CREATE_NO_CANONICALIZE
&& data
->port
) {
2859 /* Copy the original over without changes. */
2861 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->port
, data
->port_len
*sizeof(WCHAR
));
2862 uri
->canon_len
+= data
->port_len
;
2865 uri
->canon_len
+= ui2str(uri
->canon_uri
+uri
->canon_len
, data
->port_value
);
2867 uri
->canon_len
+= ui2str(NULL
, data
->port_value
);
2870 uri
->port
= data
->port_value
;
2871 } else if(has_default_port
)
2872 uri
->port
= default_port
;
2877 /* Canonicalizes the authority of the URI represented by the parse_data. */
2878 static BOOL
canonicalize_authority(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2879 uri
->authority_start
= uri
->canon_len
;
2880 uri
->authority_len
= 0;
2882 if(!canonicalize_userinfo(data
, uri
, flags
, computeOnly
))
2885 if(!canonicalize_host(data
, uri
, flags
, computeOnly
))
2888 if(!canonicalize_port(data
, uri
, flags
, computeOnly
))
2891 if(uri
->host_start
!= -1 || (data
->is_relative
&& (data
->password
|| data
->username
)))
2892 uri
->authority_len
= uri
->canon_len
- uri
->authority_start
;
2894 uri
->authority_start
= -1;
2899 /* Attempts to canonicalize the path of a hierarchical URI.
2901 * Things that happen:
2902 * 1). Forbidden characters are percent encoded, unless the NO_ENCODE_FORBIDDEN
2903 * flag is set or it's a file URI. Forbidden characters are always encoded
2904 * for file schemes reguardless and forbidden characters are never encoded
2905 * for unknown scheme types.
2907 * 2). For known scheme types '\\' are changed to '/'.
2909 * 3). Percent encoded, unreserved characters are decoded to their actual values.
2910 * Unless the scheme type is unknown. For file schemes any percent encoded
2911 * character in the unreserved or reserved set is decoded.
2913 * 4). For File schemes if the path is starts with a drive letter and doesn't
2914 * start with a '/' then one is appended.
2915 * Ex: file://c:/test.mp3 -> file:///c:/test.mp3
2917 * 5). Dot segments are removed from the path for all scheme types
2918 * unless NO_CANONICALIZE flag is set. Dot segments aren't removed
2919 * for wildcard scheme types.
2922 * file://c:/test%20test -> file:///c:/test%2520test
2923 * file://c:/test%3Etest -> file:///c:/test%253Etest
2924 * if Uri_CREATE_FILE_USE_DOS_PATH is not set:
2925 * file:///c:/test%20test -> file:///c:/test%20test
2926 * file:///c:/test%test -> file:///c:/test%25test
2928 static BOOL
canonicalize_path_hierarchical(const parse_data
*data
, Uri
*uri
,
2929 DWORD flags
, BOOL computeOnly
) {
2931 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2932 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
2933 const BOOL is_res
= data
->scheme_type
== URL_SCHEME_RES
;
2935 BOOL escape_pct
= FALSE
;
2938 uri
->path_start
= -1;
2943 uri
->path_start
= uri
->canon_len
;
2946 if(is_file
&& uri
->host_start
== -1) {
2947 /* Check if a '/' needs to be appended for the file scheme. */
2948 if(data
->path_len
> 1 && is_drive_path(ptr
) && !(flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
2950 uri
->canon_uri
[uri
->canon_len
] = '/';
2953 } else if(*ptr
== '/') {
2954 if(!(flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
2955 /* Copy the extra '/' over. */
2957 uri
->canon_uri
[uri
->canon_len
] = '/';
2963 if(is_drive_path(ptr
)) {
2965 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2966 /* If theres a '|' after the drive letter, convert it to a ':'. */
2967 uri
->canon_uri
[uri
->canon_len
+1] = ':';
2970 uri
->canon_len
+= 2;
2974 if(!is_file
&& *(data
->path
) && *(data
->path
) != '/') {
2975 /* Prepend a '/' to the path if it doesn't have one. */
2977 uri
->canon_uri
[uri
->canon_len
] = '/';
2981 for(; ptr
< data
->path
+data
->path_len
; ++ptr
) {
2982 BOOL do_default_action
= TRUE
;
2984 if(*ptr
== '%' && !is_res
) {
2985 const WCHAR
*tmp
= ptr
;
2988 /* Check if the % represents a valid encoded char, or if it needs encoded. */
2989 BOOL force_encode
= !check_pct_encoded(&tmp
) && is_file
&& !(flags
&Uri_CREATE_FILE_USE_DOS_PATH
);
2990 val
= decode_pct_val(ptr
);
2992 if(force_encode
|| escape_pct
) {
2993 /* Escape the percent sign in the file URI. */
2995 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
2996 uri
->canon_len
+= 3;
2997 do_default_action
= FALSE
;
2998 } else if((is_unreserved(val
) && known_scheme
) ||
2999 (is_file
&& (is_unreserved(val
) || is_reserved(val
) ||
3000 (val
&& flags
&Uri_CREATE_FILE_USE_DOS_PATH
&& !is_forbidden_dos_path_char(val
))))) {
3002 uri
->canon_uri
[uri
->canon_len
] = val
;
3008 } else if(*ptr
== '/' && is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
3009 /* Convert the '/' back to a '\\'. */
3011 uri
->canon_uri
[uri
->canon_len
] = '\\';
3013 do_default_action
= FALSE
;
3014 } else if(*ptr
== '\\' && known_scheme
) {
3015 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
))) {
3016 /* Convert '\\' into a '/'. */
3018 uri
->canon_uri
[uri
->canon_len
] = '/';
3020 do_default_action
= FALSE
;
3022 } else if(known_scheme
&& !is_res
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
) &&
3023 (!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) || is_file
)) {
3024 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
))) {
3025 /* Escape the forbidden character. */
3027 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3028 uri
->canon_len
+= 3;
3029 do_default_action
= FALSE
;
3033 if(do_default_action
) {
3035 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3040 uri
->path_len
= uri
->canon_len
- uri
->path_start
;
3042 /* Removing the dot segments only happens when it's not in
3043 * computeOnly mode and it's not a wildcard scheme. File schemes
3044 * with USE_DOS_PATH set don't get dot segments removed.
3046 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) &&
3047 data
->scheme_type
!= URL_SCHEME_WILDCARD
) {
3048 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
) && !computeOnly
) {
3049 /* Remove the dot segments (if any) and reset everything to the new
3052 DWORD new_len
= remove_dot_segments(uri
->canon_uri
+uri
->path_start
, uri
->path_len
);
3053 uri
->canon_len
-= uri
->path_len
-new_len
;
3054 uri
->path_len
= new_len
;
3059 TRACE("Canonicalized path %s len=%d\n",
3060 debugstr_wn(uri
->canon_uri
+uri
->path_start
, uri
->path_len
),
3066 /* Attempts to canonicalize the path for an opaque URI.
3068 * For known scheme types:
3069 * 1) forbidden characters are percent encoded if
3070 * NO_ENCODE_FORBIDDEN_CHARACTERS isn't set.
3072 * 2) Percent encoded, unreserved characters are decoded
3073 * to their actual values, for known scheme types.
3075 * 3) '\\' are changed to '/' for known scheme types
3076 * except for mailto schemes.
3078 * 4) For file schemes, if USE_DOS_PATH is set all '/'
3079 * are converted to backslashes.
3081 * 5) For file schemes, if USE_DOS_PATH isn't set all '\'
3082 * are converted to forward slashes.
3084 static BOOL
canonicalize_path_opaque(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3086 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
3087 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
3090 uri
->path_start
= -1;
3095 uri
->path_start
= uri
->canon_len
;
3097 /* Windows doesn't allow a "//" to appear after the scheme
3098 * of a URI, if it's an opaque URI.
3100 if(data
->scheme
&& *(data
->path
) == '/' && *(data
->path
+1) == '/') {
3101 /* So it inserts a "/." before the "//" if it exists. */
3103 uri
->canon_uri
[uri
->canon_len
] = '/';
3104 uri
->canon_uri
[uri
->canon_len
+1] = '.';
3107 uri
->canon_len
+= 2;
3110 for(ptr
= data
->path
; ptr
< data
->path
+data
->path_len
; ++ptr
) {
3111 BOOL do_default_action
= TRUE
;
3113 if(*ptr
== '%' && known_scheme
) {
3114 WCHAR val
= decode_pct_val(ptr
);
3116 if(is_unreserved(val
)) {
3118 uri
->canon_uri
[uri
->canon_len
] = val
;
3124 } else if(*ptr
== '/' && is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
3126 uri
->canon_uri
[uri
->canon_len
] = '\\';
3128 do_default_action
= FALSE
;
3129 } else if(*ptr
== '\\') {
3130 if(is_file
&& !(flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
3131 /* Convert to a '/'. */
3133 uri
->canon_uri
[uri
->canon_len
] = '/';
3135 do_default_action
= FALSE
;
3137 } else if(known_scheme
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
) &&
3138 !(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
)) {
3139 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
))) {
3141 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3142 uri
->canon_len
+= 3;
3143 do_default_action
= FALSE
;
3147 if(do_default_action
) {
3149 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3154 if(data
->scheme_type
== URL_SCHEME_MK
&& !computeOnly
&& !(flags
& Uri_CREATE_NO_CANONICALIZE
)) {
3155 DWORD new_len
= remove_dot_segments(uri
->canon_uri
+ uri
->path_start
,
3156 uri
->canon_len
- uri
->path_start
);
3157 uri
->canon_len
= uri
->path_start
+ new_len
;
3160 uri
->path_len
= uri
->canon_len
- uri
->path_start
;
3162 TRACE("(%p %p %x %d): Canonicalized opaque URI path %s len=%d\n", data
, uri
, flags
, computeOnly
,
3163 debugstr_wn(uri
->canon_uri
+uri
->path_start
, uri
->path_len
), uri
->path_len
);
3167 /* Determines how the URI represented by the parse_data should be canonicalized.
3169 * Essentially, if the parse_data represents an hierarchical URI then it calls
3170 * canonicalize_authority and the canonicalization functions for the path. If the
3171 * URI is opaque it canonicalizes the path of the URI.
3173 static BOOL
canonicalize_hierpart(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3174 if(!data
->is_opaque
|| (data
->is_relative
&& (data
->password
|| data
->username
))) {
3175 /* "//" is only added for non-wildcard scheme types.
3177 * A "//" is only added to a relative URI if it has a
3178 * host or port component (this only happens if a IUriBuilder
3179 * is generating an IUri).
3181 if((data
->is_relative
&& (data
->host
|| data
->has_port
)) ||
3182 (!data
->is_relative
&& data
->scheme_type
!= URL_SCHEME_WILDCARD
)) {
3184 INT pos
= uri
->canon_len
;
3186 uri
->canon_uri
[pos
] = '/';
3187 uri
->canon_uri
[pos
+1] = '/';
3189 uri
->canon_len
+= 2;
3192 if(!canonicalize_authority(data
, uri
, flags
, computeOnly
))
3195 if(data
->is_relative
&& (data
->password
|| data
->username
)) {
3196 if(!canonicalize_path_opaque(data
, uri
, flags
, computeOnly
))
3199 if(!canonicalize_path_hierarchical(data
, uri
, flags
, computeOnly
))
3203 /* Opaque URI's don't have an authority. */
3204 uri
->userinfo_start
= uri
->userinfo_split
= -1;
3205 uri
->userinfo_len
= 0;
3206 uri
->host_start
= -1;
3208 uri
->host_type
= Uri_HOST_UNKNOWN
;
3209 uri
->has_port
= FALSE
;
3210 uri
->authority_start
= -1;
3211 uri
->authority_len
= 0;
3212 uri
->domain_offset
= -1;
3213 uri
->port_offset
= -1;
3215 if(is_hierarchical_scheme(data
->scheme_type
)) {
3218 /* Absolute URIs aren't displayed for known scheme types
3219 * which should be hierarchical URIs.
3221 uri
->display_modifiers
|= URI_DISPLAY_NO_ABSOLUTE_URI
;
3223 /* Windows also sets the port for these (if they have one). */
3224 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
3225 if(data
->scheme_type
== default_ports
[i
].scheme
) {
3226 uri
->has_port
= TRUE
;
3227 uri
->port
= default_ports
[i
].port
;
3233 if(!canonicalize_path_opaque(data
, uri
, flags
, computeOnly
))
3237 if(uri
->path_start
> -1 && !computeOnly
)
3238 /* Finding file extensions happens for both types of URIs. */
3239 uri
->extension_offset
= find_file_extension(uri
->canon_uri
+uri
->path_start
, uri
->path_len
);
3241 uri
->extension_offset
= -1;
3246 /* Attempts to canonicalize the query string of the URI.
3248 * Things that happen:
3249 * 1) For known scheme types forbidden characters
3250 * are percent encoded, unless the NO_DECODE_EXTRA_INFO flag is set
3251 * or NO_ENCODE_FORBIDDEN_CHARACTERS is set.
3253 * 2) For known scheme types, percent encoded, unreserved characters
3254 * are decoded as long as the NO_DECODE_EXTRA_INFO flag isn't set.
3256 static BOOL
canonicalize_query(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3257 const WCHAR
*ptr
, *end
;
3258 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
3261 uri
->query_start
= -1;
3266 uri
->query_start
= uri
->canon_len
;
3268 end
= data
->query
+data
->query_len
;
3269 for(ptr
= data
->query
; ptr
< end
; ++ptr
) {
3271 if(known_scheme
&& !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3272 WCHAR val
= decode_pct_val(ptr
);
3273 if(is_unreserved(val
)) {
3275 uri
->canon_uri
[uri
->canon_len
] = val
;
3282 } else if(known_scheme
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
)) {
3283 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) &&
3284 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3286 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3287 uri
->canon_len
+= 3;
3293 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3297 uri
->query_len
= uri
->canon_len
- uri
->query_start
;
3300 TRACE("(%p %p %x %d): Canonicalized query string %s len=%d\n", data
, uri
, flags
,
3301 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->query_start
, uri
->query_len
),
3306 static BOOL
canonicalize_fragment(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3307 const WCHAR
*ptr
, *end
;
3308 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
3310 if(!data
->fragment
) {
3311 uri
->fragment_start
= -1;
3312 uri
->fragment_len
= 0;
3316 uri
->fragment_start
= uri
->canon_len
;
3318 end
= data
->fragment
+ data
->fragment_len
;
3319 for(ptr
= data
->fragment
; ptr
< end
; ++ptr
) {
3321 if(known_scheme
&& !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3322 WCHAR val
= decode_pct_val(ptr
);
3323 if(is_unreserved(val
)) {
3325 uri
->canon_uri
[uri
->canon_len
] = val
;
3332 } else if(known_scheme
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
)) {
3333 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) &&
3334 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3336 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3337 uri
->canon_len
+= 3;
3343 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3347 uri
->fragment_len
= uri
->canon_len
- uri
->fragment_start
;
3350 TRACE("(%p %p %x %d): Canonicalized fragment %s len=%d\n", data
, uri
, flags
,
3351 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->fragment_start
, uri
->fragment_len
),
3356 /* Canonicalizes the scheme information specified in the parse_data using the specified flags. */
3357 static BOOL
canonicalize_scheme(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3358 uri
->scheme_start
= -1;
3359 uri
->scheme_len
= 0;
3362 /* The only type of URI that doesn't have to have a scheme is a relative
3365 if(!data
->is_relative
) {
3366 FIXME("(%p %p %x): Unable to determine the scheme type of %s.\n", data
,
3367 uri
, flags
, debugstr_w(data
->uri
));
3373 INT pos
= uri
->canon_len
;
3375 for(i
= 0; i
< data
->scheme_len
; ++i
) {
3376 /* Scheme name must be lower case after canonicalization. */
3377 uri
->canon_uri
[i
+ pos
] = tolowerW(data
->scheme
[i
]);
3380 uri
->canon_uri
[i
+ pos
] = ':';
3381 uri
->scheme_start
= pos
;
3383 TRACE("(%p %p %x): Canonicalized scheme=%s, len=%d.\n", data
, uri
, flags
,
3384 debugstr_wn(uri
->canon_uri
, uri
->scheme_len
), data
->scheme_len
);
3387 /* This happens in both computation modes. */
3388 uri
->canon_len
+= data
->scheme_len
+ 1;
3389 uri
->scheme_len
= data
->scheme_len
;
3394 /* Compute's what the length of the URI specified by the parse_data will be
3395 * after canonicalization occurs using the specified flags.
3397 * This function will return a non-zero value indicating the length of the canonicalized
3398 * URI, or -1 on error.
3400 static int compute_canonicalized_length(const parse_data
*data
, DWORD flags
) {
3403 memset(&uri
, 0, sizeof(Uri
));
3405 TRACE("(%p %x): Beginning to compute canonicalized length for URI %s\n", data
, flags
,
3406 debugstr_w(data
->uri
));
3408 if(!canonicalize_scheme(data
, &uri
, flags
, TRUE
)) {
3409 ERR("(%p %x): Failed to compute URI scheme length.\n", data
, flags
);
3413 if(!canonicalize_hierpart(data
, &uri
, flags
, TRUE
)) {
3414 ERR("(%p %x): Failed to compute URI hierpart length.\n", data
, flags
);
3418 if(!canonicalize_query(data
, &uri
, flags
, TRUE
)) {
3419 ERR("(%p %x): Failed to compute query string length.\n", data
, flags
);
3423 if(!canonicalize_fragment(data
, &uri
, flags
, TRUE
)) {
3424 ERR("(%p %x): Failed to compute fragment length.\n", data
, flags
);
3428 TRACE("(%p %x): Finished computing canonicalized URI length. length=%d\n", data
, flags
, uri
.canon_len
);
3430 return uri
.canon_len
;
3433 /* Canonicalizes the URI data specified in the parse_data, using the given flags. If the
3434 * canonicalization succeededs it will store all the canonicalization information
3435 * in the pointer to the Uri.
3437 * To canonicalize a URI this function first computes what the length of the URI
3438 * specified by the parse_data will be. Once this is done it will then perfom the actual
3439 * canonicalization of the URI.
3441 static HRESULT
canonicalize_uri(const parse_data
*data
, Uri
*uri
, DWORD flags
) {
3444 uri
->canon_uri
= NULL
;
3445 uri
->canon_size
= uri
->canon_len
= 0;
3447 TRACE("(%p %p %x): beginning to canonicalize URI %s.\n", data
, uri
, flags
, debugstr_w(data
->uri
));
3449 /* First try to compute the length of the URI. */
3450 len
= compute_canonicalized_length(data
, flags
);
3452 ERR("(%p %p %x): Could not compute the canonicalized length of %s.\n", data
, uri
, flags
,
3453 debugstr_w(data
->uri
));
3454 return E_INVALIDARG
;
3457 uri
->canon_uri
= heap_alloc((len
+1)*sizeof(WCHAR
));
3459 return E_OUTOFMEMORY
;
3461 uri
->canon_size
= len
;
3462 if(!canonicalize_scheme(data
, uri
, flags
, FALSE
)) {
3463 ERR("(%p %p %x): Unable to canonicalize the scheme of the URI.\n", data
, uri
, flags
);
3464 return E_INVALIDARG
;
3466 uri
->scheme_type
= data
->scheme_type
;
3468 if(!canonicalize_hierpart(data
, uri
, flags
, FALSE
)) {
3469 ERR("(%p %p %x): Unable to canonicalize the heirpart of the URI\n", data
, uri
, flags
);
3470 return E_INVALIDARG
;
3473 if(!canonicalize_query(data
, uri
, flags
, FALSE
)) {
3474 ERR("(%p %p %x): Unable to canonicalize query string of the URI.\n",
3476 return E_INVALIDARG
;
3479 if(!canonicalize_fragment(data
, uri
, flags
, FALSE
)) {
3480 ERR("(%p %p %x): Unable to canonicalize fragment of the URI.\n",
3482 return E_INVALIDARG
;
3485 /* There's a possibility we didn't use all the space we allocated
3488 if(uri
->canon_len
< uri
->canon_size
) {
3489 /* This happens if the URI is hierarchical and dot
3490 * segments were removed from it's path.
3492 WCHAR
*tmp
= heap_realloc(uri
->canon_uri
, (uri
->canon_len
+1)*sizeof(WCHAR
));
3494 return E_OUTOFMEMORY
;
3496 uri
->canon_uri
= tmp
;
3497 uri
->canon_size
= uri
->canon_len
;
3500 uri
->canon_uri
[uri
->canon_len
] = '\0';
3501 TRACE("(%p %p %x): finished canonicalizing the URI. uri=%s\n", data
, uri
, flags
, debugstr_w(uri
->canon_uri
));
3506 static HRESULT
get_builder_component(LPWSTR
*component
, DWORD
*component_len
,
3507 LPCWSTR source
, DWORD source_len
,
3508 LPCWSTR
*output
, DWORD
*output_len
)
3521 if(!(*component
) && source
) {
3522 /* Allocate 'component', and copy the contents from 'source'
3523 * into the new allocation.
3525 *component
= heap_alloc((source_len
+1)*sizeof(WCHAR
));
3527 return E_OUTOFMEMORY
;
3529 memcpy(*component
, source
, source_len
*sizeof(WCHAR
));
3530 (*component
)[source_len
] = '\0';
3531 *component_len
= source_len
;
3534 *output
= *component
;
3535 *output_len
= *component_len
;
3536 return *output
? S_OK
: S_FALSE
;
3539 /* Allocates 'component' and copies the string from 'new_value' into 'component'.
3540 * If 'prefix' is set and 'new_value' isn't NULL, then it checks if 'new_value'
3541 * starts with 'prefix'. If it doesn't then 'prefix' is prepended to 'component'.
3543 * If everything is successful, then will set 'success_flag' in 'flags'.
3545 static HRESULT
set_builder_component(LPWSTR
*component
, DWORD
*component_len
, LPCWSTR new_value
,
3546 WCHAR prefix
, DWORD
*flags
, DWORD success_flag
)
3548 heap_free(*component
);
3554 BOOL add_prefix
= FALSE
;
3555 DWORD len
= lstrlenW(new_value
);
3558 if(prefix
&& *new_value
!= prefix
) {
3560 *component
= heap_alloc((len
+2)*sizeof(WCHAR
));
3562 *component
= heap_alloc((len
+1)*sizeof(WCHAR
));
3565 return E_OUTOFMEMORY
;
3568 (*component
)[pos
++] = prefix
;
3570 memcpy(*component
+pos
, new_value
, (len
+1)*sizeof(WCHAR
));
3571 *component_len
= len
+pos
;
3574 *flags
|= success_flag
;
3578 static void reset_builder(UriBuilder
*builder
) {
3580 IUri_Release(&builder
->uri
->IUri_iface
);
3581 builder
->uri
= NULL
;
3583 heap_free(builder
->fragment
);
3584 builder
->fragment
= NULL
;
3585 builder
->fragment_len
= 0;
3587 heap_free(builder
->host
);
3588 builder
->host
= NULL
;
3589 builder
->host_len
= 0;
3591 heap_free(builder
->password
);
3592 builder
->password
= NULL
;
3593 builder
->password_len
= 0;
3595 heap_free(builder
->path
);
3596 builder
->path
= NULL
;
3597 builder
->path_len
= 0;
3599 heap_free(builder
->query
);
3600 builder
->query
= NULL
;
3601 builder
->query_len
= 0;
3603 heap_free(builder
->scheme
);
3604 builder
->scheme
= NULL
;
3605 builder
->scheme_len
= 0;
3607 heap_free(builder
->username
);
3608 builder
->username
= NULL
;
3609 builder
->username_len
= 0;
3611 builder
->has_port
= FALSE
;
3613 builder
->modified_props
= 0;
3616 static HRESULT
validate_scheme_name(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3617 const WCHAR
*component
;
3622 if(builder
->scheme
) {
3623 ptr
= builder
->scheme
;
3624 expected_len
= builder
->scheme_len
;
3625 } else if(builder
->uri
&& builder
->uri
->scheme_start
> -1) {
3626 ptr
= builder
->uri
->canon_uri
+builder
->uri
->scheme_start
;
3627 expected_len
= builder
->uri
->scheme_len
;
3629 static const WCHAR nullW
[] = {0};
3636 if(parse_scheme(pptr
, data
, flags
, ALLOW_NULL_TERM_SCHEME
) &&
3637 data
->scheme_len
== expected_len
) {
3639 TRACE("(%p %p %x): Found valid scheme component %s len=%d.\n", builder
, data
, flags
,
3640 debugstr_wn(data
->scheme
, data
->scheme_len
), data
->scheme_len
);
3642 TRACE("(%p %p %x): Invalid scheme component found %s.\n", builder
, data
, flags
,
3643 debugstr_wn(component
, expected_len
));
3644 return INET_E_INVALID_URL
;
3650 static HRESULT
validate_username(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3655 if(builder
->username
) {
3656 ptr
= builder
->username
;
3657 expected_len
= builder
->username_len
;
3658 } else if(!(builder
->modified_props
& Uri_HAS_USER_NAME
) && builder
->uri
&&
3659 builder
->uri
->userinfo_start
> -1 && builder
->uri
->userinfo_split
!= 0) {
3660 /* Just use the username from the base Uri. */
3661 data
->username
= builder
->uri
->canon_uri
+builder
->uri
->userinfo_start
;
3662 data
->username_len
= (builder
->uri
->userinfo_split
> -1) ?
3663 builder
->uri
->userinfo_split
: builder
->uri
->userinfo_len
;
3671 const WCHAR
*component
= ptr
;
3673 if(parse_username(pptr
, data
, flags
, ALLOW_NULL_TERM_USER_NAME
) &&
3674 data
->username_len
== expected_len
)
3675 TRACE("(%p %p %x): Found valid username component %s len=%d.\n", builder
, data
, flags
,
3676 debugstr_wn(data
->username
, data
->username_len
), data
->username_len
);
3678 TRACE("(%p %p %x): Invalid username component found %s.\n", builder
, data
, flags
,
3679 debugstr_wn(component
, expected_len
));
3680 return INET_E_INVALID_URL
;
3687 static HRESULT
validate_password(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3692 if(builder
->password
) {
3693 ptr
= builder
->password
;
3694 expected_len
= builder
->password_len
;
3695 } else if(!(builder
->modified_props
& Uri_HAS_PASSWORD
) && builder
->uri
&&
3696 builder
->uri
->userinfo_split
> -1) {
3697 data
->password
= builder
->uri
->canon_uri
+builder
->uri
->userinfo_start
+builder
->uri
->userinfo_split
+1;
3698 data
->password_len
= builder
->uri
->userinfo_len
-builder
->uri
->userinfo_split
-1;
3706 const WCHAR
*component
= ptr
;
3708 if(parse_password(pptr
, data
, flags
, ALLOW_NULL_TERM_PASSWORD
) &&
3709 data
->password_len
== expected_len
)
3710 TRACE("(%p %p %x): Found valid password component %s len=%d.\n", builder
, data
, flags
,
3711 debugstr_wn(data
->password
, data
->password_len
), data
->password_len
);
3713 TRACE("(%p %p %x): Invalid password component found %s.\n", builder
, data
, flags
,
3714 debugstr_wn(component
, expected_len
));
3715 return INET_E_INVALID_URL
;
3722 static HRESULT
validate_userinfo(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3725 hr
= validate_username(builder
, data
, flags
);
3729 hr
= validate_password(builder
, data
, flags
);
3736 static HRESULT
validate_host(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3742 ptr
= builder
->host
;
3743 expected_len
= builder
->host_len
;
3744 } else if(!(builder
->modified_props
& Uri_HAS_HOST
) && builder
->uri
&& builder
->uri
->host_start
> -1) {
3745 ptr
= builder
->uri
->canon_uri
+ builder
->uri
->host_start
;
3746 expected_len
= builder
->uri
->host_len
;
3751 const WCHAR
*component
= ptr
;
3752 DWORD extras
= ALLOW_BRACKETLESS_IP_LITERAL
|IGNORE_PORT_DELIMITER
|SKIP_IP_FUTURE_CHECK
;
3755 if(parse_host(pptr
, data
, flags
, extras
) && data
->host_len
== expected_len
)
3756 TRACE("(%p %p %x): Found valid host name %s len=%d type=%d.\n", builder
, data
, flags
,
3757 debugstr_wn(data
->host
, data
->host_len
), data
->host_len
, data
->host_type
);
3759 TRACE("(%p %p %x): Invalid host name found %s.\n", builder
, data
, flags
,
3760 debugstr_wn(component
, expected_len
));
3761 return INET_E_INVALID_URL
;
3768 static void setup_port(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3769 if(builder
->modified_props
& Uri_HAS_PORT
) {
3770 if(builder
->has_port
) {
3771 data
->has_port
= TRUE
;
3772 data
->port_value
= builder
->port
;
3774 } else if(builder
->uri
&& builder
->uri
->has_port
) {
3775 data
->has_port
= TRUE
;
3776 data
->port_value
= builder
->uri
->port
;
3780 TRACE("(%p %p %x): Using %u as port for IUri.\n", builder
, data
, flags
, data
->port_value
);
3783 static HRESULT
validate_path(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3784 const WCHAR
*ptr
= NULL
;
3785 const WCHAR
*component
;
3788 BOOL check_len
= TRUE
;
3792 ptr
= builder
->path
;
3793 expected_len
= builder
->path_len
;
3794 } else if(!(builder
->modified_props
& Uri_HAS_PATH
) &&
3795 builder
->uri
&& builder
->uri
->path_start
> -1) {
3796 ptr
= builder
->uri
->canon_uri
+builder
->uri
->path_start
;
3797 expected_len
= builder
->uri
->path_len
;
3799 static const WCHAR nullW
[] = {0};
3807 /* How the path is validated depends on what type of
3810 valid
= data
->is_opaque
?
3811 parse_path_opaque(pptr
, data
, flags
) : parse_path_hierarchical(pptr
, data
, flags
);
3813 if(!valid
|| (check_len
&& expected_len
!= data
->path_len
)) {
3814 TRACE("(%p %p %x): Invalid path component %s.\n", builder
, data
, flags
,
3815 debugstr_wn(component
, check_len
? expected_len
: -1) );
3816 return INET_E_INVALID_URL
;
3819 TRACE("(%p %p %x): Valid path component %s len=%d.\n", builder
, data
, flags
,
3820 debugstr_wn(data
->path
, data
->path_len
), data
->path_len
);
3825 static HRESULT
validate_query(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3826 const WCHAR
*ptr
= NULL
;
3830 if(builder
->query
) {
3831 ptr
= builder
->query
;
3832 expected_len
= builder
->query_len
;
3833 } else if(!(builder
->modified_props
& Uri_HAS_QUERY
) && builder
->uri
&&
3834 builder
->uri
->query_start
> -1) {
3835 ptr
= builder
->uri
->canon_uri
+builder
->uri
->query_start
;
3836 expected_len
= builder
->uri
->query_len
;
3840 const WCHAR
*component
= ptr
;
3843 if(parse_query(pptr
, data
, flags
) && expected_len
== data
->query_len
)
3844 TRACE("(%p %p %x): Valid query component %s len=%d.\n", builder
, data
, flags
,
3845 debugstr_wn(data
->query
, data
->query_len
), data
->query_len
);
3847 TRACE("(%p %p %x): Invalid query component %s.\n", builder
, data
, flags
,
3848 debugstr_wn(component
, expected_len
));
3849 return INET_E_INVALID_URL
;
3856 static HRESULT
validate_fragment(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3857 const WCHAR
*ptr
= NULL
;
3861 if(builder
->fragment
) {
3862 ptr
= builder
->fragment
;
3863 expected_len
= builder
->fragment_len
;
3864 } else if(!(builder
->modified_props
& Uri_HAS_FRAGMENT
) && builder
->uri
&&
3865 builder
->uri
->fragment_start
> -1) {
3866 ptr
= builder
->uri
->canon_uri
+builder
->uri
->fragment_start
;
3867 expected_len
= builder
->uri
->fragment_len
;
3871 const WCHAR
*component
= ptr
;
3874 if(parse_fragment(pptr
, data
, flags
) && expected_len
== data
->fragment_len
)
3875 TRACE("(%p %p %x): Valid fragment component %s len=%d.\n", builder
, data
, flags
,
3876 debugstr_wn(data
->fragment
, data
->fragment_len
), data
->fragment_len
);
3878 TRACE("(%p %p %x): Invalid fragment component %s.\n", builder
, data
, flags
,
3879 debugstr_wn(component
, expected_len
));
3880 return INET_E_INVALID_URL
;
3887 static HRESULT
validate_components(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3890 memset(data
, 0, sizeof(parse_data
));
3892 TRACE("(%p %p %x): Beginning to validate builder components.\n", builder
, data
, flags
);
3894 hr
= validate_scheme_name(builder
, data
, flags
);
3898 /* Extra validation for file schemes. */
3899 if(data
->scheme_type
== URL_SCHEME_FILE
) {
3900 if((builder
->password
|| (builder
->uri
&& builder
->uri
->userinfo_split
> -1)) ||
3901 (builder
->username
|| (builder
->uri
&& builder
->uri
->userinfo_start
> -1))) {
3902 TRACE("(%p %p %x): File schemes can't contain a username or password.\n",
3903 builder
, data
, flags
);
3904 return INET_E_INVALID_URL
;
3908 hr
= validate_userinfo(builder
, data
, flags
);
3912 hr
= validate_host(builder
, data
, flags
);
3916 setup_port(builder
, data
, flags
);
3918 /* The URI is opaque if it doesn't have an authority component. */
3919 if(!data
->is_relative
)
3920 data
->is_opaque
= !data
->username
&& !data
->password
&& !data
->host
&& !data
->has_port
;
3922 data
->is_opaque
= !data
->host
&& !data
->has_port
;
3924 hr
= validate_path(builder
, data
, flags
);
3928 hr
= validate_query(builder
, data
, flags
);
3932 hr
= validate_fragment(builder
, data
, flags
);
3936 TRACE("(%p %p %x): Finished validating builder components.\n", builder
, data
, flags
);
3941 static void convert_to_dos_path(const WCHAR
*path
, DWORD path_len
,
3942 WCHAR
*output
, DWORD
*output_len
)
3944 const WCHAR
*ptr
= path
;
3946 if(path_len
> 3 && *ptr
== '/' && is_drive_path(path
+1))
3947 /* Skip over the leading / before the drive path. */
3950 for(; ptr
< path
+path_len
; ++ptr
) {
3963 /* Generates a raw uri string using the parse_data. */
3964 static DWORD
generate_raw_uri(const parse_data
*data
, BSTR uri
, DWORD flags
) {
3969 memcpy(uri
, data
->scheme
, data
->scheme_len
*sizeof(WCHAR
));
3970 uri
[data
->scheme_len
] = ':';
3972 length
+= data
->scheme_len
+1;
3975 if(!data
->is_opaque
) {
3976 /* For the "//" which appears before the authority component. */
3979 uri
[length
+1] = '/';
3983 /* Check if we need to add the "\\" before the host name
3984 * of a UNC server name in a DOS path.
3986 if(flags
& RAW_URI_CONVERT_TO_DOS_PATH
&&
3987 data
->scheme_type
== URL_SCHEME_FILE
&& data
->host
) {
3990 uri
[length
+1] = '\\';
3996 if(data
->username
) {
3998 memcpy(uri
+length
, data
->username
, data
->username_len
*sizeof(WCHAR
));
3999 length
+= data
->username_len
;
4002 if(data
->password
) {
4005 memcpy(uri
+length
+1, data
->password
, data
->password_len
*sizeof(WCHAR
));
4007 length
+= data
->password_len
+1;
4010 if(data
->password
|| data
->username
) {
4017 /* IPv6 addresses get the brackets added around them if they don't already
4020 const BOOL add_brackets
= data
->host_type
== Uri_HOST_IPV6
&& *(data
->host
) != '[';
4028 memcpy(uri
+length
, data
->host
, data
->host_len
*sizeof(WCHAR
));
4029 length
+= data
->host_len
;
4038 if(data
->has_port
) {
4039 /* The port isn't included in the raw uri if it's the default
4040 * port for the scheme type.
4043 BOOL is_default
= FALSE
;
4045 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
4046 if(data
->scheme_type
== default_ports
[i
].scheme
&&
4047 data
->port_value
== default_ports
[i
].port
)
4051 if(!is_default
|| flags
& RAW_URI_FORCE_PORT_DISP
) {
4057 length
+= ui2str(uri
+length
, data
->port_value
);
4059 length
+= ui2str(NULL
, data
->port_value
);
4063 /* Check if a '/' should be added before the path for hierarchical URIs. */
4064 if(!data
->is_opaque
&& data
->path
&& *(data
->path
) != '/') {
4071 if(!data
->is_opaque
&& data
->scheme_type
== URL_SCHEME_FILE
&&
4072 flags
& RAW_URI_CONVERT_TO_DOS_PATH
) {
4076 convert_to_dos_path(data
->path
, data
->path_len
, uri
+length
, &len
);
4078 convert_to_dos_path(data
->path
, data
->path_len
, NULL
, &len
);
4083 memcpy(uri
+length
, data
->path
, data
->path_len
*sizeof(WCHAR
));
4084 length
+= data
->path_len
;
4090 memcpy(uri
+length
, data
->query
, data
->query_len
*sizeof(WCHAR
));
4091 length
+= data
->query_len
;
4094 if(data
->fragment
) {
4096 memcpy(uri
+length
, data
->fragment
, data
->fragment_len
*sizeof(WCHAR
));
4097 length
+= data
->fragment_len
;
4101 TRACE("(%p %p): Generated raw uri=%s len=%d\n", data
, uri
, debugstr_wn(uri
, length
), length
);
4103 TRACE("(%p %p): Computed raw uri len=%d\n", data
, uri
, length
);
4108 static HRESULT
generate_uri(const UriBuilder
*builder
, const parse_data
*data
, Uri
*uri
, DWORD flags
) {
4110 DWORD length
= generate_raw_uri(data
, NULL
, 0);
4111 uri
->raw_uri
= SysAllocStringLen(NULL
, length
);
4113 return E_OUTOFMEMORY
;
4115 generate_raw_uri(data
, uri
->raw_uri
, 0);
4117 hr
= canonicalize_uri(data
, uri
, flags
);
4119 if(hr
== E_INVALIDARG
)
4120 return INET_E_INVALID_URL
;
4124 uri
->create_flags
= flags
;
4128 static inline Uri
* impl_from_IUri(IUri
*iface
)
4130 return CONTAINING_RECORD(iface
, Uri
, IUri_iface
);
4133 static inline void destory_uri_obj(Uri
*This
)
4135 SysFreeString(This
->raw_uri
);
4136 heap_free(This
->canon_uri
);
4140 static HRESULT WINAPI
Uri_QueryInterface(IUri
*iface
, REFIID riid
, void **ppv
)
4142 Uri
*This
= impl_from_IUri(iface
);
4144 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
4145 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
4146 *ppv
= &This
->IUri_iface
;
4147 }else if(IsEqualGUID(&IID_IUri
, riid
)) {
4148 TRACE("(%p)->(IID_IUri %p)\n", This
, ppv
);
4149 *ppv
= &This
->IUri_iface
;
4150 }else if(IsEqualGUID(&IID_IUriBuilderFactory
, riid
)) {
4151 TRACE("(%p)->(IID_IUriBuilderFactory %p)\n", This
, riid
);
4152 *ppv
= &This
->IUriBuilderFactory_iface
;
4153 }else if(IsEqualGUID(&IID_IUriObj
, riid
)) {
4154 TRACE("(%p)->(IID_IUriObj %p)\n", This
, ppv
);
4158 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
4160 return E_NOINTERFACE
;
4163 IUnknown_AddRef((IUnknown
*)*ppv
);
4167 static ULONG WINAPI
Uri_AddRef(IUri
*iface
)
4169 Uri
*This
= impl_from_IUri(iface
);
4170 LONG ref
= InterlockedIncrement(&This
->ref
);
4172 TRACE("(%p) ref=%d\n", This
, ref
);
4177 static ULONG WINAPI
Uri_Release(IUri
*iface
)
4179 Uri
*This
= impl_from_IUri(iface
);
4180 LONG ref
= InterlockedDecrement(&This
->ref
);
4182 TRACE("(%p) ref=%d\n", This
, ref
);
4185 destory_uri_obj(This
);
4190 static HRESULT WINAPI
Uri_GetPropertyBSTR(IUri
*iface
, Uri_PROPERTY uriProp
, BSTR
*pbstrProperty
, DWORD dwFlags
)
4192 Uri
*This
= impl_from_IUri(iface
);
4194 TRACE("(%p)->(%d %p %x)\n", This
, uriProp
, pbstrProperty
, dwFlags
);
4199 if(uriProp
> Uri_PROPERTY_STRING_LAST
) {
4200 /* Windows allocates an empty BSTR for invalid Uri_PROPERTY's. */
4201 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4202 if(!(*pbstrProperty
))
4203 return E_OUTOFMEMORY
;
4205 /* It only returns S_FALSE for the ZONE property... */
4206 if(uriProp
== Uri_PROPERTY_ZONE
)
4212 /* Don't have support for flags yet. */
4214 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pbstrProperty
, dwFlags
);
4219 case Uri_PROPERTY_ABSOLUTE_URI
:
4220 if(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
) {
4221 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4224 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
&& This
->userinfo_start
> -1) {
4225 if(This
->userinfo_len
== 0) {
4226 /* Don't include the '@' after the userinfo component. */
4227 *pbstrProperty
= SysAllocStringLen(NULL
, This
->canon_len
-1);
4229 if(*pbstrProperty
) {
4230 /* Copy everything before it. */
4231 memcpy(*pbstrProperty
, This
->canon_uri
, This
->userinfo_start
*sizeof(WCHAR
));
4233 /* And everything after it. */
4234 memcpy(*pbstrProperty
+This
->userinfo_start
, This
->canon_uri
+This
->userinfo_start
+1,
4235 (This
->canon_len
-This
->userinfo_start
-1)*sizeof(WCHAR
));
4237 } else if(This
->userinfo_split
== 0 && This
->userinfo_len
== 1) {
4238 /* Don't include the ":@" */
4239 *pbstrProperty
= SysAllocStringLen(NULL
, This
->canon_len
-2);
4241 if(*pbstrProperty
) {
4242 memcpy(*pbstrProperty
, This
->canon_uri
, This
->userinfo_start
*sizeof(WCHAR
));
4243 memcpy(*pbstrProperty
+This
->userinfo_start
, This
->canon_uri
+This
->userinfo_start
+2,
4244 (This
->canon_len
-This
->userinfo_start
-2)*sizeof(WCHAR
));
4247 *pbstrProperty
= SysAllocString(This
->canon_uri
);
4251 *pbstrProperty
= SysAllocString(This
->canon_uri
);
4256 if(!(*pbstrProperty
))
4257 hres
= E_OUTOFMEMORY
;
4260 case Uri_PROPERTY_AUTHORITY
:
4261 if(This
->authority_start
> -1) {
4262 if(This
->port_offset
> -1 && is_default_port(This
->scheme_type
, This
->port
) &&
4263 This
->display_modifiers
& URI_DISPLAY_NO_DEFAULT_PORT_AUTH
)
4264 /* Don't include the port in the authority component. */
4265 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->authority_start
, This
->port_offset
);
4267 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->authority_start
, This
->authority_len
);
4270 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4274 if(!(*pbstrProperty
))
4275 hres
= E_OUTOFMEMORY
;
4278 case Uri_PROPERTY_DISPLAY_URI
:
4279 /* The Display URI contains everything except for the userinfo for known
4282 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
&& This
->userinfo_start
> -1) {
4283 *pbstrProperty
= SysAllocStringLen(NULL
, This
->canon_len
-This
->userinfo_len
);
4285 if(*pbstrProperty
) {
4286 /* Copy everything before the userinfo over. */
4287 memcpy(*pbstrProperty
, This
->canon_uri
, This
->userinfo_start
*sizeof(WCHAR
));
4288 /* Copy everything after the userinfo over. */
4289 memcpy(*pbstrProperty
+This
->userinfo_start
,
4290 This
->canon_uri
+This
->userinfo_start
+This
->userinfo_len
+1,
4291 (This
->canon_len
-(This
->userinfo_start
+This
->userinfo_len
+1))*sizeof(WCHAR
));
4294 *pbstrProperty
= SysAllocString(This
->canon_uri
);
4296 if(!(*pbstrProperty
))
4297 hres
= E_OUTOFMEMORY
;
4302 case Uri_PROPERTY_DOMAIN
:
4303 if(This
->domain_offset
> -1) {
4304 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->host_start
+This
->domain_offset
,
4305 This
->host_len
-This
->domain_offset
);
4308 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4312 if(!(*pbstrProperty
))
4313 hres
= E_OUTOFMEMORY
;
4316 case Uri_PROPERTY_EXTENSION
:
4317 if(This
->extension_offset
> -1) {
4318 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->path_start
+This
->extension_offset
,
4319 This
->path_len
-This
->extension_offset
);
4322 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4326 if(!(*pbstrProperty
))
4327 hres
= E_OUTOFMEMORY
;
4330 case Uri_PROPERTY_FRAGMENT
:
4331 if(This
->fragment_start
> -1) {
4332 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->fragment_start
, This
->fragment_len
);
4335 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4339 if(!(*pbstrProperty
))
4340 hres
= E_OUTOFMEMORY
;
4343 case Uri_PROPERTY_HOST
:
4344 if(This
->host_start
> -1) {
4345 /* The '[' and ']' aren't included for IPv6 addresses. */
4346 if(This
->host_type
== Uri_HOST_IPV6
)
4347 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->host_start
+1, This
->host_len
-2);
4349 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->host_start
, This
->host_len
);
4353 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4357 if(!(*pbstrProperty
))
4358 hres
= E_OUTOFMEMORY
;
4361 case Uri_PROPERTY_PASSWORD
:
4362 if(This
->userinfo_split
> -1) {
4363 *pbstrProperty
= SysAllocStringLen(
4364 This
->canon_uri
+This
->userinfo_start
+This
->userinfo_split
+1,
4365 This
->userinfo_len
-This
->userinfo_split
-1);
4368 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4372 if(!(*pbstrProperty
))
4373 return E_OUTOFMEMORY
;
4376 case Uri_PROPERTY_PATH
:
4377 if(This
->path_start
> -1) {
4378 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->path_start
, This
->path_len
);
4381 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4385 if(!(*pbstrProperty
))
4386 hres
= E_OUTOFMEMORY
;
4389 case Uri_PROPERTY_PATH_AND_QUERY
:
4390 if(This
->path_start
> -1) {
4391 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->path_start
, This
->path_len
+This
->query_len
);
4393 } else if(This
->query_start
> -1) {
4394 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->query_start
, This
->query_len
);
4397 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4401 if(!(*pbstrProperty
))
4402 hres
= E_OUTOFMEMORY
;
4405 case Uri_PROPERTY_QUERY
:
4406 if(This
->query_start
> -1) {
4407 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->query_start
, This
->query_len
);
4410 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4414 if(!(*pbstrProperty
))
4415 hres
= E_OUTOFMEMORY
;
4418 case Uri_PROPERTY_RAW_URI
:
4419 *pbstrProperty
= SysAllocString(This
->raw_uri
);
4420 if(!(*pbstrProperty
))
4421 hres
= E_OUTOFMEMORY
;
4425 case Uri_PROPERTY_SCHEME_NAME
:
4426 if(This
->scheme_start
> -1) {
4427 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+ This
->scheme_start
, This
->scheme_len
);
4430 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4434 if(!(*pbstrProperty
))
4435 hres
= E_OUTOFMEMORY
;
4438 case Uri_PROPERTY_USER_INFO
:
4439 if(This
->userinfo_start
> -1) {
4440 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->userinfo_start
, This
->userinfo_len
);
4443 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4447 if(!(*pbstrProperty
))
4448 hres
= E_OUTOFMEMORY
;
4451 case Uri_PROPERTY_USER_NAME
:
4452 if(This
->userinfo_start
> -1 && This
->userinfo_split
!= 0) {
4453 /* If userinfo_split is set, that means a password exists
4454 * so the username is only from userinfo_start to userinfo_split.
4456 if(This
->userinfo_split
> -1) {
4457 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+ This
->userinfo_start
, This
->userinfo_split
);
4460 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+ This
->userinfo_start
, This
->userinfo_len
);
4464 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4468 if(!(*pbstrProperty
))
4469 return E_OUTOFMEMORY
;
4473 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pbstrProperty
, dwFlags
);
4480 static HRESULT WINAPI
Uri_GetPropertyLength(IUri
*iface
, Uri_PROPERTY uriProp
, DWORD
*pcchProperty
, DWORD dwFlags
)
4482 Uri
*This
= impl_from_IUri(iface
);
4484 TRACE("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4487 return E_INVALIDARG
;
4489 /* Can only return a length for a property if it's a string. */
4490 if(uriProp
> Uri_PROPERTY_STRING_LAST
)
4491 return E_INVALIDARG
;
4493 /* Don't have support for flags yet. */
4495 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4500 case Uri_PROPERTY_ABSOLUTE_URI
:
4501 if(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
) {
4505 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
4506 if(This
->userinfo_start
> -1 && This
->userinfo_len
== 0)
4507 /* Don't include the '@' in the length. */
4508 *pcchProperty
= This
->canon_len
-1;
4509 else if(This
->userinfo_start
> -1 && This
->userinfo_len
== 1 &&
4510 This
->userinfo_split
== 0)
4511 /* Don't include the ":@" in the length. */
4512 *pcchProperty
= This
->canon_len
-2;
4514 *pcchProperty
= This
->canon_len
;
4516 *pcchProperty
= This
->canon_len
;
4522 case Uri_PROPERTY_AUTHORITY
:
4523 if(This
->port_offset
> -1 &&
4524 This
->display_modifiers
& URI_DISPLAY_NO_DEFAULT_PORT_AUTH
&&
4525 is_default_port(This
->scheme_type
, This
->port
))
4526 /* Only count up until the port in the authority. */
4527 *pcchProperty
= This
->port_offset
;
4529 *pcchProperty
= This
->authority_len
;
4530 hres
= (This
->authority_start
> -1) ? S_OK
: S_FALSE
;
4532 case Uri_PROPERTY_DISPLAY_URI
:
4533 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
&& This
->userinfo_start
> -1)
4534 *pcchProperty
= This
->canon_len
-This
->userinfo_len
-1;
4536 *pcchProperty
= This
->canon_len
;
4540 case Uri_PROPERTY_DOMAIN
:
4541 if(This
->domain_offset
> -1)
4542 *pcchProperty
= This
->host_len
- This
->domain_offset
;
4546 hres
= (This
->domain_offset
> -1) ? S_OK
: S_FALSE
;
4548 case Uri_PROPERTY_EXTENSION
:
4549 if(This
->extension_offset
> -1) {
4550 *pcchProperty
= This
->path_len
- This
->extension_offset
;
4558 case Uri_PROPERTY_FRAGMENT
:
4559 *pcchProperty
= This
->fragment_len
;
4560 hres
= (This
->fragment_start
> -1) ? S_OK
: S_FALSE
;
4562 case Uri_PROPERTY_HOST
:
4563 *pcchProperty
= This
->host_len
;
4565 /* '[' and ']' aren't included in the length. */
4566 if(This
->host_type
== Uri_HOST_IPV6
)
4569 hres
= (This
->host_start
> -1) ? S_OK
: S_FALSE
;
4571 case Uri_PROPERTY_PASSWORD
:
4572 *pcchProperty
= (This
->userinfo_split
> -1) ? This
->userinfo_len
-This
->userinfo_split
-1 : 0;
4573 hres
= (This
->userinfo_split
> -1) ? S_OK
: S_FALSE
;
4575 case Uri_PROPERTY_PATH
:
4576 *pcchProperty
= This
->path_len
;
4577 hres
= (This
->path_start
> -1) ? S_OK
: S_FALSE
;
4579 case Uri_PROPERTY_PATH_AND_QUERY
:
4580 *pcchProperty
= This
->path_len
+This
->query_len
;
4581 hres
= (This
->path_start
> -1 || This
->query_start
> -1) ? S_OK
: S_FALSE
;
4583 case Uri_PROPERTY_QUERY
:
4584 *pcchProperty
= This
->query_len
;
4585 hres
= (This
->query_start
> -1) ? S_OK
: S_FALSE
;
4587 case Uri_PROPERTY_RAW_URI
:
4588 *pcchProperty
= SysStringLen(This
->raw_uri
);
4591 case Uri_PROPERTY_SCHEME_NAME
:
4592 *pcchProperty
= This
->scheme_len
;
4593 hres
= (This
->scheme_start
> -1) ? S_OK
: S_FALSE
;
4595 case Uri_PROPERTY_USER_INFO
:
4596 *pcchProperty
= This
->userinfo_len
;
4597 hres
= (This
->userinfo_start
> -1) ? S_OK
: S_FALSE
;
4599 case Uri_PROPERTY_USER_NAME
:
4600 *pcchProperty
= (This
->userinfo_split
> -1) ? This
->userinfo_split
: This
->userinfo_len
;
4601 if(This
->userinfo_split
== 0)
4604 hres
= (This
->userinfo_start
> -1) ? S_OK
: S_FALSE
;
4607 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4614 static HRESULT WINAPI
Uri_GetPropertyDWORD(IUri
*iface
, Uri_PROPERTY uriProp
, DWORD
*pcchProperty
, DWORD dwFlags
)
4616 Uri
*This
= impl_from_IUri(iface
);
4619 TRACE("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4622 return E_INVALIDARG
;
4624 /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
4625 * From what I can tell, instead of checking which URLZONE the URI belongs to it
4626 * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies to the GetZone
4629 if(uriProp
== Uri_PROPERTY_ZONE
) {
4630 *pcchProperty
= URLZONE_INVALID
;
4634 if(uriProp
< Uri_PROPERTY_DWORD_START
) {
4636 return E_INVALIDARG
;
4640 case Uri_PROPERTY_HOST_TYPE
:
4641 *pcchProperty
= This
->host_type
;
4644 case Uri_PROPERTY_PORT
:
4645 if(!This
->has_port
) {
4649 *pcchProperty
= This
->port
;
4654 case Uri_PROPERTY_SCHEME
:
4655 *pcchProperty
= This
->scheme_type
;
4659 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4666 static HRESULT WINAPI
Uri_HasProperty(IUri
*iface
, Uri_PROPERTY uriProp
, BOOL
*pfHasProperty
)
4668 Uri
*This
= impl_from_IUri(iface
);
4669 TRACE("(%p)->(%d %p)\n", This
, uriProp
, pfHasProperty
);
4672 return E_INVALIDARG
;
4675 case Uri_PROPERTY_ABSOLUTE_URI
:
4676 *pfHasProperty
= !(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
);
4678 case Uri_PROPERTY_AUTHORITY
:
4679 *pfHasProperty
= This
->authority_start
> -1;
4681 case Uri_PROPERTY_DISPLAY_URI
:
4682 *pfHasProperty
= TRUE
;
4684 case Uri_PROPERTY_DOMAIN
:
4685 *pfHasProperty
= This
->domain_offset
> -1;
4687 case Uri_PROPERTY_EXTENSION
:
4688 *pfHasProperty
= This
->extension_offset
> -1;
4690 case Uri_PROPERTY_FRAGMENT
:
4691 *pfHasProperty
= This
->fragment_start
> -1;
4693 case Uri_PROPERTY_HOST
:
4694 *pfHasProperty
= This
->host_start
> -1;
4696 case Uri_PROPERTY_PASSWORD
:
4697 *pfHasProperty
= This
->userinfo_split
> -1;
4699 case Uri_PROPERTY_PATH
:
4700 *pfHasProperty
= This
->path_start
> -1;
4702 case Uri_PROPERTY_PATH_AND_QUERY
:
4703 *pfHasProperty
= (This
->path_start
> -1 || This
->query_start
> -1);
4705 case Uri_PROPERTY_QUERY
:
4706 *pfHasProperty
= This
->query_start
> -1;
4708 case Uri_PROPERTY_RAW_URI
:
4709 *pfHasProperty
= TRUE
;
4711 case Uri_PROPERTY_SCHEME_NAME
:
4712 *pfHasProperty
= This
->scheme_start
> -1;
4714 case Uri_PROPERTY_USER_INFO
:
4715 *pfHasProperty
= This
->userinfo_start
> -1;
4717 case Uri_PROPERTY_USER_NAME
:
4718 if(This
->userinfo_split
== 0)
4719 *pfHasProperty
= FALSE
;
4721 *pfHasProperty
= This
->userinfo_start
> -1;
4723 case Uri_PROPERTY_HOST_TYPE
:
4724 *pfHasProperty
= TRUE
;
4726 case Uri_PROPERTY_PORT
:
4727 *pfHasProperty
= This
->has_port
;
4729 case Uri_PROPERTY_SCHEME
:
4730 *pfHasProperty
= TRUE
;
4732 case Uri_PROPERTY_ZONE
:
4733 *pfHasProperty
= FALSE
;
4736 FIXME("(%p)->(%d %p): Unsupported property type.\n", This
, uriProp
, pfHasProperty
);
4743 static HRESULT WINAPI
Uri_GetAbsoluteUri(IUri
*iface
, BSTR
*pstrAbsoluteUri
)
4745 TRACE("(%p)->(%p)\n", iface
, pstrAbsoluteUri
);
4746 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_ABSOLUTE_URI
, pstrAbsoluteUri
, 0);
4749 static HRESULT WINAPI
Uri_GetAuthority(IUri
*iface
, BSTR
*pstrAuthority
)
4751 TRACE("(%p)->(%p)\n", iface
, pstrAuthority
);
4752 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_AUTHORITY
, pstrAuthority
, 0);
4755 static HRESULT WINAPI
Uri_GetDisplayUri(IUri
*iface
, BSTR
*pstrDisplayUri
)
4757 TRACE("(%p)->(%p)\n", iface
, pstrDisplayUri
);
4758 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_DISPLAY_URI
, pstrDisplayUri
, 0);
4761 static HRESULT WINAPI
Uri_GetDomain(IUri
*iface
, BSTR
*pstrDomain
)
4763 TRACE("(%p)->(%p)\n", iface
, pstrDomain
);
4764 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_DOMAIN
, pstrDomain
, 0);
4767 static HRESULT WINAPI
Uri_GetExtension(IUri
*iface
, BSTR
*pstrExtension
)
4769 TRACE("(%p)->(%p)\n", iface
, pstrExtension
);
4770 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_EXTENSION
, pstrExtension
, 0);
4773 static HRESULT WINAPI
Uri_GetFragment(IUri
*iface
, BSTR
*pstrFragment
)
4775 TRACE("(%p)->(%p)\n", iface
, pstrFragment
);
4776 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_FRAGMENT
, pstrFragment
, 0);
4779 static HRESULT WINAPI
Uri_GetHost(IUri
*iface
, BSTR
*pstrHost
)
4781 TRACE("(%p)->(%p)\n", iface
, pstrHost
);
4782 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_HOST
, pstrHost
, 0);
4785 static HRESULT WINAPI
Uri_GetPassword(IUri
*iface
, BSTR
*pstrPassword
)
4787 TRACE("(%p)->(%p)\n", iface
, pstrPassword
);
4788 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_PASSWORD
, pstrPassword
, 0);
4791 static HRESULT WINAPI
Uri_GetPath(IUri
*iface
, BSTR
*pstrPath
)
4793 TRACE("(%p)->(%p)\n", iface
, pstrPath
);
4794 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_PATH
, pstrPath
, 0);
4797 static HRESULT WINAPI
Uri_GetPathAndQuery(IUri
*iface
, BSTR
*pstrPathAndQuery
)
4799 TRACE("(%p)->(%p)\n", iface
, pstrPathAndQuery
);
4800 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_PATH_AND_QUERY
, pstrPathAndQuery
, 0);
4803 static HRESULT WINAPI
Uri_GetQuery(IUri
*iface
, BSTR
*pstrQuery
)
4805 TRACE("(%p)->(%p)\n", iface
, pstrQuery
);
4806 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_QUERY
, pstrQuery
, 0);
4809 static HRESULT WINAPI
Uri_GetRawUri(IUri
*iface
, BSTR
*pstrRawUri
)
4811 TRACE("(%p)->(%p)\n", iface
, pstrRawUri
);
4812 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_RAW_URI
, pstrRawUri
, 0);
4815 static HRESULT WINAPI
Uri_GetSchemeName(IUri
*iface
, BSTR
*pstrSchemeName
)
4817 TRACE("(%p)->(%p)\n", iface
, pstrSchemeName
);
4818 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_SCHEME_NAME
, pstrSchemeName
, 0);
4821 static HRESULT WINAPI
Uri_GetUserInfo(IUri
*iface
, BSTR
*pstrUserInfo
)
4823 TRACE("(%p)->(%p)\n", iface
, pstrUserInfo
);
4824 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_USER_INFO
, pstrUserInfo
, 0);
4827 static HRESULT WINAPI
Uri_GetUserName(IUri
*iface
, BSTR
*pstrUserName
)
4829 TRACE("(%p)->(%p)\n", iface
, pstrUserName
);
4830 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_USER_NAME
, pstrUserName
, 0);
4833 static HRESULT WINAPI
Uri_GetHostType(IUri
*iface
, DWORD
*pdwHostType
)
4835 TRACE("(%p)->(%p)\n", iface
, pdwHostType
);
4836 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_HOST_TYPE
, pdwHostType
, 0);
4839 static HRESULT WINAPI
Uri_GetPort(IUri
*iface
, DWORD
*pdwPort
)
4841 TRACE("(%p)->(%p)\n", iface
, pdwPort
);
4842 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_PORT
, pdwPort
, 0);
4845 static HRESULT WINAPI
Uri_GetScheme(IUri
*iface
, DWORD
*pdwScheme
)
4847 TRACE("(%p)->(%p)\n", iface
, pdwScheme
);
4848 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_SCHEME
, pdwScheme
, 0);
4851 static HRESULT WINAPI
Uri_GetZone(IUri
*iface
, DWORD
*pdwZone
)
4853 TRACE("(%p)->(%p)\n", iface
, pdwZone
);
4854 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_ZONE
,pdwZone
, 0);
4857 static HRESULT WINAPI
Uri_GetProperties(IUri
*iface
, DWORD
*pdwProperties
)
4859 Uri
*This
= impl_from_IUri(iface
);
4860 TRACE("(%p)->(%p)\n", This
, pdwProperties
);
4863 return E_INVALIDARG
;
4865 /* All URIs have these. */
4866 *pdwProperties
= Uri_HAS_DISPLAY_URI
|Uri_HAS_RAW_URI
|Uri_HAS_SCHEME
|Uri_HAS_HOST_TYPE
;
4868 if(!(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
))
4869 *pdwProperties
|= Uri_HAS_ABSOLUTE_URI
;
4871 if(This
->scheme_start
> -1)
4872 *pdwProperties
|= Uri_HAS_SCHEME_NAME
;
4874 if(This
->authority_start
> -1) {
4875 *pdwProperties
|= Uri_HAS_AUTHORITY
;
4876 if(This
->userinfo_start
> -1) {
4877 *pdwProperties
|= Uri_HAS_USER_INFO
;
4878 if(This
->userinfo_split
!= 0)
4879 *pdwProperties
|= Uri_HAS_USER_NAME
;
4881 if(This
->userinfo_split
> -1)
4882 *pdwProperties
|= Uri_HAS_PASSWORD
;
4883 if(This
->host_start
> -1)
4884 *pdwProperties
|= Uri_HAS_HOST
;
4885 if(This
->domain_offset
> -1)
4886 *pdwProperties
|= Uri_HAS_DOMAIN
;
4890 *pdwProperties
|= Uri_HAS_PORT
;
4891 if(This
->path_start
> -1)
4892 *pdwProperties
|= Uri_HAS_PATH
|Uri_HAS_PATH_AND_QUERY
;
4893 if(This
->query_start
> -1)
4894 *pdwProperties
|= Uri_HAS_QUERY
|Uri_HAS_PATH_AND_QUERY
;
4896 if(This
->extension_offset
> -1)
4897 *pdwProperties
|= Uri_HAS_EXTENSION
;
4899 if(This
->fragment_start
> -1)
4900 *pdwProperties
|= Uri_HAS_FRAGMENT
;
4905 static HRESULT WINAPI
Uri_IsEqual(IUri
*iface
, IUri
*pUri
, BOOL
*pfEqual
)
4907 Uri
*This
= impl_from_IUri(iface
);
4910 TRACE("(%p)->(%p %p)\n", This
, pUri
, pfEqual
);
4918 /* For some reason Windows returns S_OK here... */
4922 /* Try to convert it to a Uri (allows for a more simple comparison). */
4923 if((other
= get_uri_obj(pUri
)))
4924 *pfEqual
= are_equal_simple(This
, other
);
4926 /* Do it the hard way. */
4927 FIXME("(%p)->(%p %p) No support for unknown IUri's yet.\n", iface
, pUri
, pfEqual
);
4934 static const IUriVtbl UriVtbl
= {
4938 Uri_GetPropertyBSTR
,
4939 Uri_GetPropertyLength
,
4940 Uri_GetPropertyDWORD
,
4951 Uri_GetPathAndQuery
,
4965 static inline Uri
* impl_from_IUriBuilderFactory(IUriBuilderFactory
*iface
)
4967 return CONTAINING_RECORD(iface
, Uri
, IUriBuilderFactory_iface
);
4970 static HRESULT WINAPI
UriBuilderFactory_QueryInterface(IUriBuilderFactory
*iface
, REFIID riid
, void **ppv
)
4972 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
4974 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
4975 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
4976 *ppv
= &This
->IUriBuilderFactory_iface
;
4977 }else if(IsEqualGUID(&IID_IUriBuilderFactory
, riid
)) {
4978 TRACE("(%p)->(IID_IUriBuilderFactory %p)\n", This
, ppv
);
4979 *ppv
= &This
->IUriBuilderFactory_iface
;
4980 }else if(IsEqualGUID(&IID_IUri
, riid
)) {
4981 TRACE("(%p)->(IID_IUri %p)\n", This
, ppv
);
4982 *ppv
= &This
->IUri_iface
;
4984 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
4986 return E_NOINTERFACE
;
4989 IUnknown_AddRef((IUnknown
*)*ppv
);
4993 static ULONG WINAPI
UriBuilderFactory_AddRef(IUriBuilderFactory
*iface
)
4995 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
4996 LONG ref
= InterlockedIncrement(&This
->ref
);
4998 TRACE("(%p) ref=%d\n", This
, ref
);
5003 static ULONG WINAPI
UriBuilderFactory_Release(IUriBuilderFactory
*iface
)
5005 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5006 LONG ref
= InterlockedDecrement(&This
->ref
);
5008 TRACE("(%p) ref=%d\n", This
, ref
);
5011 destory_uri_obj(This
);
5016 static HRESULT WINAPI
UriBuilderFactory_CreateIUriBuilder(IUriBuilderFactory
*iface
,
5018 DWORD_PTR dwReserved
,
5019 IUriBuilder
**ppIUriBuilder
)
5021 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5022 TRACE("(%p)->(%08x %08x %p)\n", This
, dwFlags
, (DWORD
)dwReserved
, ppIUriBuilder
);
5027 if(dwFlags
|| dwReserved
) {
5028 *ppIUriBuilder
= NULL
;
5029 return E_INVALIDARG
;
5032 return CreateIUriBuilder(NULL
, 0, 0, ppIUriBuilder
);
5035 static HRESULT WINAPI
UriBuilderFactory_CreateInitializedIUriBuilder(IUriBuilderFactory
*iface
,
5037 DWORD_PTR dwReserved
,
5038 IUriBuilder
**ppIUriBuilder
)
5040 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5041 TRACE("(%p)->(%08x %08x %p)\n", This
, dwFlags
, (DWORD
)dwReserved
, ppIUriBuilder
);
5046 if(dwFlags
|| dwReserved
) {
5047 *ppIUriBuilder
= NULL
;
5048 return E_INVALIDARG
;
5051 return CreateIUriBuilder(&This
->IUri_iface
, 0, 0, ppIUriBuilder
);
5054 static const IUriBuilderFactoryVtbl UriBuilderFactoryVtbl
= {
5055 UriBuilderFactory_QueryInterface
,
5056 UriBuilderFactory_AddRef
,
5057 UriBuilderFactory_Release
,
5058 UriBuilderFactory_CreateIUriBuilder
,
5059 UriBuilderFactory_CreateInitializedIUriBuilder
5062 static Uri
* create_uri_obj(void) {
5063 Uri
*ret
= heap_alloc_zero(sizeof(Uri
));
5065 ret
->IUri_iface
.lpVtbl
= &UriVtbl
;
5066 ret
->IUriBuilderFactory_iface
.lpVtbl
= &UriBuilderFactoryVtbl
;
5073 /***********************************************************************
5074 * CreateUri (urlmon.@)
5076 * Creates a new IUri object using the URI represented by pwzURI. This function
5077 * parses and validates the components of pwzURI and then canonicalizes the
5078 * parsed components.
5081 * pwzURI [I] The URI to parse, validate, and canonicalize.
5082 * dwFlags [I] Flags which can affect how the parsing/canonicalization is performed.
5083 * dwReserved [I] Reserved (not used).
5084 * ppURI [O] The resulting IUri after parsing/canonicalization occurs.
5087 * Success: Returns S_OK. ppURI contains the pointer to the newly allocated IUri.
5088 * Failure: E_INVALIDARG if there's invalid flag combinations in dwFlags, or an
5089 * invalid parameters, or pwzURI doesn't represnt a valid URI.
5090 * E_OUTOFMEMORY if any memory allocation fails.
5094 * Uri_CREATE_CANONICALIZE, Uri_CREATE_DECODE_EXTRA_INFO, Uri_CREATE_CRACK_UNKNOWN_SCHEMES,
5095 * Uri_CREATE_PRE_PROCESS_HTML_URI, Uri_CREATE_NO_IE_SETTINGS.
5097 HRESULT WINAPI
CreateUri(LPCWSTR pwzURI
, DWORD dwFlags
, DWORD_PTR dwReserved
, IUri
**ppURI
)
5099 const DWORD supported_flags
= Uri_CREATE_ALLOW_RELATIVE
|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME
|
5100 Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME
|Uri_CREATE_NO_CANONICALIZE
|Uri_CREATE_CANONICALIZE
|
5101 Uri_CREATE_DECODE_EXTRA_INFO
|Uri_CREATE_NO_DECODE_EXTRA_INFO
|Uri_CREATE_CRACK_UNKNOWN_SCHEMES
|
5102 Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
|Uri_CREATE_PRE_PROCESS_HTML_URI
|Uri_CREATE_NO_PRE_PROCESS_HTML_URI
|
5103 Uri_CREATE_NO_IE_SETTINGS
|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
|Uri_CREATE_FILE_USE_DOS_PATH
;
5108 TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI
), dwFlags
, (DWORD
)dwReserved
, ppURI
);
5111 return E_INVALIDARG
;
5113 if(!pwzURI
|| !*pwzURI
) {
5115 return E_INVALIDARG
;
5118 /* Check for invalid flags. */
5119 if(has_invalid_flag_combination(dwFlags
)) {
5121 return E_INVALIDARG
;
5124 /* Currently unsupported. */
5125 if(dwFlags
& ~supported_flags
)
5126 FIXME("Ignoring unsupported flag(s) %x\n", dwFlags
& ~supported_flags
);
5128 ret
= create_uri_obj();
5131 return E_OUTOFMEMORY
;
5134 /* Explicitly set the default flags if it doesn't cause a flag conflict. */
5135 apply_default_flags(&dwFlags
);
5137 /* Pre process the URI, unless told otherwise. */
5138 if(!(dwFlags
& Uri_CREATE_NO_PRE_PROCESS_HTML_URI
))
5139 ret
->raw_uri
= pre_process_uri(pwzURI
);
5141 ret
->raw_uri
= SysAllocString(pwzURI
);
5145 return E_OUTOFMEMORY
;
5148 memset(&data
, 0, sizeof(parse_data
));
5149 data
.uri
= ret
->raw_uri
;
5151 /* Validate and parse the URI into it's components. */
5152 if(!parse_uri(&data
, dwFlags
)) {
5153 /* Encountered an unsupported or invalid URI */
5154 IUri_Release(&ret
->IUri_iface
);
5156 return E_INVALIDARG
;
5159 /* Canonicalize the URI. */
5160 hr
= canonicalize_uri(&data
, ret
, dwFlags
);
5162 IUri_Release(&ret
->IUri_iface
);
5167 ret
->create_flags
= dwFlags
;
5169 *ppURI
= &ret
->IUri_iface
;
5173 /***********************************************************************
5174 * CreateUriWithFragment (urlmon.@)
5176 * Creates a new IUri object. This is almost the same as CreateUri, expect that
5177 * it allows you to explicitly specify a fragment (pwzFragment) for pwzURI.
5180 * pwzURI [I] The URI to parse and perform canonicalization on.
5181 * pwzFragment [I] The explict fragment string which should be added to pwzURI.
5182 * dwFlags [I] The flags which will be passed to CreateUri.
5183 * dwReserved [I] Reserved (not used).
5184 * ppURI [O] The resulting IUri after parsing/canonicalization.
5187 * Success: S_OK. ppURI contains the pointer to the newly allocated IUri.
5188 * Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment
5189 * isn't NULL. Will also return E_INVALIDARG for the same reasons as
5190 * CreateUri will. E_OUTOFMEMORY if any allocations fail.
5192 HRESULT WINAPI
CreateUriWithFragment(LPCWSTR pwzURI
, LPCWSTR pwzFragment
, DWORD dwFlags
,
5193 DWORD_PTR dwReserved
, IUri
**ppURI
)
5196 TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI
), debugstr_w(pwzFragment
), dwFlags
, (DWORD
)dwReserved
, ppURI
);
5199 return E_INVALIDARG
;
5203 return E_INVALIDARG
;
5206 /* Check if a fragment should be appended to the URI string. */
5209 DWORD uri_len
, frag_len
;
5212 /* Check if the original URI already has a fragment component. */
5213 if(StrChrW(pwzURI
, '#')) {
5215 return E_INVALIDARG
;
5218 uri_len
= lstrlenW(pwzURI
);
5219 frag_len
= lstrlenW(pwzFragment
);
5221 /* If the fragment doesn't start with a '#', one will be added. */
5222 add_pound
= *pwzFragment
!= '#';
5225 uriW
= heap_alloc((uri_len
+frag_len
+2)*sizeof(WCHAR
));
5227 uriW
= heap_alloc((uri_len
+frag_len
+1)*sizeof(WCHAR
));
5230 return E_OUTOFMEMORY
;
5232 memcpy(uriW
, pwzURI
, uri_len
*sizeof(WCHAR
));
5234 uriW
[uri_len
++] = '#';
5235 memcpy(uriW
+uri_len
, pwzFragment
, (frag_len
+1)*sizeof(WCHAR
));
5237 hres
= CreateUri(uriW
, dwFlags
, 0, ppURI
);
5241 /* A fragment string wasn't specified, so just forward the call. */
5242 hres
= CreateUri(pwzURI
, dwFlags
, 0, ppURI
);
5247 static HRESULT
build_uri(const UriBuilder
*builder
, IUri
**uri
, DWORD create_flags
,
5248 DWORD use_orig_flags
, DWORD encoding_mask
)
5257 if(encoding_mask
&& (!builder
->uri
|| builder
->modified_props
)) {
5262 /* Decide what flags should be used when creating the Uri. */
5263 if((use_orig_flags
& UriBuilder_USE_ORIGINAL_FLAGS
) && builder
->uri
)
5264 create_flags
= builder
->uri
->create_flags
;
5266 if(has_invalid_flag_combination(create_flags
)) {
5268 return E_INVALIDARG
;
5271 /* Set the default flags if they don't cause a conflict. */
5272 apply_default_flags(&create_flags
);
5275 /* Return the base IUri if no changes have been made and the create_flags match. */
5276 if(builder
->uri
&& !builder
->modified_props
&& builder
->uri
->create_flags
== create_flags
) {
5277 *uri
= &builder
->uri
->IUri_iface
;
5282 hr
= validate_components(builder
, &data
, create_flags
);
5288 ret
= create_uri_obj();
5291 return E_OUTOFMEMORY
;
5294 hr
= generate_uri(builder
, &data
, ret
, create_flags
);
5296 IUri_Release(&ret
->IUri_iface
);
5301 *uri
= &ret
->IUri_iface
;
5305 static inline UriBuilder
* impl_from_IUriBuilder(IUriBuilder
*iface
)
5307 return CONTAINING_RECORD(iface
, UriBuilder
, IUriBuilder_iface
);
5310 static HRESULT WINAPI
UriBuilder_QueryInterface(IUriBuilder
*iface
, REFIID riid
, void **ppv
)
5312 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5314 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
5315 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
5316 *ppv
= &This
->IUriBuilder_iface
;
5317 }else if(IsEqualGUID(&IID_IUriBuilder
, riid
)) {
5318 TRACE("(%p)->(IID_IUriBuilder %p)\n", This
, ppv
);
5319 *ppv
= &This
->IUriBuilder_iface
;
5321 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
5323 return E_NOINTERFACE
;
5326 IUnknown_AddRef((IUnknown
*)*ppv
);
5330 static ULONG WINAPI
UriBuilder_AddRef(IUriBuilder
*iface
)
5332 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5333 LONG ref
= InterlockedIncrement(&This
->ref
);
5335 TRACE("(%p) ref=%d\n", This
, ref
);
5340 static ULONG WINAPI
UriBuilder_Release(IUriBuilder
*iface
)
5342 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5343 LONG ref
= InterlockedDecrement(&This
->ref
);
5345 TRACE("(%p) ref=%d\n", This
, ref
);
5348 if(This
->uri
) IUri_Release(&This
->uri
->IUri_iface
);
5349 heap_free(This
->fragment
);
5350 heap_free(This
->host
);
5351 heap_free(This
->password
);
5352 heap_free(This
->path
);
5353 heap_free(This
->query
);
5354 heap_free(This
->scheme
);
5355 heap_free(This
->username
);
5362 static HRESULT WINAPI
UriBuilder_CreateUriSimple(IUriBuilder
*iface
,
5363 DWORD dwAllowEncodingPropertyMask
,
5364 DWORD_PTR dwReserved
,
5367 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5369 TRACE("(%p)->(%d %d %p)\n", This
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5371 hr
= build_uri(This
, ppIUri
, 0, UriBuilder_USE_ORIGINAL_FLAGS
, dwAllowEncodingPropertyMask
);
5373 FIXME("(%p)->(%d %d %p)\n", This
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5377 static HRESULT WINAPI
UriBuilder_CreateUri(IUriBuilder
*iface
,
5378 DWORD dwCreateFlags
,
5379 DWORD dwAllowEncodingPropertyMask
,
5380 DWORD_PTR dwReserved
,
5383 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5385 TRACE("(%p)->(0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5387 if(dwCreateFlags
== -1)
5388 hr
= build_uri(This
, ppIUri
, 0, UriBuilder_USE_ORIGINAL_FLAGS
, dwAllowEncodingPropertyMask
);
5390 hr
= build_uri(This
, ppIUri
, dwCreateFlags
, 0, dwAllowEncodingPropertyMask
);
5393 FIXME("(%p)->(0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5397 static HRESULT WINAPI
UriBuilder_CreateUriWithFlags(IUriBuilder
*iface
,
5398 DWORD dwCreateFlags
,
5399 DWORD dwUriBuilderFlags
,
5400 DWORD dwAllowEncodingPropertyMask
,
5401 DWORD_PTR dwReserved
,
5404 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5406 TRACE("(%p)->(0x%08x 0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwUriBuilderFlags
,
5407 dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5409 hr
= build_uri(This
, ppIUri
, dwCreateFlags
, dwUriBuilderFlags
, dwAllowEncodingPropertyMask
);
5411 FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwUriBuilderFlags
,
5412 dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5416 static HRESULT WINAPI
UriBuilder_GetIUri(IUriBuilder
*iface
, IUri
**ppIUri
)
5418 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5419 TRACE("(%p)->(%p)\n", This
, ppIUri
);
5425 IUri
*uri
= &This
->uri
->IUri_iface
;
5434 static HRESULT WINAPI
UriBuilder_SetIUri(IUriBuilder
*iface
, IUri
*pIUri
)
5436 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5437 TRACE("(%p)->(%p)\n", This
, pIUri
);
5442 if((uri
= get_uri_obj(pIUri
))) {
5443 /* Only reset the builder if it's Uri isn't the same as
5444 * the Uri passed to the function.
5446 if(This
->uri
!= uri
) {
5447 reset_builder(This
);
5451 This
->port
= uri
->port
;
5456 FIXME("(%p)->(%p) Unknown IUri types not supported yet.\n", This
, pIUri
);
5459 } else if(This
->uri
)
5460 /* Only reset the builder if it's Uri isn't NULL. */
5461 reset_builder(This
);
5466 static HRESULT WINAPI
UriBuilder_GetFragment(IUriBuilder
*iface
, DWORD
*pcchFragment
, LPCWSTR
*ppwzFragment
)
5468 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5469 TRACE("(%p)->(%p %p)\n", This
, pcchFragment
, ppwzFragment
);
5471 if(!This
->uri
|| This
->uri
->fragment_start
== -1 || This
->modified_props
& Uri_HAS_FRAGMENT
)
5472 return get_builder_component(&This
->fragment
, &This
->fragment_len
, NULL
, 0, ppwzFragment
, pcchFragment
);
5474 return get_builder_component(&This
->fragment
, &This
->fragment_len
, This
->uri
->canon_uri
+This
->uri
->fragment_start
,
5475 This
->uri
->fragment_len
, ppwzFragment
, pcchFragment
);
5478 static HRESULT WINAPI
UriBuilder_GetHost(IUriBuilder
*iface
, DWORD
*pcchHost
, LPCWSTR
*ppwzHost
)
5480 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5481 TRACE("(%p)->(%p %p)\n", This
, pcchHost
, ppwzHost
);
5483 if(!This
->uri
|| This
->uri
->host_start
== -1 || This
->modified_props
& Uri_HAS_HOST
)
5484 return get_builder_component(&This
->host
, &This
->host_len
, NULL
, 0, ppwzHost
, pcchHost
);
5486 if(This
->uri
->host_type
== Uri_HOST_IPV6
)
5487 /* Don't include the '[' and ']' around the address. */
5488 return get_builder_component(&This
->host
, &This
->host_len
, This
->uri
->canon_uri
+This
->uri
->host_start
+1,
5489 This
->uri
->host_len
-2, ppwzHost
, pcchHost
);
5491 return get_builder_component(&This
->host
, &This
->host_len
, This
->uri
->canon_uri
+This
->uri
->host_start
,
5492 This
->uri
->host_len
, ppwzHost
, pcchHost
);
5496 static HRESULT WINAPI
UriBuilder_GetPassword(IUriBuilder
*iface
, DWORD
*pcchPassword
, LPCWSTR
*ppwzPassword
)
5498 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5499 TRACE("(%p)->(%p %p)\n", This
, pcchPassword
, ppwzPassword
);
5501 if(!This
->uri
|| This
->uri
->userinfo_split
== -1 || This
->modified_props
& Uri_HAS_PASSWORD
)
5502 return get_builder_component(&This
->password
, &This
->password_len
, NULL
, 0, ppwzPassword
, pcchPassword
);
5504 const WCHAR
*start
= This
->uri
->canon_uri
+This
->uri
->userinfo_start
+This
->uri
->userinfo_split
+1;
5505 DWORD len
= This
->uri
->userinfo_len
-This
->uri
->userinfo_split
-1;
5506 return get_builder_component(&This
->password
, &This
->password_len
, start
, len
, ppwzPassword
, pcchPassword
);
5510 static HRESULT WINAPI
UriBuilder_GetPath(IUriBuilder
*iface
, DWORD
*pcchPath
, LPCWSTR
*ppwzPath
)
5512 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5513 TRACE("(%p)->(%p %p)\n", This
, pcchPath
, ppwzPath
);
5515 if(!This
->uri
|| This
->uri
->path_start
== -1 || This
->modified_props
& Uri_HAS_PATH
)
5516 return get_builder_component(&This
->path
, &This
->path_len
, NULL
, 0, ppwzPath
, pcchPath
);
5518 return get_builder_component(&This
->path
, &This
->path_len
, This
->uri
->canon_uri
+This
->uri
->path_start
,
5519 This
->uri
->path_len
, ppwzPath
, pcchPath
);
5522 static HRESULT WINAPI
UriBuilder_GetPort(IUriBuilder
*iface
, BOOL
*pfHasPort
, DWORD
*pdwPort
)
5524 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5525 TRACE("(%p)->(%p %p)\n", This
, pfHasPort
, pdwPort
);
5538 *pfHasPort
= This
->has_port
;
5539 *pdwPort
= This
->port
;
5543 static HRESULT WINAPI
UriBuilder_GetQuery(IUriBuilder
*iface
, DWORD
*pcchQuery
, LPCWSTR
*ppwzQuery
)
5545 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5546 TRACE("(%p)->(%p %p)\n", This
, pcchQuery
, ppwzQuery
);
5548 if(!This
->uri
|| This
->uri
->query_start
== -1 || This
->modified_props
& Uri_HAS_QUERY
)
5549 return get_builder_component(&This
->query
, &This
->query_len
, NULL
, 0, ppwzQuery
, pcchQuery
);
5551 return get_builder_component(&This
->query
, &This
->query_len
, This
->uri
->canon_uri
+This
->uri
->query_start
,
5552 This
->uri
->query_len
, ppwzQuery
, pcchQuery
);
5555 static HRESULT WINAPI
UriBuilder_GetSchemeName(IUriBuilder
*iface
, DWORD
*pcchSchemeName
, LPCWSTR
*ppwzSchemeName
)
5557 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5558 TRACE("(%p)->(%p %p)\n", This
, pcchSchemeName
, ppwzSchemeName
);
5560 if(!This
->uri
|| This
->uri
->scheme_start
== -1 || This
->modified_props
& Uri_HAS_SCHEME_NAME
)
5561 return get_builder_component(&This
->scheme
, &This
->scheme_len
, NULL
, 0, ppwzSchemeName
, pcchSchemeName
);
5563 return get_builder_component(&This
->scheme
, &This
->scheme_len
, This
->uri
->canon_uri
+This
->uri
->scheme_start
,
5564 This
->uri
->scheme_len
, ppwzSchemeName
, pcchSchemeName
);
5567 static HRESULT WINAPI
UriBuilder_GetUserName(IUriBuilder
*iface
, DWORD
*pcchUserName
, LPCWSTR
*ppwzUserName
)
5569 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5570 TRACE("(%p)->(%p %p)\n", This
, pcchUserName
, ppwzUserName
);
5572 if(!This
->uri
|| This
->uri
->userinfo_start
== -1 || This
->uri
->userinfo_split
== 0 ||
5573 This
->modified_props
& Uri_HAS_USER_NAME
)
5574 return get_builder_component(&This
->username
, &This
->username_len
, NULL
, 0, ppwzUserName
, pcchUserName
);
5576 const WCHAR
*start
= This
->uri
->canon_uri
+This
->uri
->userinfo_start
;
5578 /* Check if there's a password in the userinfo section. */
5579 if(This
->uri
->userinfo_split
> -1)
5580 /* Don't include the password. */
5581 return get_builder_component(&This
->username
, &This
->username_len
, start
,
5582 This
->uri
->userinfo_split
, ppwzUserName
, pcchUserName
);
5584 return get_builder_component(&This
->username
, &This
->username_len
, start
,
5585 This
->uri
->userinfo_len
, ppwzUserName
, pcchUserName
);
5589 static HRESULT WINAPI
UriBuilder_SetFragment(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5591 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5592 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5593 return set_builder_component(&This
->fragment
, &This
->fragment_len
, pwzNewValue
, '#',
5594 &This
->modified_props
, Uri_HAS_FRAGMENT
);
5597 static HRESULT WINAPI
UriBuilder_SetHost(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5599 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5600 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5602 /* Host name can't be set to NULL. */
5604 return E_INVALIDARG
;
5606 return set_builder_component(&This
->host
, &This
->host_len
, pwzNewValue
, 0,
5607 &This
->modified_props
, Uri_HAS_HOST
);
5610 static HRESULT WINAPI
UriBuilder_SetPassword(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5612 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5613 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5614 return set_builder_component(&This
->password
, &This
->password_len
, pwzNewValue
, 0,
5615 &This
->modified_props
, Uri_HAS_PASSWORD
);
5618 static HRESULT WINAPI
UriBuilder_SetPath(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5620 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5621 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5622 return set_builder_component(&This
->path
, &This
->path_len
, pwzNewValue
, 0,
5623 &This
->modified_props
, Uri_HAS_PATH
);
5626 static HRESULT WINAPI
UriBuilder_SetPort(IUriBuilder
*iface
, BOOL fHasPort
, DWORD dwNewValue
)
5628 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5629 TRACE("(%p)->(%d %d)\n", This
, fHasPort
, dwNewValue
);
5631 This
->has_port
= fHasPort
;
5632 This
->port
= dwNewValue
;
5633 This
->modified_props
|= Uri_HAS_PORT
;
5637 static HRESULT WINAPI
UriBuilder_SetQuery(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5639 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5640 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5641 return set_builder_component(&This
->query
, &This
->query_len
, pwzNewValue
, '?',
5642 &This
->modified_props
, Uri_HAS_QUERY
);
5645 static HRESULT WINAPI
UriBuilder_SetSchemeName(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5647 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5648 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5650 /* Only set the scheme name if it's not NULL or empty. */
5651 if(!pwzNewValue
|| !*pwzNewValue
)
5652 return E_INVALIDARG
;
5654 return set_builder_component(&This
->scheme
, &This
->scheme_len
, pwzNewValue
, 0,
5655 &This
->modified_props
, Uri_HAS_SCHEME_NAME
);
5658 static HRESULT WINAPI
UriBuilder_SetUserName(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5660 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5661 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5662 return set_builder_component(&This
->username
, &This
->username_len
, pwzNewValue
, 0,
5663 &This
->modified_props
, Uri_HAS_USER_NAME
);
5666 static HRESULT WINAPI
UriBuilder_RemoveProperties(IUriBuilder
*iface
, DWORD dwPropertyMask
)
5668 const DWORD accepted_flags
= Uri_HAS_AUTHORITY
|Uri_HAS_DOMAIN
|Uri_HAS_EXTENSION
|Uri_HAS_FRAGMENT
|Uri_HAS_HOST
|
5669 Uri_HAS_PASSWORD
|Uri_HAS_PATH
|Uri_HAS_PATH_AND_QUERY
|Uri_HAS_QUERY
|
5670 Uri_HAS_USER_INFO
|Uri_HAS_USER_NAME
;
5672 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5673 TRACE("(%p)->(0x%08x)\n", This
, dwPropertyMask
);
5675 if(dwPropertyMask
& ~accepted_flags
)
5676 return E_INVALIDARG
;
5678 if(dwPropertyMask
& Uri_HAS_FRAGMENT
)
5679 UriBuilder_SetFragment(iface
, NULL
);
5681 /* Even though you can't set the host name to NULL or an
5682 * empty string, you can still remove it... for some reason.
5684 if(dwPropertyMask
& Uri_HAS_HOST
)
5685 set_builder_component(&This
->host
, &This
->host_len
, NULL
, 0,
5686 &This
->modified_props
, Uri_HAS_HOST
);
5688 if(dwPropertyMask
& Uri_HAS_PASSWORD
)
5689 UriBuilder_SetPassword(iface
, NULL
);
5691 if(dwPropertyMask
& Uri_HAS_PATH
)
5692 UriBuilder_SetPath(iface
, NULL
);
5694 if(dwPropertyMask
& Uri_HAS_PORT
)
5695 UriBuilder_SetPort(iface
, FALSE
, 0);
5697 if(dwPropertyMask
& Uri_HAS_QUERY
)
5698 UriBuilder_SetQuery(iface
, NULL
);
5700 if(dwPropertyMask
& Uri_HAS_USER_NAME
)
5701 UriBuilder_SetUserName(iface
, NULL
);
5706 static HRESULT WINAPI
UriBuilder_HasBeenModified(IUriBuilder
*iface
, BOOL
*pfModified
)
5708 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5709 TRACE("(%p)->(%p)\n", This
, pfModified
);
5714 *pfModified
= This
->modified_props
> 0;
5718 static const IUriBuilderVtbl UriBuilderVtbl
= {
5719 UriBuilder_QueryInterface
,
5722 UriBuilder_CreateUriSimple
,
5723 UriBuilder_CreateUri
,
5724 UriBuilder_CreateUriWithFlags
,
5727 UriBuilder_GetFragment
,
5729 UriBuilder_GetPassword
,
5732 UriBuilder_GetQuery
,
5733 UriBuilder_GetSchemeName
,
5734 UriBuilder_GetUserName
,
5735 UriBuilder_SetFragment
,
5737 UriBuilder_SetPassword
,
5740 UriBuilder_SetQuery
,
5741 UriBuilder_SetSchemeName
,
5742 UriBuilder_SetUserName
,
5743 UriBuilder_RemoveProperties
,
5744 UriBuilder_HasBeenModified
,
5747 /***********************************************************************
5748 * CreateIUriBuilder (urlmon.@)
5750 HRESULT WINAPI
CreateIUriBuilder(IUri
*pIUri
, DWORD dwFlags
, DWORD_PTR dwReserved
, IUriBuilder
**ppIUriBuilder
)
5754 TRACE("(%p %x %x %p)\n", pIUri
, dwFlags
, (DWORD
)dwReserved
, ppIUriBuilder
);
5759 ret
= heap_alloc_zero(sizeof(UriBuilder
));
5761 return E_OUTOFMEMORY
;
5763 ret
->IUriBuilder_iface
.lpVtbl
= &UriBuilderVtbl
;
5769 if((uri
= get_uri_obj(pIUri
))) {
5774 /* Windows doesn't set 'has_port' to TRUE in this case. */
5775 ret
->port
= uri
->port
;
5779 *ppIUriBuilder
= NULL
;
5780 FIXME("(%p %x %x %p): Unknown IUri types not supported yet.\n", pIUri
, dwFlags
,
5781 (DWORD
)dwReserved
, ppIUriBuilder
);
5786 *ppIUriBuilder
= &ret
->IUriBuilder_iface
;
5790 /* Merges the base path with the relative path and stores the resulting path
5791 * and path len in 'result' and 'result_len'.
5793 static HRESULT
merge_paths(parse_data
*data
, const WCHAR
*base
, DWORD base_len
, const WCHAR
*relative
,
5794 DWORD relative_len
, WCHAR
**result
, DWORD
*result_len
, DWORD flags
)
5796 const WCHAR
*end
= NULL
;
5797 DWORD base_copy_len
= 0;
5801 /* Find the characters the will be copied over from
5804 end
= str_last_of(base
, base
+(base_len
-1), '/');
5805 if(!end
&& data
->scheme_type
== URL_SCHEME_FILE
)
5806 /* Try looking for a '\\'. */
5807 end
= str_last_of(base
, base
+(base_len
-1), '\\');
5811 base_copy_len
= (end
+1)-base
;
5812 *result
= heap_alloc((base_copy_len
+relative_len
+1)*sizeof(WCHAR
));
5814 *result
= heap_alloc((relative_len
+1)*sizeof(WCHAR
));
5818 return E_OUTOFMEMORY
;
5823 memcpy(ptr
, base
, base_copy_len
*sizeof(WCHAR
));
5824 ptr
+= base_copy_len
;
5827 memcpy(ptr
, relative
, relative_len
*sizeof(WCHAR
));
5828 ptr
+= relative_len
;
5831 *result_len
= (ptr
-*result
);
5835 static HRESULT
combine_uri(Uri
*base
, Uri
*relative
, DWORD flags
, IUri
**result
, DWORD extras
) {
5839 DWORD create_flags
= 0, len
= 0;
5841 memset(&data
, 0, sizeof(parse_data
));
5843 /* Base case is when the relative Uri has a scheme name,
5844 * if it does, then 'result' will contain the same data
5845 * as the relative Uri.
5847 if(relative
->scheme_start
> -1) {
5848 data
.uri
= SysAllocString(relative
->raw_uri
);
5851 return E_OUTOFMEMORY
;
5854 parse_uri(&data
, 0);
5856 ret
= create_uri_obj();
5859 return E_OUTOFMEMORY
;
5862 if(extras
& COMBINE_URI_FORCE_FLAG_USE
) {
5863 if(flags
& URL_DONT_SIMPLIFY
)
5864 create_flags
|= Uri_CREATE_NO_CANONICALIZE
;
5865 if(flags
& URL_DONT_UNESCAPE_EXTRA_INFO
)
5866 create_flags
|= Uri_CREATE_NO_DECODE_EXTRA_INFO
;
5869 ret
->raw_uri
= data
.uri
;
5870 hr
= canonicalize_uri(&data
, ret
, create_flags
);
5872 IUri_Release(&ret
->IUri_iface
);
5877 apply_default_flags(&create_flags
);
5878 ret
->create_flags
= create_flags
;
5880 *result
= &ret
->IUri_iface
;
5883 DWORD raw_flags
= 0;
5885 if(base
->scheme_start
> -1) {
5886 data
.scheme
= base
->canon_uri
+base
->scheme_start
;
5887 data
.scheme_len
= base
->scheme_len
;
5888 data
.scheme_type
= base
->scheme_type
;
5890 data
.is_relative
= TRUE
;
5891 data
.scheme_type
= URL_SCHEME_UNKNOWN
;
5892 create_flags
|= Uri_CREATE_ALLOW_RELATIVE
;
5895 if(base
->authority_start
> -1) {
5896 if(base
->userinfo_start
> -1 && base
->userinfo_split
!= 0) {
5897 data
.username
= base
->canon_uri
+base
->userinfo_start
;
5898 data
.username_len
= (base
->userinfo_split
> -1) ? base
->userinfo_split
: base
->userinfo_len
;
5901 if(base
->userinfo_split
> -1) {
5902 data
.password
= base
->canon_uri
+base
->userinfo_start
+base
->userinfo_split
+1;
5903 data
.password_len
= base
->userinfo_len
-base
->userinfo_split
-1;
5906 if(base
->host_start
> -1) {
5907 data
.host
= base
->canon_uri
+base
->host_start
;
5908 data
.host_len
= base
->host_len
;
5909 data
.host_type
= base
->host_type
;
5912 if(base
->has_port
) {
5913 data
.has_port
= TRUE
;
5914 data
.port_value
= base
->port
;
5916 } else if(base
->scheme_type
!= URL_SCHEME_FILE
)
5917 data
.is_opaque
= TRUE
;
5919 if(relative
->path_start
== -1 || !relative
->path_len
) {
5920 if(base
->path_start
> -1) {
5921 data
.path
= base
->canon_uri
+base
->path_start
;
5922 data
.path_len
= base
->path_len
;
5923 } else if((base
->path_start
== -1 || !base
->path_len
) && !data
.is_opaque
) {
5924 /* Just set the path as a '/' if the base didn't have
5925 * one and if it's an hierarchical URI.
5927 static const WCHAR slashW
[] = {'/',0};
5932 if(relative
->query_start
> -1) {
5933 data
.query
= relative
->canon_uri
+relative
->query_start
;
5934 data
.query_len
= relative
->query_len
;
5935 } else if(base
->query_start
> -1) {
5936 data
.query
= base
->canon_uri
+base
->query_start
;
5937 data
.query_len
= base
->query_len
;
5940 const WCHAR
*ptr
, **pptr
;
5941 DWORD path_offset
= 0, path_len
= 0;
5943 /* There's two possibilities on what will happen to the path component
5944 * of the result IUri. First, if the relative path begins with a '/'
5945 * then the resulting path will just be the relative path. Second, if
5946 * relative path doesn't begin with a '/' then the base path and relative
5947 * path are merged together.
5949 if(relative
->path_len
&& *(relative
->canon_uri
+relative
->path_start
) == '/') {
5951 BOOL copy_drive_path
= FALSE
;
5953 /* If the relative IUri's path starts with a '/', then we
5954 * don't use the base IUri's path. Unless the base IUri
5955 * is a file URI, in which case it uses the drive path of
5956 * the base IUri (if it has any) in the new path.
5958 if(base
->scheme_type
== URL_SCHEME_FILE
) {
5959 if(base
->path_len
> 3 && *(base
->canon_uri
+base
->path_start
) == '/' &&
5960 is_drive_path(base
->canon_uri
+base
->path_start
+1)) {
5962 copy_drive_path
= TRUE
;
5966 path_len
+= relative
->path_len
;
5968 path
= heap_alloc((path_len
+1)*sizeof(WCHAR
));
5971 return E_OUTOFMEMORY
;
5976 /* Copy the base paths, drive path over. */
5977 if(copy_drive_path
) {
5978 memcpy(tmp
, base
->canon_uri
+base
->path_start
, 3*sizeof(WCHAR
));
5982 memcpy(tmp
, relative
->canon_uri
+relative
->path_start
, relative
->path_len
*sizeof(WCHAR
));
5983 path
[path_len
] = '\0';
5985 /* Merge the base path with the relative path. */
5986 hr
= merge_paths(&data
, base
->canon_uri
+base
->path_start
, base
->path_len
,
5987 relative
->canon_uri
+relative
->path_start
, relative
->path_len
,
5988 &path
, &path_len
, flags
);
5994 /* If the resulting IUri is a file URI, the drive path isn't
5995 * reduced out when the dot segments are removed.
5997 if(path_len
>= 3 && data
.scheme_type
== URL_SCHEME_FILE
&& !data
.host
) {
5998 if(*path
== '/' && is_drive_path(path
+1))
6000 else if(is_drive_path(path
))
6005 /* Check if the dot segments need to be removed from the path. */
6006 if(!(flags
& URL_DONT_SIMPLIFY
) && !data
.is_opaque
) {
6007 DWORD offset
= (path_offset
> 0) ? path_offset
+1 : 0;
6008 DWORD new_len
= remove_dot_segments(path
+offset
,path_len
-offset
);
6010 if(new_len
!= path_len
) {
6011 WCHAR
*tmp
= heap_realloc(path
, (offset
+new_len
+1)*sizeof(WCHAR
));
6015 return E_OUTOFMEMORY
;
6018 tmp
[new_len
+offset
] = '\0';
6020 path_len
= new_len
+offset
;
6024 /* Make sure the path component is valid. */
6027 if((data
.is_opaque
&& !parse_path_opaque(pptr
, &data
, 0)) ||
6028 (!data
.is_opaque
&& !parse_path_hierarchical(pptr
, &data
, 0))) {
6031 return E_INVALIDARG
;
6035 if(relative
->fragment_start
> -1) {
6036 data
.fragment
= relative
->canon_uri
+relative
->fragment_start
;
6037 data
.fragment_len
= relative
->fragment_len
;
6040 if(flags
& URL_DONT_SIMPLIFY
)
6041 raw_flags
|= RAW_URI_FORCE_PORT_DISP
;
6042 if(flags
& URL_FILE_USE_PATHURL
)
6043 raw_flags
|= RAW_URI_CONVERT_TO_DOS_PATH
;
6045 len
= generate_raw_uri(&data
, data
.uri
, raw_flags
);
6046 data
.uri
= SysAllocStringLen(NULL
, len
);
6050 return E_OUTOFMEMORY
;
6053 generate_raw_uri(&data
, data
.uri
, raw_flags
);
6055 ret
= create_uri_obj();
6057 SysFreeString(data
.uri
);
6060 return E_OUTOFMEMORY
;
6063 if(flags
& URL_DONT_SIMPLIFY
)
6064 create_flags
|= Uri_CREATE_NO_CANONICALIZE
;
6065 if(flags
& URL_FILE_USE_PATHURL
)
6066 create_flags
|= Uri_CREATE_FILE_USE_DOS_PATH
;
6068 ret
->raw_uri
= data
.uri
;
6069 hr
= canonicalize_uri(&data
, ret
, create_flags
);
6071 IUri_Release(&ret
->IUri_iface
);
6076 if(flags
& URL_DONT_SIMPLIFY
)
6077 ret
->display_modifiers
|= URI_DISPLAY_NO_DEFAULT_PORT_AUTH
;
6079 apply_default_flags(&create_flags
);
6080 ret
->create_flags
= create_flags
;
6081 *result
= &ret
->IUri_iface
;
6089 /***********************************************************************
6090 * CoInternetCombineIUri (urlmon.@)
6092 HRESULT WINAPI
CoInternetCombineIUri(IUri
*pBaseUri
, IUri
*pRelativeUri
, DWORD dwCombineFlags
,
6093 IUri
**ppCombinedUri
, DWORD_PTR dwReserved
)
6096 IInternetProtocolInfo
*info
;
6097 Uri
*relative
, *base
;
6098 TRACE("(%p %p %x %p %x)\n", pBaseUri
, pRelativeUri
, dwCombineFlags
, ppCombinedUri
, (DWORD
)dwReserved
);
6101 return E_INVALIDARG
;
6103 if(!pBaseUri
|| !pRelativeUri
) {
6104 *ppCombinedUri
= NULL
;
6105 return E_INVALIDARG
;
6108 relative
= get_uri_obj(pRelativeUri
);
6109 base
= get_uri_obj(pBaseUri
);
6110 if(!relative
|| !base
) {
6111 *ppCombinedUri
= NULL
;
6112 FIXME("(%p %p %x %p %x) Unknown IUri types not supported yet.\n",
6113 pBaseUri
, pRelativeUri
, dwCombineFlags
, ppCombinedUri
, (DWORD
)dwReserved
);
6117 info
= get_protocol_info(base
->canon_uri
);
6119 WCHAR result
[INTERNET_MAX_URL_LENGTH
+1];
6120 DWORD result_len
= 0;
6122 hr
= IInternetProtocolInfo_CombineUrl(info
, base
->canon_uri
, relative
->canon_uri
, dwCombineFlags
,
6123 result
, INTERNET_MAX_URL_LENGTH
+1, &result_len
, 0);
6124 IInternetProtocolInfo_Release(info
);
6126 hr
= CreateUri(result
, Uri_CREATE_ALLOW_RELATIVE
, 0, ppCombinedUri
);
6132 return combine_uri(base
, relative
, dwCombineFlags
, ppCombinedUri
, 0);
6135 /***********************************************************************
6136 * CoInternetCombineUrlEx (urlmon.@)
6138 HRESULT WINAPI
CoInternetCombineUrlEx(IUri
*pBaseUri
, LPCWSTR pwzRelativeUrl
, DWORD dwCombineFlags
,
6139 IUri
**ppCombinedUri
, DWORD_PTR dwReserved
)
6144 IInternetProtocolInfo
*info
;
6146 TRACE("(%p %s %x %p %x) stub\n", pBaseUri
, debugstr_w(pwzRelativeUrl
), dwCombineFlags
,
6147 ppCombinedUri
, (DWORD
)dwReserved
);
6152 if(!pwzRelativeUrl
) {
6153 *ppCombinedUri
= NULL
;
6154 return E_UNEXPECTED
;
6158 *ppCombinedUri
= NULL
;
6159 return E_INVALIDARG
;
6162 base
= get_uri_obj(pBaseUri
);
6164 *ppCombinedUri
= NULL
;
6165 FIXME("(%p %s %x %p %x) Unknown IUri's not supported yet.\n", pBaseUri
, debugstr_w(pwzRelativeUrl
),
6166 dwCombineFlags
, ppCombinedUri
, (DWORD
)dwReserved
);
6170 info
= get_protocol_info(base
->canon_uri
);
6172 WCHAR result
[INTERNET_MAX_URL_LENGTH
+1];
6173 DWORD result_len
= 0;
6175 hr
= IInternetProtocolInfo_CombineUrl(info
, base
->canon_uri
, pwzRelativeUrl
, dwCombineFlags
,
6176 result
, INTERNET_MAX_URL_LENGTH
+1, &result_len
, 0);
6177 IInternetProtocolInfo_Release(info
);
6179 hr
= CreateUri(result
, Uri_CREATE_ALLOW_RELATIVE
, 0, ppCombinedUri
);
6185 hr
= CreateUri(pwzRelativeUrl
, Uri_CREATE_ALLOW_RELATIVE
, 0, &relative
);
6187 *ppCombinedUri
= NULL
;
6191 hr
= combine_uri(base
, get_uri_obj(relative
), dwCombineFlags
, ppCombinedUri
, COMBINE_URI_FORCE_FLAG_USE
);
6193 IUri_Release(relative
);
6197 static HRESULT
parse_canonicalize(const Uri
*uri
, DWORD flags
, LPWSTR output
,
6198 DWORD output_len
, DWORD
*result_len
)
6200 const WCHAR
*ptr
= NULL
;
6203 WCHAR buffer
[INTERNET_MAX_URL_LENGTH
+1];
6207 /* URL_UNESCAPE only has effect if none of the URL_ESCAPE flags are set. */
6208 const BOOL allow_unescape
= !(flags
& URL_ESCAPE_UNSAFE
) &&
6209 !(flags
& URL_ESCAPE_SPACES_ONLY
) &&
6210 !(flags
& URL_ESCAPE_PERCENT
);
6213 /* Check if the dot segments need to be removed from the
6216 if(uri
->scheme_start
> -1 && uri
->path_start
> -1) {
6217 ptr
= uri
->canon_uri
+uri
->scheme_start
+uri
->scheme_len
+1;
6220 reduce_path
= !(flags
& URL_NO_META
) &&
6221 !(flags
& URL_DONT_SIMPLIFY
) &&
6222 ptr
&& check_hierarchical(pptr
);
6224 for(ptr
= uri
->canon_uri
; ptr
< uri
->canon_uri
+uri
->canon_len
; ++ptr
) {
6225 BOOL do_default_action
= TRUE
;
6227 /* Keep track of the path if we need to remove dot segments from
6230 if(reduce_path
&& !path
&& ptr
== uri
->canon_uri
+uri
->path_start
)
6233 /* Check if it's time to reduce the path. */
6234 if(reduce_path
&& ptr
== uri
->canon_uri
+uri
->path_start
+uri
->path_len
) {
6235 DWORD current_path_len
= (buffer
+len
) - path
;
6236 DWORD new_path_len
= remove_dot_segments(path
, current_path_len
);
6238 /* Update the current length. */
6239 len
-= (current_path_len
-new_path_len
);
6240 reduce_path
= FALSE
;
6244 const WCHAR decoded
= decode_pct_val(ptr
);
6246 if(allow_unescape
&& (flags
& URL_UNESCAPE
)) {
6247 buffer
[len
++] = decoded
;
6249 do_default_action
= FALSE
;
6253 /* See if %'s needed to encoded. */
6254 if(do_default_action
&& (flags
& URL_ESCAPE_PERCENT
)) {
6255 pct_encode_val(*ptr
, buffer
+len
);
6257 do_default_action
= FALSE
;
6259 } else if(*ptr
== ' ') {
6260 if((flags
& URL_ESCAPE_SPACES_ONLY
) &&
6261 !(flags
& URL_ESCAPE_UNSAFE
)) {
6262 pct_encode_val(*ptr
, buffer
+len
);
6264 do_default_action
= FALSE
;
6266 } else if(!is_reserved(*ptr
) && !is_unreserved(*ptr
)) {
6267 if(flags
& URL_ESCAPE_UNSAFE
) {
6268 pct_encode_val(*ptr
, buffer
+len
);
6270 do_default_action
= FALSE
;
6274 if(do_default_action
)
6275 buffer
[len
++] = *ptr
;
6278 /* Sometimes the path is the very last component of the IUri, so
6279 * see if the dot segments need to be reduced now.
6281 if(reduce_path
&& path
) {
6282 DWORD current_path_len
= (buffer
+len
) - path
;
6283 DWORD new_path_len
= remove_dot_segments(path
, current_path_len
);
6285 /* Update the current length. */
6286 len
-= (current_path_len
-new_path_len
);
6291 /* The null terminator isn't included the length. */
6292 *result_len
= len
-1;
6293 if(len
> output_len
)
6294 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6296 memcpy(output
, buffer
, len
*sizeof(WCHAR
));
6301 static HRESULT
parse_friendly(IUri
*uri
, LPWSTR output
, DWORD output_len
,
6308 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_DISPLAY_URI
, &display_len
, 0);
6314 *result_len
= display_len
;
6315 if(display_len
+1 > output_len
)
6316 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6318 hr
= IUri_GetDisplayUri(uri
, &display
);
6324 memcpy(output
, display
, (display_len
+1)*sizeof(WCHAR
));
6325 SysFreeString(display
);
6329 static HRESULT
parse_rootdocument(const Uri
*uri
, LPWSTR output
, DWORD output_len
,
6332 static const WCHAR colon_slashesW
[] = {':','/','/'};
6337 /* Windows only returns the root document if the URI has an authority
6338 * and it's not an unknown scheme type or a file scheme type.
6340 if(uri
->authority_start
== -1 ||
6341 uri
->scheme_type
== URL_SCHEME_UNKNOWN
||
6342 uri
->scheme_type
== URL_SCHEME_FILE
) {
6345 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6351 len
= uri
->scheme_len
+uri
->authority_len
;
6352 /* For the "://" and '/' which will be added. */
6355 if(len
+1 > output_len
) {
6357 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6361 memcpy(ptr
, uri
->canon_uri
+uri
->scheme_start
, uri
->scheme_len
*sizeof(WCHAR
));
6363 /* Add the "://". */
6364 ptr
+= uri
->scheme_len
;
6365 memcpy(ptr
, colon_slashesW
, sizeof(colon_slashesW
));
6367 /* Add the authority. */
6368 ptr
+= sizeof(colon_slashesW
)/sizeof(WCHAR
);
6369 memcpy(ptr
, uri
->canon_uri
+uri
->authority_start
, uri
->authority_len
*sizeof(WCHAR
));
6371 /* Add the '/' after the authority. */
6372 ptr
+= uri
->authority_len
;
6380 static HRESULT
parse_document(const Uri
*uri
, LPWSTR output
, DWORD output_len
,
6385 /* It has to be a known scheme type, but, it can't be a file
6386 * scheme. It also has to hierarchical.
6388 if(uri
->scheme_type
== URL_SCHEME_UNKNOWN
||
6389 uri
->scheme_type
== URL_SCHEME_FILE
||
6390 uri
->authority_start
== -1) {
6393 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6399 if(uri
->fragment_start
> -1)
6400 len
= uri
->fragment_start
;
6402 len
= uri
->canon_len
;
6405 if(len
+1 > output_len
)
6406 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6408 memcpy(output
, uri
->canon_uri
, len
*sizeof(WCHAR
));
6413 static HRESULT
parse_path_from_url(const Uri
*uri
, LPWSTR output
, DWORD output_len
,
6416 const WCHAR
*path_ptr
;
6417 WCHAR buffer
[INTERNET_MAX_URL_LENGTH
+1];
6420 if(uri
->scheme_type
!= URL_SCHEME_FILE
) {
6424 return E_INVALIDARG
;
6428 if(uri
->host_start
> -1) {
6429 static const WCHAR slash_slashW
[] = {'\\','\\'};
6431 memcpy(ptr
, slash_slashW
, sizeof(slash_slashW
));
6432 ptr
+= sizeof(slash_slashW
)/sizeof(WCHAR
);
6433 memcpy(ptr
, uri
->canon_uri
+uri
->host_start
, uri
->host_len
*sizeof(WCHAR
));
6434 ptr
+= uri
->host_len
;
6437 path_ptr
= uri
->canon_uri
+uri
->path_start
;
6438 if(uri
->path_len
> 3 && *path_ptr
== '/' && is_drive_path(path_ptr
+1))
6439 /* Skip past the '/' in front of the drive path. */
6442 for(; path_ptr
< uri
->canon_uri
+uri
->path_start
+uri
->path_len
; ++path_ptr
, ++ptr
) {
6443 BOOL do_default_action
= TRUE
;
6445 if(*path_ptr
== '%') {
6446 const WCHAR decoded
= decode_pct_val(path_ptr
);
6450 do_default_action
= FALSE
;
6452 } else if(*path_ptr
== '/') {
6454 do_default_action
= FALSE
;
6457 if(do_default_action
)
6463 *result_len
= ptr
-buffer
;
6464 if(*result_len
+1 > output_len
)
6465 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6467 memcpy(output
, buffer
, (*result_len
+1)*sizeof(WCHAR
));
6471 static HRESULT
parse_url_from_path(IUri
*uri
, LPWSTR output
, DWORD output_len
,
6478 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_ABSOLUTE_URI
, &len
, 0);
6485 if(len
+1 > output_len
)
6486 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6488 hr
= IUri_GetAbsoluteUri(uri
, &received
);
6494 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6495 SysFreeString(received
);
6500 static HRESULT
parse_schema(IUri
*uri
, LPWSTR output
, DWORD output_len
,
6507 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_SCHEME_NAME
, &len
, 0);
6514 if(len
+1 > output_len
)
6515 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6517 hr
= IUri_GetSchemeName(uri
, &received
);
6523 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6524 SysFreeString(received
);
6529 static HRESULT
parse_site(IUri
*uri
, LPWSTR output
, DWORD output_len
, DWORD
*result_len
)
6535 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_HOST
, &len
, 0);
6542 if(len
+1 > output_len
)
6543 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6545 hr
= IUri_GetHost(uri
, &received
);
6551 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6552 SysFreeString(received
);
6557 static HRESULT
parse_domain(IUri
*uri
, LPWSTR output
, DWORD output_len
, DWORD
*result_len
)
6563 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_DOMAIN
, &len
, 0);
6570 if(len
+1 > output_len
)
6571 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6573 hr
= IUri_GetDomain(uri
, &received
);
6579 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6580 SysFreeString(received
);
6585 static HRESULT
parse_anchor(IUri
*uri
, LPWSTR output
, DWORD output_len
, DWORD
*result_len
)
6591 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_FRAGMENT
, &len
, 0);
6598 if(len
+1 > output_len
)
6599 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6601 hr
= IUri_GetFragment(uri
, &received
);
6607 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6608 SysFreeString(received
);
6613 /***********************************************************************
6614 * CoInternetParseIUri (urlmon.@)
6616 HRESULT WINAPI
CoInternetParseIUri(IUri
*pIUri
, PARSEACTION ParseAction
, DWORD dwFlags
,
6617 LPWSTR pwzResult
, DWORD cchResult
, DWORD
*pcchResult
,
6618 DWORD_PTR dwReserved
)
6622 IInternetProtocolInfo
*info
;
6624 TRACE("(%p %d %x %p %d %p %x)\n", pIUri
, ParseAction
, dwFlags
, pwzResult
,
6625 cchResult
, pcchResult
, (DWORD
)dwReserved
);
6630 if(!pwzResult
|| !pIUri
) {
6632 return E_INVALIDARG
;
6635 if(!(uri
= get_uri_obj(pIUri
))) {
6637 FIXME("(%p %d %x %p %d %p %x) Unknown IUri's not supported for this action.\n",
6638 pIUri
, ParseAction
, dwFlags
, pwzResult
, cchResult
, pcchResult
, (DWORD
)dwReserved
);
6642 info
= get_protocol_info(uri
->canon_uri
);
6644 hr
= IInternetProtocolInfo_ParseUrl(info
, uri
->canon_uri
, ParseAction
, dwFlags
,
6645 pwzResult
, cchResult
, pcchResult
, 0);
6646 IInternetProtocolInfo_Release(info
);
6647 if(SUCCEEDED(hr
)) return hr
;
6650 switch(ParseAction
) {
6651 case PARSE_CANONICALIZE
:
6652 hr
= parse_canonicalize(uri
, dwFlags
, pwzResult
, cchResult
, pcchResult
);
6654 case PARSE_FRIENDLY
:
6655 hr
= parse_friendly(pIUri
, pwzResult
, cchResult
, pcchResult
);
6657 case PARSE_ROOTDOCUMENT
:
6658 hr
= parse_rootdocument(uri
, pwzResult
, cchResult
, pcchResult
);
6660 case PARSE_DOCUMENT
:
6661 hr
= parse_document(uri
, pwzResult
, cchResult
, pcchResult
);
6663 case PARSE_PATH_FROM_URL
:
6664 hr
= parse_path_from_url(uri
, pwzResult
, cchResult
, pcchResult
);
6666 case PARSE_URL_FROM_PATH
:
6667 hr
= parse_url_from_path(pIUri
, pwzResult
, cchResult
, pcchResult
);
6670 hr
= parse_schema(pIUri
, pwzResult
, cchResult
, pcchResult
);
6673 hr
= parse_site(pIUri
, pwzResult
, cchResult
, pcchResult
);
6676 hr
= parse_domain(pIUri
, pwzResult
, cchResult
, pcchResult
);
6678 case PARSE_LOCATION
:
6680 hr
= parse_anchor(pIUri
, pwzResult
, cchResult
, pcchResult
);
6682 case PARSE_SECURITY_URL
:
6685 case PARSE_SECURITY_DOMAIN
:
6692 FIXME("(%p %d %x %p %d %p %x) Partial stub.\n", pIUri
, ParseAction
, dwFlags
,
6693 pwzResult
, cchResult
, pcchResult
, (DWORD
)dwReserved
);