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
;
162 URL_SCHEME scheme_type
;
164 const WCHAR
*username
;
167 const WCHAR
*password
;
172 Uri_HOST_TYPE host_type
;
175 ipv6_address ipv6_address
;
188 const WCHAR
*fragment
;
192 static const CHAR hexDigits
[] = "0123456789ABCDEF";
194 /* List of scheme types/scheme names that are recognized by the IUri interface as of IE 7. */
195 static const struct {
197 WCHAR scheme_name
[16];
198 } recognized_schemes
[] = {
199 {URL_SCHEME_FTP
, {'f','t','p',0}},
200 {URL_SCHEME_HTTP
, {'h','t','t','p',0}},
201 {URL_SCHEME_GOPHER
, {'g','o','p','h','e','r',0}},
202 {URL_SCHEME_MAILTO
, {'m','a','i','l','t','o',0}},
203 {URL_SCHEME_NEWS
, {'n','e','w','s',0}},
204 {URL_SCHEME_NNTP
, {'n','n','t','p',0}},
205 {URL_SCHEME_TELNET
, {'t','e','l','n','e','t',0}},
206 {URL_SCHEME_WAIS
, {'w','a','i','s',0}},
207 {URL_SCHEME_FILE
, {'f','i','l','e',0}},
208 {URL_SCHEME_MK
, {'m','k',0}},
209 {URL_SCHEME_HTTPS
, {'h','t','t','p','s',0}},
210 {URL_SCHEME_SHELL
, {'s','h','e','l','l',0}},
211 {URL_SCHEME_SNEWS
, {'s','n','e','w','s',0}},
212 {URL_SCHEME_LOCAL
, {'l','o','c','a','l',0}},
213 {URL_SCHEME_JAVASCRIPT
, {'j','a','v','a','s','c','r','i','p','t',0}},
214 {URL_SCHEME_VBSCRIPT
, {'v','b','s','c','r','i','p','t',0}},
215 {URL_SCHEME_ABOUT
, {'a','b','o','u','t',0}},
216 {URL_SCHEME_RES
, {'r','e','s',0}},
217 {URL_SCHEME_MSSHELLROOTED
, {'m','s','-','s','h','e','l','l','-','r','o','o','t','e','d',0}},
218 {URL_SCHEME_MSSHELLIDLIST
, {'m','s','-','s','h','e','l','l','-','i','d','l','i','s','t',0}},
219 {URL_SCHEME_MSHELP
, {'h','c','p',0}},
220 {URL_SCHEME_WILDCARD
, {'*',0}}
223 /* List of default ports Windows recognizes. */
224 static const struct {
227 } default_ports
[] = {
228 {URL_SCHEME_FTP
, 21},
229 {URL_SCHEME_HTTP
, 80},
230 {URL_SCHEME_GOPHER
, 70},
231 {URL_SCHEME_NNTP
, 119},
232 {URL_SCHEME_TELNET
, 23},
233 {URL_SCHEME_WAIS
, 210},
234 {URL_SCHEME_HTTPS
, 443},
237 /* List of 3-character top level domain names Windows seems to recognize.
238 * There might be more, but, these are the only ones I've found so far.
240 static const struct {
242 } recognized_tlds
[] = {
252 static Uri
*get_uri_obj(IUri
*uri
)
257 hres
= IUri_QueryInterface(uri
, &IID_IUriObj
, (void**)&ret
);
258 return SUCCEEDED(hres
) ? ret
: NULL
;
261 static inline BOOL
is_alpha(WCHAR val
) {
262 return ((val
>= 'a' && val
<= 'z') || (val
>= 'A' && val
<= 'Z'));
265 static inline BOOL
is_num(WCHAR val
) {
266 return (val
>= '0' && val
<= '9');
269 static inline BOOL
is_drive_path(const WCHAR
*str
) {
270 return (is_alpha(str
[0]) && (str
[1] == ':' || str
[1] == '|'));
273 static inline BOOL
is_unc_path(const WCHAR
*str
) {
274 return (str
[0] == '\\' && str
[0] == '\\');
277 static inline BOOL
is_forbidden_dos_path_char(WCHAR val
) {
278 return (val
== '>' || val
== '<' || val
== '\"');
281 /* A URI is implicitly a file path if it begins with
282 * a drive letter (e.g. X:) or starts with "\\" (UNC path).
284 static inline BOOL
is_implicit_file_path(const WCHAR
*str
) {
285 return (is_unc_path(str
) || (is_alpha(str
[0]) && str
[1] == ':'));
288 /* Checks if the URI is a hierarchical URI. A hierarchical
289 * URI is one that has "//" after the scheme.
291 static BOOL
check_hierarchical(const WCHAR
**ptr
) {
292 const WCHAR
*start
= *ptr
;
307 /* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" */
308 static inline BOOL
is_unreserved(WCHAR val
) {
309 return (is_alpha(val
) || is_num(val
) || val
== '-' || val
== '.' ||
310 val
== '_' || val
== '~');
313 /* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
314 * / "*" / "+" / "," / ";" / "="
316 static inline BOOL
is_subdelim(WCHAR val
) {
317 return (val
== '!' || val
== '$' || val
== '&' ||
318 val
== '\'' || val
== '(' || val
== ')' ||
319 val
== '*' || val
== '+' || val
== ',' ||
320 val
== ';' || val
== '=');
323 /* gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" */
324 static inline BOOL
is_gendelim(WCHAR val
) {
325 return (val
== ':' || val
== '/' || val
== '?' ||
326 val
== '#' || val
== '[' || val
== ']' ||
330 /* Characters that delimit the end of the authority
331 * section of a URI. Sometimes a '\\' is considered
332 * an authority delimiter.
334 static inline BOOL
is_auth_delim(WCHAR val
, BOOL acceptSlash
) {
335 return (val
== '#' || val
== '/' || val
== '?' ||
336 val
== '\0' || (acceptSlash
&& val
== '\\'));
339 /* reserved = gen-delims / sub-delims */
340 static inline BOOL
is_reserved(WCHAR val
) {
341 return (is_subdelim(val
) || is_gendelim(val
));
344 static inline BOOL
is_hexdigit(WCHAR val
) {
345 return ((val
>= 'a' && val
<= 'f') ||
346 (val
>= 'A' && val
<= 'F') ||
347 (val
>= '0' && val
<= '9'));
350 static inline BOOL
is_path_delim(WCHAR val
) {
351 return (!val
|| val
== '#' || val
== '?');
354 static inline BOOL
is_slash(WCHAR c
)
356 return c
== '/' || c
== '\\';
359 static BOOL
is_default_port(URL_SCHEME scheme
, DWORD port
) {
362 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
363 if(default_ports
[i
].scheme
== scheme
&& default_ports
[i
].port
)
370 /* List of schemes types Windows seems to expect to be hierarchical. */
371 static inline BOOL
is_hierarchical_scheme(URL_SCHEME type
) {
372 return(type
== URL_SCHEME_HTTP
|| type
== URL_SCHEME_FTP
||
373 type
== URL_SCHEME_GOPHER
|| type
== URL_SCHEME_NNTP
||
374 type
== URL_SCHEME_TELNET
|| type
== URL_SCHEME_WAIS
||
375 type
== URL_SCHEME_FILE
|| type
== URL_SCHEME_HTTPS
||
376 type
== URL_SCHEME_RES
);
379 /* Checks if 'flags' contains an invalid combination of Uri_CREATE flags. */
380 static inline BOOL
has_invalid_flag_combination(DWORD flags
) {
381 return((flags
& Uri_CREATE_DECODE_EXTRA_INFO
&& flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
) ||
382 (flags
& Uri_CREATE_CANONICALIZE
&& flags
& Uri_CREATE_NO_CANONICALIZE
) ||
383 (flags
& Uri_CREATE_CRACK_UNKNOWN_SCHEMES
&& flags
& Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
) ||
384 (flags
& Uri_CREATE_PRE_PROCESS_HTML_URI
&& flags
& Uri_CREATE_NO_PRE_PROCESS_HTML_URI
) ||
385 (flags
& Uri_CREATE_IE_SETTINGS
&& flags
& Uri_CREATE_NO_IE_SETTINGS
));
388 /* Applies each default Uri_CREATE flags to 'flags' if it
389 * doesn't cause a flag conflict.
391 static void apply_default_flags(DWORD
*flags
) {
392 if(!(*flags
& Uri_CREATE_NO_CANONICALIZE
))
393 *flags
|= Uri_CREATE_CANONICALIZE
;
394 if(!(*flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
))
395 *flags
|= Uri_CREATE_DECODE_EXTRA_INFO
;
396 if(!(*flags
& Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
))
397 *flags
|= Uri_CREATE_CRACK_UNKNOWN_SCHEMES
;
398 if(!(*flags
& Uri_CREATE_NO_PRE_PROCESS_HTML_URI
))
399 *flags
|= Uri_CREATE_PRE_PROCESS_HTML_URI
;
400 if(!(*flags
& Uri_CREATE_IE_SETTINGS
))
401 *flags
|= Uri_CREATE_NO_IE_SETTINGS
;
404 /* Determines if the URI is hierarchical using the information already parsed into
405 * data and using the current location of parsing in the URI string.
407 * Windows considers a URI hierarchical if one of the following is true:
408 * A.) It's a wildcard scheme.
409 * B.) It's an implicit file scheme.
410 * C.) It's a known hierarchical scheme and it has two '\\' after the scheme name.
411 * (the '\\' will be converted into "//" during canonicalization).
412 * D.) It's not a relative URI and "//" appears after the scheme name.
414 static inline BOOL
is_hierarchical_uri(const WCHAR
**ptr
, const parse_data
*data
) {
415 const WCHAR
*start
= *ptr
;
417 if(data
->scheme_type
== URL_SCHEME_WILDCARD
)
419 else if(data
->scheme_type
== URL_SCHEME_FILE
&& data
->has_implicit_scheme
)
421 else if(is_hierarchical_scheme(data
->scheme_type
) && (*ptr
)[0] == '\\' && (*ptr
)[1] == '\\') {
424 } else if(!data
->is_relative
&& check_hierarchical(ptr
))
431 /* Checks if the two Uri's are logically equivalent. It's a simple
432 * comparison, since they are both of type Uri, and it can access
433 * the properties of each Uri directly without the need to go
434 * through the "IUri_Get*" interface calls.
436 static BOOL
are_equal_simple(const Uri
*a
, const Uri
*b
) {
437 if(a
->scheme_type
== b
->scheme_type
) {
438 const BOOL known_scheme
= a
->scheme_type
!= URL_SCHEME_UNKNOWN
;
439 const BOOL are_hierarchical
=
440 (a
->authority_start
> -1 && b
->authority_start
> -1);
442 if(a
->scheme_type
== URL_SCHEME_FILE
) {
443 if(a
->canon_len
== b
->canon_len
)
444 return !StrCmpIW(a
->canon_uri
, b
->canon_uri
);
447 /* Only compare the scheme names (if any) if their unknown scheme types. */
449 if((a
->scheme_start
> -1 && b
->scheme_start
> -1) &&
450 (a
->scheme_len
== b
->scheme_len
)) {
451 /* Make sure the schemes are the same. */
452 if(StrCmpNW(a
->canon_uri
+a
->scheme_start
, b
->canon_uri
+b
->scheme_start
, a
->scheme_len
))
454 } else if(a
->scheme_len
!= b
->scheme_len
)
455 /* One of the Uri's has a scheme name, while the other doesn't. */
459 /* If they have a userinfo component, perform case sensitive compare. */
460 if((a
->userinfo_start
> -1 && b
->userinfo_start
> -1) &&
461 (a
->userinfo_len
== b
->userinfo_len
)) {
462 if(StrCmpNW(a
->canon_uri
+a
->userinfo_start
, b
->canon_uri
+b
->userinfo_start
, a
->userinfo_len
))
464 } else if(a
->userinfo_len
!= b
->userinfo_len
)
465 /* One of the Uri's had a userinfo, while the other one doesn't. */
468 /* Check if they have a host name. */
469 if((a
->host_start
> -1 && b
->host_start
> -1) &&
470 (a
->host_len
== b
->host_len
)) {
471 /* Perform a case insensitive compare if they are a known scheme type. */
473 if(StrCmpNIW(a
->canon_uri
+a
->host_start
, b
->canon_uri
+b
->host_start
, a
->host_len
))
475 } else if(StrCmpNW(a
->canon_uri
+a
->host_start
, b
->canon_uri
+b
->host_start
, a
->host_len
))
477 } else if(a
->host_len
!= b
->host_len
)
478 /* One of the Uri's had a host, while the other one didn't. */
481 if(a
->has_port
&& b
->has_port
) {
482 if(a
->port
!= b
->port
)
484 } else if(a
->has_port
|| b
->has_port
)
485 /* One had a port, while the other one didn't. */
488 /* Windows is weird with how it handles paths. For example
489 * One URI could be "http://google.com" (after canonicalization)
490 * and one could be "http://google.com/" and the IsEqual function
491 * would still evaluate to TRUE, but, only if they are both hierarchical
494 if((a
->path_start
> -1 && b
->path_start
> -1) &&
495 (a
->path_len
== b
->path_len
)) {
496 if(StrCmpNW(a
->canon_uri
+a
->path_start
, b
->canon_uri
+b
->path_start
, a
->path_len
))
498 } else if(are_hierarchical
&& a
->path_len
== -1 && b
->path_len
== 0) {
499 if(*(a
->canon_uri
+a
->path_start
) != '/')
501 } else if(are_hierarchical
&& b
->path_len
== 1 && a
->path_len
== 0) {
502 if(*(b
->canon_uri
+b
->path_start
) != '/')
504 } else if(a
->path_len
!= b
->path_len
)
507 /* Compare the query strings of the two URIs. */
508 if((a
->query_start
> -1 && b
->query_start
> -1) &&
509 (a
->query_len
== b
->query_len
)) {
510 if(StrCmpNW(a
->canon_uri
+a
->query_start
, b
->canon_uri
+b
->query_start
, a
->query_len
))
512 } else if(a
->query_len
!= b
->query_len
)
515 if((a
->fragment_start
> -1 && b
->fragment_start
> -1) &&
516 (a
->fragment_len
== b
->fragment_len
)) {
517 if(StrCmpNW(a
->canon_uri
+a
->fragment_start
, b
->canon_uri
+b
->fragment_start
, a
->fragment_len
))
519 } else if(a
->fragment_len
!= b
->fragment_len
)
522 /* If we get here, the two URIs are equivalent. */
529 /* Computes the size of the given IPv6 address.
530 * Each h16 component is 16 bits. If there is an IPv4 address, it's
531 * 32 bits. If there's an elision it can be 16 to 128 bits, depending
532 * on the number of other components.
534 * Modeled after google-url's CheckIPv6ComponentsSize function
536 static void compute_ipv6_comps_size(ipv6_address
*address
) {
537 address
->components_size
= address
->h16_count
* 2;
540 /* IPv4 address is 4 bytes. */
541 address
->components_size
+= 4;
543 if(address
->elision
) {
544 /* An elision can be anywhere from 2 bytes up to 16 bytes.
545 * Its size depends on the size of the h16 and IPv4 components.
547 address
->elision_size
= 16 - address
->components_size
;
548 if(address
->elision_size
< 2)
549 address
->elision_size
= 2;
551 address
->elision_size
= 0;
554 /* Taken from dlls/jscript/lex.c */
555 static int hex_to_int(WCHAR val
) {
556 if(val
>= '0' && val
<= '9')
558 else if(val
>= 'a' && val
<= 'f')
559 return val
- 'a' + 10;
560 else if(val
>= 'A' && val
<= 'F')
561 return val
- 'A' + 10;
566 /* Helper function for converting a percent encoded string
567 * representation of a WCHAR value into its actual WCHAR value. If
568 * the two characters following the '%' aren't valid hex values then
569 * this function returns the NULL character.
572 * "%2E" will result in '.' being returned by this function.
574 static WCHAR
decode_pct_val(const WCHAR
*ptr
) {
577 if(*ptr
== '%' && is_hexdigit(*(ptr
+ 1)) && is_hexdigit(*(ptr
+ 2))) {
578 INT a
= hex_to_int(*(ptr
+ 1));
579 INT b
= hex_to_int(*(ptr
+ 2));
588 /* Helper function for percent encoding a given character
589 * and storing the encoded value into a given buffer (dest).
591 * It's up to the calling function to ensure that there is
592 * at least enough space in 'dest' for the percent encoded
593 * value to be stored (so dest + 3 spaces available).
595 static inline void pct_encode_val(WCHAR val
, WCHAR
*dest
) {
597 dest
[1] = hexDigits
[(val
>> 4) & 0xf];
598 dest
[2] = hexDigits
[val
& 0xf];
601 /* Attempts to parse the domain name from the host.
603 * This function also includes the Top-level Domain (TLD) name
604 * of the host when it tries to find the domain name. If it finds
605 * a valid domain name it will assign 'domain_start' the offset
606 * into 'host' where the domain name starts.
608 * It's implied that if there is a domain name its range is:
609 * [host+domain_start, host+host_len).
611 void find_domain_name(const WCHAR
*host
, DWORD host_len
,
613 const WCHAR
*last_tld
, *sec_last_tld
, *end
;
615 end
= host
+host_len
-1;
619 /* There has to be at least enough room for a '.' followed by a
620 * 3-character TLD for a domain to even exist in the host name.
625 last_tld
= memrchrW(host
, '.', host_len
);
627 /* http://hostname -> has no domain name. */
630 sec_last_tld
= memrchrW(host
, '.', last_tld
-host
);
632 /* If the '.' is at the beginning of the host there
633 * has to be at least 3 characters in the TLD for it
635 * Ex: .com -> .com as the domain name.
636 * .co -> has no domain name.
638 if(last_tld
-host
== 0) {
639 if(end
-(last_tld
-1) < 3)
641 } else if(last_tld
-host
== 3) {
644 /* If there are three characters in front of last_tld and
645 * they are on the list of recognized TLDs, then this
646 * host doesn't have a domain (since the host only contains
648 * Ex: edu.uk -> has no domain name.
649 * foo.uk -> foo.uk as the domain name.
651 for(i
= 0; i
< sizeof(recognized_tlds
)/sizeof(recognized_tlds
[0]); ++i
) {
652 if(!StrCmpNIW(host
, recognized_tlds
[i
].tld_name
, 3))
655 } else if(last_tld
-host
< 3)
656 /* Anything less than 3 characters is considered part
658 * Ex: ak.uk -> Has no domain name.
662 /* Otherwise the domain name is the whole host name. */
664 } else if(end
+1-last_tld
> 3) {
665 /* If the last_tld has more than 3 characters, then it's automatically
666 * considered the TLD of the domain name.
667 * Ex: www.winehq.org.uk.test -> uk.test as the domain name.
669 *domain_start
= (sec_last_tld
+1)-host
;
670 } else if(last_tld
- (sec_last_tld
+1) < 4) {
672 /* If the sec_last_tld is 3 characters long it HAS to be on the list of
673 * recognized to still be considered part of the TLD name, otherwise
674 * its considered the domain name.
675 * Ex: www.google.com.uk -> google.com.uk as the domain name.
676 * www.google.foo.uk -> foo.uk as the domain name.
678 if(last_tld
- (sec_last_tld
+1) == 3) {
679 for(i
= 0; i
< sizeof(recognized_tlds
)/sizeof(recognized_tlds
[0]); ++i
) {
680 if(!StrCmpNIW(sec_last_tld
+1, recognized_tlds
[i
].tld_name
, 3)) {
681 const WCHAR
*domain
= memrchrW(host
, '.', sec_last_tld
-host
);
686 *domain_start
= (domain
+1) - host
;
687 TRACE("Found domain name %s\n", debugstr_wn(host
+*domain_start
,
688 (host
+host_len
)-(host
+*domain_start
)));
693 *domain_start
= (sec_last_tld
+1)-host
;
695 /* Since the sec_last_tld is less than 3 characters it's considered
697 * Ex: www.google.fo.uk -> google.fo.uk as the domain name.
699 const WCHAR
*domain
= memrchrW(host
, '.', sec_last_tld
-host
);
704 *domain_start
= (domain
+1) - host
;
707 /* The second to last TLD has more than 3 characters making it
709 * Ex: www.google.test.us -> test.us as the domain name.
711 *domain_start
= (sec_last_tld
+1)-host
;
714 TRACE("Found domain name %s\n", debugstr_wn(host
+*domain_start
,
715 (host
+host_len
)-(host
+*domain_start
)));
718 /* Removes the dot segments from a hierarchical URIs path component. This
719 * function performs the removal in place.
721 * This function returns the new length of the path string.
723 static DWORD
remove_dot_segments(WCHAR
*path
, DWORD path_len
) {
725 const WCHAR
*in
= out
;
726 const WCHAR
*end
= out
+ path_len
;
730 /* Move the first path segment in the input buffer to the end of
731 * the output buffer, and any subsequent characters up to, including
732 * the next "/" character (if any) or the end of the input buffer.
734 while(in
< end
&& !is_slash(*in
))
744 /* Handle ending "/." */
751 if(is_slash(in
[1])) {
756 /* If we don't have "/../" or ending "/.." */
757 if(in
[1] != '.' || (in
+ 2 != end
&& !is_slash(in
[2])))
760 /* Find the slash preceding out pointer and move out pointer to it */
761 if(out
> path
+1 && is_slash(*--out
))
763 while(out
> path
&& !is_slash(*(--out
)));
773 TRACE("(%p %d): Path after dot segments removed %s len=%d\n", path
, path_len
,
774 debugstr_wn(path
, len
), len
);
778 /* Attempts to find the file extension in a given path. */
779 static INT
find_file_extension(const WCHAR
*path
, DWORD path_len
) {
782 for(end
= path
+path_len
-1; end
>= path
&& *end
!= '/' && *end
!= '\\'; --end
) {
790 /* Computes the location where the elision should occur in the IPv6
791 * address using the numerical values of each component stored in
792 * 'values'. If the address shouldn't contain an elision then 'index'
793 * is assigned -1 as its value. Otherwise 'index' will contain the
794 * starting index (into values) where the elision should be, and 'count'
795 * will contain the number of cells the elision covers.
798 * Windows will expand an elision if the elision only represents one h16
799 * component of the address.
801 * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
803 * If the IPv6 address contains an IPv4 address, the IPv4 address is also
804 * considered for being included as part of an elision if all its components
807 * Ex: [1:2:3:4:5:6:0.0.0.0] -> [1:2:3:4:5:6::]
809 static void compute_elision_location(const ipv6_address
*address
, const USHORT values
[8],
810 INT
*index
, DWORD
*count
) {
811 DWORD i
, max_len
, cur_len
;
812 INT max_index
, cur_index
;
814 max_len
= cur_len
= 0;
815 max_index
= cur_index
= -1;
816 for(i
= 0; i
< 8; ++i
) {
817 BOOL check_ipv4
= (address
->ipv4
&& i
== 6);
818 BOOL is_end
= (check_ipv4
|| i
== 7);
821 /* Check if the IPv4 address contains only zeros. */
822 if(values
[i
] == 0 && values
[i
+1] == 0) {
829 } else if(values
[i
] == 0) {
836 if(is_end
|| values
[i
] != 0) {
837 /* We only consider it for an elision if it's
838 * more than 1 component long.
840 if(cur_len
> 1 && cur_len
> max_len
) {
841 /* Found the new elision location. */
843 max_index
= cur_index
;
846 /* Reset the current range for the next range of zeros. */
856 /* Removes all the leading and trailing white spaces or
857 * control characters from the URI and removes all control
858 * characters inside of the URI string.
860 static BSTR
pre_process_uri(LPCWSTR uri
) {
861 const WCHAR
*start
, *end
, *ptr
;
867 /* Skip leading controls and whitespace. */
868 while(*start
&& (iscntrlW(*start
) || isspaceW(*start
))) ++start
;
870 /* URI consisted only of control/whitespace. */
872 return SysAllocStringLen(NULL
, 0);
874 end
= start
+ strlenW(start
);
875 while(--end
> start
&& (iscntrlW(*end
) || isspaceW(*end
)));
878 for(ptr
= start
; ptr
< end
; ptr
++) {
883 ret
= SysAllocStringLen(NULL
, len
);
887 for(ptr
= start
, ptr2
=ret
; ptr
< end
; ptr
++) {
895 /* Converts the specified IPv4 address into an uint value.
897 * This function assumes that the IPv4 address has already been validated.
899 static UINT
ipv4toui(const WCHAR
*ip
, DWORD len
) {
901 DWORD comp_value
= 0;
904 for(ptr
= ip
; ptr
< ip
+len
; ++ptr
) {
910 comp_value
= comp_value
*10 + (*ptr
-'0');
919 /* Converts an IPv4 address in numerical form into its fully qualified
920 * string form. This function returns the number of characters written
921 * to 'dest'. If 'dest' is NULL this function will return the number of
922 * characters that would have been written.
924 * It's up to the caller to ensure there's enough space in 'dest' for the
927 static DWORD
ui2ipv4(WCHAR
*dest
, UINT address
) {
928 static const WCHAR formatW
[] =
929 {'%','u','.','%','u','.','%','u','.','%','u',0};
933 digits
[0] = (address
>> 24) & 0xff;
934 digits
[1] = (address
>> 16) & 0xff;
935 digits
[2] = (address
>> 8) & 0xff;
936 digits
[3] = address
& 0xff;
940 ret
= sprintfW(tmp
, formatW
, digits
[0], digits
[1], digits
[2], digits
[3]);
942 ret
= sprintfW(dest
, formatW
, digits
[0], digits
[1], digits
[2], digits
[3]);
947 static DWORD
ui2str(WCHAR
*dest
, UINT value
) {
948 static const WCHAR formatW
[] = {'%','u',0};
953 ret
= sprintfW(tmp
, formatW
, value
);
955 ret
= sprintfW(dest
, formatW
, value
);
960 /* Converts a h16 component (from an IPv6 address) into its
963 * This function assumes that the h16 component has already been validated.
965 static USHORT
h16tous(h16 component
) {
969 for(i
= 0; i
< component
.len
; ++i
) {
971 ret
+= hex_to_int(component
.str
[i
]);
977 /* Converts an IPv6 address into its 128 bits (16 bytes) numerical value.
979 * This function assumes that the ipv6_address has already been validated.
981 static BOOL
ipv6_to_number(const ipv6_address
*address
, USHORT number
[8]) {
982 DWORD i
, cur_component
= 0;
983 BOOL already_passed_elision
= FALSE
;
985 for(i
= 0; i
< address
->h16_count
; ++i
) {
986 if(address
->elision
) {
987 if(address
->components
[i
].str
> address
->elision
&& !already_passed_elision
) {
988 /* Means we just passed the elision and need to add its values to
989 * 'number' before we do anything else.
992 for(j
= 0; j
< address
->elision_size
; j
+=2)
993 number
[cur_component
++] = 0;
995 already_passed_elision
= TRUE
;
999 number
[cur_component
++] = h16tous(address
->components
[i
]);
1002 /* Case when the elision appears after the h16 components. */
1003 if(!already_passed_elision
&& address
->elision
) {
1004 for(i
= 0; i
< address
->elision_size
; i
+=2)
1005 number
[cur_component
++] = 0;
1009 UINT value
= ipv4toui(address
->ipv4
, address
->ipv4_len
);
1011 if(cur_component
!= 6) {
1012 ERR("(%p %p): Failed sanity check with %d\n", address
, number
, cur_component
);
1016 number
[cur_component
++] = (value
>> 16) & 0xffff;
1017 number
[cur_component
] = value
& 0xffff;
1023 /* Checks if the characters pointed to by 'ptr' are
1024 * a percent encoded data octet.
1026 * pct-encoded = "%" HEXDIG HEXDIG
1028 static BOOL
check_pct_encoded(const WCHAR
**ptr
) {
1029 const WCHAR
*start
= *ptr
;
1035 if(!is_hexdigit(**ptr
)) {
1041 if(!is_hexdigit(**ptr
)) {
1050 /* dec-octet = DIGIT ; 0-9
1051 * / %x31-39 DIGIT ; 10-99
1052 * / "1" 2DIGIT ; 100-199
1053 * / "2" %x30-34 DIGIT ; 200-249
1054 * / "25" %x30-35 ; 250-255
1056 static BOOL
check_dec_octet(const WCHAR
**ptr
) {
1057 const WCHAR
*c1
, *c2
, *c3
;
1060 /* A dec-octet must be at least 1 digit long. */
1061 if(*c1
< '0' || *c1
> '9')
1067 /* Since the 1-digit requirement was met, it doesn't
1068 * matter if this is a DIGIT value, it's considered a
1071 if(*c2
< '0' || *c2
> '9')
1077 /* Same explanation as above. */
1078 if(*c3
< '0' || *c3
> '9')
1081 /* Anything > 255 isn't a valid IP dec-octet. */
1082 if(*c1
>= '2' && *c2
>= '5' && *c3
>= '5') {
1091 /* Checks if there is an implicit IPv4 address in the host component of the URI.
1092 * The max value of an implicit IPv4 address is UINT_MAX.
1095 * "234567" would be considered an implicit IPv4 address.
1097 static BOOL
check_implicit_ipv4(const WCHAR
**ptr
, UINT
*val
) {
1098 const WCHAR
*start
= *ptr
;
1102 while(is_num(**ptr
)) {
1103 ret
= ret
*10 + (**ptr
- '0');
1105 if(ret
> UINT_MAX
) {
1119 /* Checks if the string contains an IPv4 address.
1121 * This function has a strict mode or a non-strict mode of operation
1122 * When 'strict' is set to FALSE this function will return TRUE if
1123 * the string contains at least 'dec-octet "." dec-octet' since partial
1124 * IPv4 addresses will be normalized out into full IPv4 addresses. When
1125 * 'strict' is set this function expects there to be a full IPv4 address.
1127 * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
1129 static BOOL
check_ipv4address(const WCHAR
**ptr
, BOOL strict
) {
1130 const WCHAR
*start
= *ptr
;
1132 if(!check_dec_octet(ptr
)) {
1143 if(!check_dec_octet(ptr
)) {
1157 if(!check_dec_octet(ptr
)) {
1171 if(!check_dec_octet(ptr
)) {
1176 /* Found a four digit ip address. */
1179 /* Tries to parse the scheme name of the URI.
1181 * scheme = ALPHA *(ALPHA | NUM | '+' | '-' | '.') as defined by RFC 3896.
1182 * NOTE: Windows accepts a number as the first character of a scheme.
1184 static BOOL
parse_scheme_name(const WCHAR
**ptr
, parse_data
*data
, DWORD extras
) {
1185 const WCHAR
*start
= *ptr
;
1187 data
->scheme
= NULL
;
1188 data
->scheme_len
= 0;
1191 if(**ptr
== '*' && *ptr
== start
) {
1192 /* Might have found a wildcard scheme. If it is the next
1193 * char has to be a ':' for it to be a valid URI
1197 } else if(!is_num(**ptr
) && !is_alpha(**ptr
) && **ptr
!= '+' &&
1198 **ptr
!= '-' && **ptr
!= '.')
1207 /* Schemes must end with a ':' */
1208 if(**ptr
!= ':' && !((extras
& ALLOW_NULL_TERM_SCHEME
) && !**ptr
)) {
1213 data
->scheme
= start
;
1214 data
->scheme_len
= *ptr
- start
;
1220 /* Tries to deduce the corresponding URL_SCHEME for the given URI. Stores
1221 * the deduced URL_SCHEME in data->scheme_type.
1223 static BOOL
parse_scheme_type(parse_data
*data
) {
1224 /* If there's scheme data then see if it's a recognized scheme. */
1225 if(data
->scheme
&& data
->scheme_len
) {
1228 for(i
= 0; i
< sizeof(recognized_schemes
)/sizeof(recognized_schemes
[0]); ++i
) {
1229 if(lstrlenW(recognized_schemes
[i
].scheme_name
) == data
->scheme_len
) {
1230 /* Has to be a case insensitive compare. */
1231 if(!StrCmpNIW(recognized_schemes
[i
].scheme_name
, data
->scheme
, data
->scheme_len
)) {
1232 data
->scheme_type
= recognized_schemes
[i
].scheme
;
1238 /* If we get here it means it's not a recognized scheme. */
1239 data
->scheme_type
= URL_SCHEME_UNKNOWN
;
1241 } else if(data
->is_relative
) {
1242 /* Relative URI's have no scheme. */
1243 data
->scheme_type
= URL_SCHEME_UNKNOWN
;
1246 /* Should never reach here! what happened... */
1247 FIXME("(%p): Unable to determine scheme type for URI %s\n", data
, debugstr_w(data
->uri
));
1252 /* Tries to parse (or deduce) the scheme_name of a URI. If it can't
1253 * parse a scheme from the URI it will try to deduce the scheme_name and scheme_type
1254 * using the flags specified in 'flags' (if any). Flags that affect how this function
1255 * operates are the Uri_CREATE_ALLOW_* flags.
1257 * All parsed/deduced information will be stored in 'data' when the function returns.
1259 * Returns TRUE if it was able to successfully parse the information.
1261 static BOOL
parse_scheme(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1262 static const WCHAR fileW
[] = {'f','i','l','e',0};
1263 static const WCHAR wildcardW
[] = {'*',0};
1265 /* First check to see if the uri could implicitly be a file path. */
1266 if(is_implicit_file_path(*ptr
)) {
1267 if(flags
& Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME
) {
1268 data
->scheme
= fileW
;
1269 data
->scheme_len
= lstrlenW(fileW
);
1270 data
->has_implicit_scheme
= TRUE
;
1272 TRACE("(%p %p %x): URI is an implicit file path.\n", ptr
, data
, flags
);
1274 /* Windows does not consider anything that can implicitly be a file
1275 * path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set...
1277 TRACE("(%p %p %x): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n",
1281 } else if(!parse_scheme_name(ptr
, data
, extras
)) {
1282 /* No scheme was found, this means it could be:
1283 * a) an implicit Wildcard scheme
1285 * c) an invalid URI.
1287 if(flags
& Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME
) {
1288 data
->scheme
= wildcardW
;
1289 data
->scheme_len
= lstrlenW(wildcardW
);
1290 data
->has_implicit_scheme
= TRUE
;
1292 TRACE("(%p %p %x): URI is an implicit wildcard scheme.\n", ptr
, data
, flags
);
1293 } else if (flags
& Uri_CREATE_ALLOW_RELATIVE
) {
1294 data
->is_relative
= TRUE
;
1295 TRACE("(%p %p %x): URI is relative.\n", ptr
, data
, flags
);
1297 TRACE("(%p %p %x): Malformed URI found. Unable to deduce scheme name.\n", ptr
, data
, flags
);
1302 if(!data
->is_relative
)
1303 TRACE("(%p %p %x): Found scheme=%s scheme_len=%d\n", ptr
, data
, flags
,
1304 debugstr_wn(data
->scheme
, data
->scheme_len
), data
->scheme_len
);
1306 if(!parse_scheme_type(data
))
1309 TRACE("(%p %p %x): Assigned %d as the URL_SCHEME.\n", ptr
, data
, flags
, data
->scheme_type
);
1313 static BOOL
parse_username(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1314 data
->username
= *ptr
;
1316 while(**ptr
!= ':' && **ptr
!= '@') {
1318 if(!check_pct_encoded(ptr
)) {
1319 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1320 *ptr
= data
->username
;
1321 data
->username
= NULL
;
1326 } else if(extras
& ALLOW_NULL_TERM_USER_NAME
&& !**ptr
)
1328 else if(is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)) {
1329 *ptr
= data
->username
;
1330 data
->username
= NULL
;
1337 data
->username_len
= *ptr
- data
->username
;
1341 static BOOL
parse_password(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1342 data
->password
= *ptr
;
1344 while(**ptr
!= '@') {
1346 if(!check_pct_encoded(ptr
)) {
1347 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1348 *ptr
= data
->password
;
1349 data
->password
= NULL
;
1354 } else if(extras
& ALLOW_NULL_TERM_PASSWORD
&& !**ptr
)
1356 else if(is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)) {
1357 *ptr
= data
->password
;
1358 data
->password
= NULL
;
1365 data
->password_len
= *ptr
- data
->password
;
1369 /* Parses the userinfo part of the URI (if it exists). The userinfo field of
1370 * a URI can consist of "username:password@", or just "username@".
1373 * userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
1376 * 1) If there is more than one ':' in the userinfo part of the URI Windows
1377 * uses the first occurrence of ':' to delimit the username and password
1381 * ftp://user:pass:word@winehq.org
1383 * would yield "user" as the username and "pass:word" as the password.
1385 * 2) Windows allows any character to appear in the "userinfo" part of
1386 * a URI, as long as it's not an authority delimiter character set.
1388 static void parse_userinfo(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1389 const WCHAR
*start
= *ptr
;
1391 if(!parse_username(ptr
, data
, flags
, 0)) {
1392 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr
, data
, flags
);
1398 if(!parse_password(ptr
, data
, flags
, 0)) {
1400 data
->username
= NULL
;
1401 data
->username_len
= 0;
1402 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr
, data
, flags
);
1409 data
->username
= NULL
;
1410 data
->username_len
= 0;
1411 data
->password
= NULL
;
1412 data
->password_len
= 0;
1414 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr
, data
, flags
);
1419 TRACE("(%p %p %x): Found username %s len=%d.\n", ptr
, data
, flags
,
1420 debugstr_wn(data
->username
, data
->username_len
), data
->username_len
);
1423 TRACE("(%p %p %x): Found password %s len=%d.\n", ptr
, data
, flags
,
1424 debugstr_wn(data
->password
, data
->password_len
), data
->password_len
);
1429 /* Attempts to parse a port from the URI.
1432 * Windows seems to have a cap on what the maximum value
1433 * for a port can be. The max value is USHORT_MAX.
1437 static BOOL
parse_port(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1441 while(!is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)) {
1442 if(!is_num(**ptr
)) {
1448 port
= port
*10 + (**ptr
-'0');
1450 if(port
> USHORT_MAX
) {
1459 data
->has_port
= TRUE
;
1460 data
->port_value
= port
;
1461 data
->port_len
= *ptr
- data
->port
;
1463 TRACE("(%p %p %x): Found port %s len=%d value=%u\n", ptr
, data
, flags
,
1464 debugstr_wn(data
->port
, data
->port_len
), data
->port_len
, data
->port_value
);
1468 /* Attempts to parse a IPv4 address from the URI.
1471 * Windows normalizes IPv4 addresses, This means there are three
1472 * possibilities for the URI to contain an IPv4 address.
1473 * 1) A well formed address (ex. 192.2.2.2).
1474 * 2) A partially formed address. For example "192.0" would
1475 * normalize to "192.0.0.0" during canonicalization.
1476 * 3) An implicit IPv4 address. For example "256" would
1477 * normalize to "0.0.1.0" during canonicalization. Also
1478 * note that the maximum value for an implicit IP address
1479 * is UINT_MAX, if the value in the URI exceeds this then
1480 * it is not considered an IPv4 address.
1482 static BOOL
parse_ipv4address(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1483 const BOOL is_unknown
= data
->scheme_type
== URL_SCHEME_UNKNOWN
;
1486 if(!check_ipv4address(ptr
, FALSE
)) {
1487 if(!check_implicit_ipv4(ptr
, &data
->implicit_ipv4
)) {
1488 TRACE("(%p %p %x): URI didn't contain anything looking like an IPv4 address.\n",
1494 data
->has_implicit_ip
= TRUE
;
1497 data
->host_len
= *ptr
- data
->host
;
1498 data
->host_type
= Uri_HOST_IPV4
;
1500 /* Check if what we found is the only part of the host name (if it isn't
1501 * we don't have an IPv4 address).
1505 if(!parse_port(ptr
, data
, flags
)) {
1510 } else if(!is_auth_delim(**ptr
, !is_unknown
)) {
1511 /* Found more data which belongs to the host, so this isn't an IPv4. */
1514 data
->has_implicit_ip
= FALSE
;
1518 TRACE("(%p %p %x): IPv4 address found. host=%s host_len=%d host_type=%d\n",
1519 ptr
, data
, flags
, debugstr_wn(data
->host
, data
->host_len
),
1520 data
->host_len
, data
->host_type
);
1524 /* Attempts to parse the reg-name from the URI.
1526 * Because of the way Windows handles ':' this function also
1527 * handles parsing the port.
1529 * reg-name = *( unreserved / pct-encoded / sub-delims )
1532 * Windows allows everything, but, the characters in "auth_delims" and ':'
1533 * to appear in a reg-name, unless it's an unknown scheme type then ':' is
1534 * allowed to appear (even if a valid port isn't after it).
1536 * Windows doesn't like host names which start with '[' and end with ']'
1537 * and don't contain a valid IP literal address in between them.
1539 * On Windows if a '[' is encountered in the host name the ':' no longer
1540 * counts as a delimiter until you reach the next ']' or an "authority delimiter".
1542 * A reg-name CAN be empty.
1544 static BOOL
parse_reg_name(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1545 const BOOL has_start_bracket
= **ptr
== '[';
1546 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
1547 const BOOL is_res
= data
->scheme_type
== URL_SCHEME_RES
;
1548 BOOL inside_brackets
= has_start_bracket
;
1550 /* res URIs don't have ports. */
1551 BOOL ignore_col
= (extras
& IGNORE_PORT_DELIMITER
) || is_res
;
1553 /* We have to be careful with file schemes. */
1554 if(data
->scheme_type
== URL_SCHEME_FILE
) {
1555 /* This is because an implicit file scheme could be "C:\\test" and it
1556 * would trick this function into thinking the host is "C", when after
1557 * canonicalization the host would end up being an empty string. A drive
1558 * path can also have a '|' instead of a ':' after the drive letter.
1560 if(is_drive_path(*ptr
)) {
1561 /* Regular old drive paths have no host type (or host name). */
1562 data
->host_type
= Uri_HOST_UNKNOWN
;
1566 } else if(is_unc_path(*ptr
))
1567 /* Skip past the "\\" of a UNC path. */
1573 /* For res URIs, everything before the first '/' is
1574 * considered the host.
1576 while((!is_res
&& !is_auth_delim(**ptr
, known_scheme
)) ||
1577 (is_res
&& **ptr
&& **ptr
!= '/')) {
1578 if(**ptr
== ':' && !ignore_col
) {
1579 /* We can ignore ':' if were inside brackets.*/
1580 if(!inside_brackets
) {
1581 const WCHAR
*tmp
= (*ptr
)++;
1583 /* Attempt to parse the port. */
1584 if(!parse_port(ptr
, data
, flags
)) {
1585 /* Windows expects there to be a valid port for known scheme types. */
1586 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1589 TRACE("(%p %p %x %x): Expected valid port\n", ptr
, data
, flags
, extras
);
1592 /* Windows gives up on trying to parse a port when it
1593 * encounters an invalid port.
1597 data
->host_len
= tmp
- data
->host
;
1601 } else if(**ptr
== '%' && (known_scheme
&& !is_res
)) {
1602 /* Has to be a legit % encoded value. */
1603 if(!check_pct_encoded(ptr
)) {
1609 } else if(is_res
&& is_forbidden_dos_path_char(**ptr
)) {
1613 } else if(**ptr
== ']')
1614 inside_brackets
= FALSE
;
1615 else if(**ptr
== '[')
1616 inside_brackets
= TRUE
;
1621 if(has_start_bracket
) {
1622 /* Make sure the last character of the host wasn't a ']'. */
1623 if(*(*ptr
-1) == ']') {
1624 TRACE("(%p %p %x %x): Expected an IP literal inside of the host\n",
1625 ptr
, data
, flags
, extras
);
1632 /* Don't overwrite our length if we found a port earlier. */
1634 data
->host_len
= *ptr
- data
->host
;
1636 /* If the host is empty, then it's an unknown host type. */
1637 if(data
->host_len
== 0 || is_res
)
1638 data
->host_type
= Uri_HOST_UNKNOWN
;
1640 data
->host_type
= Uri_HOST_DNS
;
1642 TRACE("(%p %p %x %x): Parsed reg-name. host=%s len=%d\n", ptr
, data
, flags
, extras
,
1643 debugstr_wn(data
->host
, data
->host_len
), data
->host_len
);
1647 /* Attempts to parse an IPv6 address out of the URI.
1649 * IPv6address = 6( h16 ":" ) ls32
1650 * / "::" 5( h16 ":" ) ls32
1651 * / [ h16 ] "::" 4( h16 ":" ) ls32
1652 * / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
1653 * / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
1654 * / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
1655 * / [ *4( h16 ":" ) h16 ] "::" ls32
1656 * / [ *5( h16 ":" ) h16 ] "::" h16
1657 * / [ *6( h16 ":" ) h16 ] "::"
1659 * ls32 = ( h16 ":" h16 ) / IPv4address
1660 * ; least-significant 32 bits of address.
1663 * ; 16 bits of address represented in hexadecimal.
1665 * Modeled after google-url's 'DoParseIPv6' function.
1667 static BOOL
parse_ipv6address(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1668 const WCHAR
*start
, *cur_start
;
1671 start
= cur_start
= *ptr
;
1672 memset(&ip
, 0, sizeof(ipv6_address
));
1675 /* Check if we're on the last character of the host. */
1676 BOOL is_end
= (is_auth_delim(**ptr
, data
->scheme_type
!= URL_SCHEME_UNKNOWN
)
1679 BOOL is_split
= (**ptr
== ':');
1680 BOOL is_elision
= (is_split
&& !is_end
&& *(*ptr
+1) == ':');
1682 /* Check if we're at the end of a component, or
1683 * if we're at the end of the IPv6 address.
1685 if(is_split
|| is_end
) {
1688 cur_len
= *ptr
- cur_start
;
1690 /* h16 can't have a length > 4. */
1694 TRACE("(%p %p %x): h16 component to long.\n",
1700 /* An h16 component can't have the length of 0 unless
1701 * the elision is at the beginning of the address, or
1702 * at the end of the address.
1704 if(!((*ptr
== start
&& is_elision
) ||
1705 (is_end
&& (*ptr
-2) == ip
.elision
))) {
1707 TRACE("(%p %p %x): IPv6 component cannot have a length of 0.\n",
1714 /* An IPv6 address can have no more than 8 h16 components. */
1715 if(ip
.h16_count
>= 8) {
1717 TRACE("(%p %p %x): Not a IPv6 address, to many h16 components.\n",
1722 ip
.components
[ip
.h16_count
].str
= cur_start
;
1723 ip
.components
[ip
.h16_count
].len
= cur_len
;
1725 TRACE("(%p %p %x): Found h16 component %s, len=%d, h16_count=%d\n",
1726 ptr
, data
, flags
, debugstr_wn(cur_start
, cur_len
), cur_len
,
1736 /* A IPv6 address can only have 1 elision ('::'). */
1740 TRACE("(%p %p %x): IPv6 address cannot have 2 elisions.\n",
1752 if(!check_ipv4address(ptr
, TRUE
)) {
1753 if(!is_hexdigit(**ptr
)) {
1754 /* Not a valid character for an IPv6 address. */
1759 /* Found an IPv4 address. */
1760 ip
.ipv4
= cur_start
;
1761 ip
.ipv4_len
= *ptr
- cur_start
;
1763 TRACE("(%p %p %x): Found an attached IPv4 address %s len=%d.\n",
1764 ptr
, data
, flags
, debugstr_wn(ip
.ipv4
, ip
.ipv4_len
),
1767 /* IPv4 addresses can only appear at the end of a IPv6. */
1773 compute_ipv6_comps_size(&ip
);
1775 /* Make sure the IPv6 address adds up to 16 bytes. */
1776 if(ip
.components_size
+ ip
.elision_size
!= 16) {
1778 TRACE("(%p %p %x): Invalid IPv6 address, did not add up to 16 bytes.\n",
1783 if(ip
.elision_size
== 2) {
1784 /* For some reason on Windows if an elision that represents
1785 * only one h16 component is encountered at the very begin or
1786 * end of an IPv6 address, Windows does not consider it a
1787 * valid IPv6 address.
1789 * Ex: [::2:3:4:5:6:7] is not valid, even though the sum
1790 * of all the components == 128bits.
1792 if(ip
.elision
< ip
.components
[0].str
||
1793 ip
.elision
> ip
.components
[ip
.h16_count
-1].str
) {
1795 TRACE("(%p %p %x): Invalid IPv6 address. Detected elision of 2 bytes at the beginning or end of the address.\n",
1801 data
->host_type
= Uri_HOST_IPV6
;
1802 data
->has_ipv6
= TRUE
;
1803 data
->ipv6_address
= ip
;
1805 TRACE("(%p %p %x): Found valid IPv6 literal %s len=%d\n",
1806 ptr
, data
, flags
, debugstr_wn(start
, *ptr
-start
),
1811 /* IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" ) */
1812 static BOOL
parse_ipvfuture(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1813 const WCHAR
*start
= *ptr
;
1815 /* IPvFuture has to start with a 'v' or 'V'. */
1816 if(**ptr
!= 'v' && **ptr
!= 'V')
1819 /* Following the v there must be at least 1 hex digit. */
1821 if(!is_hexdigit(**ptr
)) {
1827 while(is_hexdigit(**ptr
))
1830 /* End of the hexdigit sequence must be a '.' */
1837 if(!is_unreserved(**ptr
) && !is_subdelim(**ptr
) && **ptr
!= ':') {
1843 while(is_unreserved(**ptr
) || is_subdelim(**ptr
) || **ptr
== ':')
1846 data
->host_type
= Uri_HOST_UNKNOWN
;
1848 TRACE("(%p %p %x): Parsed IPvFuture address %s len=%d\n", ptr
, data
, flags
,
1849 debugstr_wn(start
, *ptr
-start
), (int)(*ptr
-start
));
1854 /* IP-literal = "[" ( IPv6address / IPvFuture ) "]" */
1855 static BOOL
parse_ip_literal(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1858 if(**ptr
!= '[' && !(extras
& ALLOW_BRACKETLESS_IP_LITERAL
)) {
1861 } else if(**ptr
== '[')
1864 if(!parse_ipv6address(ptr
, data
, flags
)) {
1865 if(extras
& SKIP_IP_FUTURE_CHECK
|| !parse_ipvfuture(ptr
, data
, flags
)) {
1872 if(**ptr
!= ']' && !(extras
& ALLOW_BRACKETLESS_IP_LITERAL
)) {
1876 } else if(!**ptr
&& extras
& ALLOW_BRACKETLESS_IP_LITERAL
) {
1877 /* The IP literal didn't contain brackets and was followed by
1878 * a NULL terminator, so no reason to even check the port.
1880 data
->host_len
= *ptr
- data
->host
;
1887 /* If a valid port is not found, then let it trickle down to
1890 if(!parse_port(ptr
, data
, flags
)) {
1896 data
->host_len
= *ptr
- data
->host
;
1901 /* Parses the host information from the URI.
1903 * host = IP-literal / IPv4address / reg-name
1905 static BOOL
parse_host(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
, DWORD extras
) {
1906 if(!parse_ip_literal(ptr
, data
, flags
, extras
)) {
1907 if(!parse_ipv4address(ptr
, data
, flags
)) {
1908 if(!parse_reg_name(ptr
, data
, flags
, extras
)) {
1909 TRACE("(%p %p %x %x): Malformed URI, Unknown host type.\n",
1910 ptr
, data
, flags
, extras
);
1919 /* Parses the authority information from the URI.
1921 * authority = [ userinfo "@" ] host [ ":" port ]
1923 static BOOL
parse_authority(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1924 parse_userinfo(ptr
, data
, flags
);
1926 /* Parsing the port will happen during one of the host parsing
1927 * routines (if the URI has a port).
1929 if(!parse_host(ptr
, data
, flags
, 0))
1935 /* Attempts to parse the path information of a hierarchical URI. */
1936 static BOOL
parse_path_hierarchical(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
1937 const WCHAR
*start
= *ptr
;
1938 static const WCHAR slash
[] = {'/',0};
1939 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
1941 if(is_path_delim(**ptr
)) {
1942 if(data
->scheme_type
== URL_SCHEME_WILDCARD
&& !data
->must_have_path
) {
1945 } else if(!(flags
& Uri_CREATE_NO_CANONICALIZE
)) {
1946 /* If the path component is empty, then a '/' is added. */
1951 while(!is_path_delim(**ptr
)) {
1952 if(**ptr
== '%' && data
->scheme_type
!= URL_SCHEME_UNKNOWN
&& !is_file
) {
1953 if(!check_pct_encoded(ptr
)) {
1958 } else if(is_forbidden_dos_path_char(**ptr
) && is_file
&&
1959 (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
1960 /* File schemes with USE_DOS_PATH set aren't allowed to have
1961 * a '<' or '>' or '\"' appear in them.
1965 } else if(**ptr
== '\\') {
1966 /* Not allowed to have a backslash if NO_CANONICALIZE is set
1967 * and the scheme is known type (but not a file scheme).
1969 if(flags
& Uri_CREATE_NO_CANONICALIZE
) {
1970 if(data
->scheme_type
!= URL_SCHEME_FILE
&&
1971 data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
1981 /* The only time a URI doesn't have a path is when
1982 * the NO_CANONICALIZE flag is set and the raw URI
1983 * didn't contain one.
1990 data
->path_len
= *ptr
- start
;
1995 TRACE("(%p %p %x): Parsed path %s len=%d\n", ptr
, data
, flags
,
1996 debugstr_wn(data
->path
, data
->path_len
), data
->path_len
);
1998 TRACE("(%p %p %x): The URI contained no path\n", ptr
, data
, flags
);
2003 /* Parses the path of an opaque URI (much less strict then the parser
2004 * for a hierarchical URI).
2007 * Windows allows invalid % encoded data to appear in opaque URI paths
2008 * for unknown scheme types.
2010 * File schemes with USE_DOS_PATH set aren't allowed to have '<', '>', or '\"'
2013 static BOOL
parse_path_opaque(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2014 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2015 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
2019 while(!is_path_delim(**ptr
)) {
2020 if(**ptr
== '%' && known_scheme
) {
2021 if(!check_pct_encoded(ptr
)) {
2027 } else if(is_forbidden_dos_path_char(**ptr
) && is_file
&&
2028 (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
2037 data
->path_len
= *ptr
- data
->path
;
2038 TRACE("(%p %p %x): Parsed opaque URI path %s len=%d\n", ptr
, data
, flags
,
2039 debugstr_wn(data
->path
, data
->path_len
), data
->path_len
);
2043 /* Determines how the URI should be parsed after the scheme information.
2045 * If the scheme is followed by "//", then it is treated as a hierarchical URI
2046 * which then the authority and path information will be parsed out. Otherwise, the
2047 * URI will be treated as an opaque URI which the authority information is not parsed
2050 * RFC 3896 definition of hier-part:
2052 * hier-part = "//" authority path-abempty
2057 * MSDN opaque URI definition:
2058 * scheme ":" path [ "#" fragment ]
2061 * If the URI is of an unknown scheme type and has a "//" following the scheme then it
2062 * is treated as a hierarchical URI, but, if the CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is
2063 * set then it is considered an opaque URI regardless of what follows the scheme information
2064 * (per MSDN documentation).
2066 static BOOL
parse_hierpart(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2067 const WCHAR
*start
= *ptr
;
2069 data
->must_have_path
= FALSE
;
2071 /* For javascript: URIs, simply set everything as a path */
2072 if(data
->scheme_type
== URL_SCHEME_JAVASCRIPT
) {
2074 data
->path_len
= strlenW(*ptr
);
2075 data
->is_opaque
= TRUE
;
2076 *ptr
+= data
->path_len
;
2080 /* Checks if the authority information needs to be parsed. */
2081 if(is_hierarchical_uri(ptr
, data
)) {
2082 /* Only treat it as a hierarchical URI if the scheme_type is known or
2083 * the Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is not set.
2085 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
||
2086 !(flags
& Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
)) {
2087 TRACE("(%p %p %x): Treating URI as an hierarchical URI.\n", ptr
, data
, flags
);
2088 data
->is_opaque
= FALSE
;
2090 if(data
->scheme_type
== URL_SCHEME_WILDCARD
&& !data
->has_implicit_scheme
) {
2091 if(**ptr
== '/' && *(*ptr
+1) == '/') {
2092 data
->must_have_path
= TRUE
;
2097 /* TODO: Handle hierarchical URI's, parse authority then parse the path. */
2098 if(!parse_authority(ptr
, data
, flags
))
2101 return parse_path_hierarchical(ptr
, data
, flags
);
2103 /* Reset ptr to its starting position so opaque path parsing
2104 * begins at the correct location.
2109 /* If it reaches here, then the URI will be treated as an opaque
2113 TRACE("(%p %p %x): Treating URI as an opaque URI.\n", ptr
, data
, flags
);
2115 data
->is_opaque
= TRUE
;
2116 if(!parse_path_opaque(ptr
, data
, flags
))
2122 /* Attempts to parse the query string from the URI.
2125 * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
2126 * data is allowed to appear in the query string. For unknown scheme types
2127 * invalid percent encoded data is allowed to appear regardless.
2129 static BOOL
parse_query(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2130 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2133 TRACE("(%p %p %x): URI didn't contain a query string.\n", ptr
, data
, flags
);
2140 while(**ptr
&& **ptr
!= '#') {
2141 if(**ptr
== '%' && known_scheme
&&
2142 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
2143 if(!check_pct_encoded(ptr
)) {
2154 data
->query_len
= *ptr
- data
->query
;
2156 TRACE("(%p %p %x): Parsed query string %s len=%d\n", ptr
, data
, flags
,
2157 debugstr_wn(data
->query
, data
->query_len
), data
->query_len
);
2161 /* Attempts to parse the fragment from the URI.
2164 * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
2165 * data is allowed to appear in the query string. For unknown scheme types
2166 * invalid percent encoded data is allowed to appear regardless.
2168 static BOOL
parse_fragment(const WCHAR
**ptr
, parse_data
*data
, DWORD flags
) {
2169 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2172 TRACE("(%p %p %x): URI didn't contain a fragment.\n", ptr
, data
, flags
);
2176 data
->fragment
= *ptr
;
2180 if(**ptr
== '%' && known_scheme
&&
2181 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
2182 if(!check_pct_encoded(ptr
)) {
2183 *ptr
= data
->fragment
;
2184 data
->fragment
= NULL
;
2193 data
->fragment_len
= *ptr
- data
->fragment
;
2195 TRACE("(%p %p %x): Parsed fragment %s len=%d\n", ptr
, data
, flags
,
2196 debugstr_wn(data
->fragment
, data
->fragment_len
), data
->fragment_len
);
2200 /* Parses and validates the components of the specified by data->uri
2201 * and stores the information it parses into 'data'.
2203 * Returns TRUE if it successfully parsed the URI. False otherwise.
2205 static BOOL
parse_uri(parse_data
*data
, DWORD flags
) {
2212 TRACE("(%p %x): BEGINNING TO PARSE URI %s.\n", data
, flags
, debugstr_w(data
->uri
));
2214 if(!parse_scheme(pptr
, data
, flags
, 0))
2217 if(!parse_hierpart(pptr
, data
, flags
))
2220 if(!parse_query(pptr
, data
, flags
))
2223 if(!parse_fragment(pptr
, data
, flags
))
2226 TRACE("(%p %x): FINISHED PARSING URI.\n", data
, flags
);
2230 static BOOL
canonicalize_username(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2233 if(!data
->username
) {
2234 uri
->userinfo_start
= -1;
2238 uri
->userinfo_start
= uri
->canon_len
;
2239 for(ptr
= data
->username
; ptr
< data
->username
+data
->username_len
; ++ptr
) {
2241 /* Only decode % encoded values for known scheme types. */
2242 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
2243 /* See if the value really needs decoding. */
2244 WCHAR val
= decode_pct_val(ptr
);
2245 if(is_unreserved(val
)) {
2247 uri
->canon_uri
[uri
->canon_len
] = val
;
2251 /* Move pass the hex characters. */
2256 } else if(!is_reserved(*ptr
) && !is_unreserved(*ptr
) && *ptr
!= '\\') {
2257 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2260 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
)) {
2262 pct_encode_val(*ptr
, uri
->canon_uri
+ uri
->canon_len
);
2264 uri
->canon_len
+= 3;
2270 /* Nothing special, so just copy the character over. */
2271 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2278 static BOOL
canonicalize_password(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2281 if(!data
->password
) {
2282 uri
->userinfo_split
= -1;
2286 if(uri
->userinfo_start
== -1)
2287 /* Has a password, but, doesn't have a username. */
2288 uri
->userinfo_start
= uri
->canon_len
;
2290 uri
->userinfo_split
= uri
->canon_len
- uri
->userinfo_start
;
2292 /* Add the ':' to the userinfo component. */
2294 uri
->canon_uri
[uri
->canon_len
] = ':';
2297 for(ptr
= data
->password
; ptr
< data
->password
+data
->password_len
; ++ptr
) {
2299 /* Only decode % encoded values for known scheme types. */
2300 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
2301 /* See if the value really needs decoding. */
2302 WCHAR val
= decode_pct_val(ptr
);
2303 if(is_unreserved(val
)) {
2305 uri
->canon_uri
[uri
->canon_len
] = val
;
2309 /* Move pass the hex characters. */
2314 } else if(!is_reserved(*ptr
) && !is_unreserved(*ptr
) && *ptr
!= '\\') {
2315 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2318 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
)) {
2320 pct_encode_val(*ptr
, uri
->canon_uri
+ uri
->canon_len
);
2322 uri
->canon_len
+= 3;
2328 /* Nothing special, so just copy the character over. */
2329 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2336 /* Canonicalizes the userinfo of the URI represented by the parse_data.
2338 * Canonicalization of the userinfo is a simple process. If there are any percent
2339 * encoded characters that fall in the "unreserved" character set, they are decoded
2340 * to their actual value. If a character is not in the "unreserved" or "reserved" sets
2341 * then it is percent encoded. Other than that the characters are copied over without
2344 static BOOL
canonicalize_userinfo(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2345 uri
->userinfo_start
= uri
->userinfo_split
= -1;
2346 uri
->userinfo_len
= 0;
2348 if(!data
->username
&& !data
->password
)
2349 /* URI doesn't have userinfo, so nothing to do here. */
2352 if(!canonicalize_username(data
, uri
, flags
, computeOnly
))
2355 if(!canonicalize_password(data
, uri
, flags
, computeOnly
))
2358 uri
->userinfo_len
= uri
->canon_len
- uri
->userinfo_start
;
2360 TRACE("(%p %p %x %d): Canonicalized userinfo, userinfo_start=%d, userinfo=%s, userinfo_split=%d userinfo_len=%d.\n",
2361 data
, uri
, flags
, computeOnly
, uri
->userinfo_start
, debugstr_wn(uri
->canon_uri
+ uri
->userinfo_start
, uri
->userinfo_len
),
2362 uri
->userinfo_split
, uri
->userinfo_len
);
2364 /* Now insert the '@' after the userinfo. */
2366 uri
->canon_uri
[uri
->canon_len
] = '@';
2372 /* Attempts to canonicalize a reg_name.
2374 * Things that happen:
2375 * 1) If Uri_CREATE_NO_CANONICALIZE flag is not set, then the reg_name is
2376 * lower cased. Unless it's an unknown scheme type, which case it's
2377 * no lower cased regardless.
2379 * 2) Unreserved % encoded characters are decoded for known
2382 * 3) Forbidden characters are % encoded as long as
2383 * Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS flag is not set and
2384 * it isn't an unknown scheme type.
2386 * 4) If it's a file scheme and the host is "localhost" it's removed.
2388 * 5) If it's a file scheme and Uri_CREATE_FILE_USE_DOS_PATH is set,
2389 * then the UNC path characters are added before the host name.
2391 static BOOL
canonicalize_reg_name(const parse_data
*data
, Uri
*uri
,
2392 DWORD flags
, BOOL computeOnly
) {
2393 static const WCHAR localhostW
[] =
2394 {'l','o','c','a','l','h','o','s','t',0};
2396 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2398 if(data
->scheme_type
== URL_SCHEME_FILE
&&
2399 data
->host_len
== lstrlenW(localhostW
)) {
2400 if(!StrCmpNIW(data
->host
, localhostW
, data
->host_len
)) {
2401 uri
->host_start
= -1;
2403 uri
->host_type
= Uri_HOST_UNKNOWN
;
2408 if(data
->scheme_type
== URL_SCHEME_FILE
&& flags
& Uri_CREATE_FILE_USE_DOS_PATH
) {
2410 uri
->canon_uri
[uri
->canon_len
] = '\\';
2411 uri
->canon_uri
[uri
->canon_len
+1] = '\\';
2413 uri
->canon_len
+= 2;
2414 uri
->authority_start
= uri
->canon_len
;
2417 uri
->host_start
= uri
->canon_len
;
2419 for(ptr
= data
->host
; ptr
< data
->host
+data
->host_len
; ++ptr
) {
2420 if(*ptr
== '%' && known_scheme
) {
2421 WCHAR val
= decode_pct_val(ptr
);
2422 if(is_unreserved(val
)) {
2423 /* If NO_CANONICALIZE is not set, then windows lower cases the
2426 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
) && isupperW(val
)) {
2428 uri
->canon_uri
[uri
->canon_len
] = tolowerW(val
);
2431 uri
->canon_uri
[uri
->canon_len
] = val
;
2435 /* Skip past the % encoded character. */
2439 /* Just copy the % over. */
2441 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2444 } else if(*ptr
== '\\') {
2445 /* Only unknown scheme types could have made it here with a '\\' in the host name. */
2447 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2449 } else if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) &&
2450 !is_unreserved(*ptr
) && !is_reserved(*ptr
) && known_scheme
) {
2452 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
2454 /* The percent encoded value gets lower cased also. */
2455 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
)) {
2456 uri
->canon_uri
[uri
->canon_len
+1] = tolowerW(uri
->canon_uri
[uri
->canon_len
+1]);
2457 uri
->canon_uri
[uri
->canon_len
+2] = tolowerW(uri
->canon_uri
[uri
->canon_len
+2]);
2461 uri
->canon_len
+= 3;
2464 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
) && known_scheme
)
2465 uri
->canon_uri
[uri
->canon_len
] = tolowerW(*ptr
);
2467 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2474 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2477 TRACE("(%p %p %x %d): Canonicalize reg_name=%s len=%d\n", data
, uri
, flags
,
2478 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2482 find_domain_name(uri
->canon_uri
+uri
->host_start
, uri
->host_len
,
2483 &(uri
->domain_offset
));
2488 /* Attempts to canonicalize an implicit IPv4 address. */
2489 static BOOL
canonicalize_implicit_ipv4address(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2490 uri
->host_start
= uri
->canon_len
;
2492 TRACE("%u\n", data
->implicit_ipv4
);
2493 /* For unknown scheme types Windows doesn't convert
2494 * the value into an IP address, but it still considers
2495 * it an IPv4 address.
2497 if(data
->scheme_type
== URL_SCHEME_UNKNOWN
) {
2499 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2500 uri
->canon_len
+= data
->host_len
;
2503 uri
->canon_len
+= ui2ipv4(uri
->canon_uri
+uri
->canon_len
, data
->implicit_ipv4
);
2505 uri
->canon_len
+= ui2ipv4(NULL
, data
->implicit_ipv4
);
2508 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2509 uri
->host_type
= Uri_HOST_IPV4
;
2512 TRACE("%p %p %x %d): Canonicalized implicit IP address=%s len=%d\n",
2513 data
, uri
, flags
, computeOnly
,
2514 debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2520 /* Attempts to canonicalize an IPv4 address.
2522 * If the parse_data represents a URI that has an implicit IPv4 address
2523 * (ex. http://256/, this function will convert 256 into 0.0.1.0). If
2524 * the implicit IP address exceeds the value of UINT_MAX (maximum value
2525 * for an IPv4 address) it's canonicalized as if it were a reg-name.
2527 * If the parse_data contains a partial or full IPv4 address it normalizes it.
2528 * A partial IPv4 address is something like "192.0" and would be normalized to
2529 * "192.0.0.0". With a full (or partial) IPv4 address like "192.002.01.003" would
2530 * be normalized to "192.2.1.3".
2533 * Windows ONLY normalizes IPv4 address for known scheme types (one that isn't
2534 * URL_SCHEME_UNKNOWN). For unknown scheme types, it simply copies the data from
2535 * the original URI into the canonicalized URI, but, it still recognizes URI's
2536 * host type as HOST_IPV4.
2538 static BOOL
canonicalize_ipv4address(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2539 if(data
->has_implicit_ip
)
2540 return canonicalize_implicit_ipv4address(data
, uri
, flags
, computeOnly
);
2542 uri
->host_start
= uri
->canon_len
;
2544 /* Windows only normalizes for known scheme types. */
2545 if(data
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
2546 /* parse_data contains a partial or full IPv4 address, so normalize it. */
2547 DWORD i
, octetDigitCount
= 0, octetCount
= 0;
2548 BOOL octetHasDigit
= FALSE
;
2550 for(i
= 0; i
< data
->host_len
; ++i
) {
2551 if(data
->host
[i
] == '0' && !octetHasDigit
) {
2552 /* Can ignore leading zeros if:
2553 * 1) It isn't the last digit of the octet.
2554 * 2) i+1 != data->host_len
2557 if(octetDigitCount
== 2 ||
2558 i
+1 == data
->host_len
||
2559 data
->host
[i
+1] == '.') {
2561 uri
->canon_uri
[uri
->canon_len
] = data
->host
[i
];
2563 TRACE("Adding zero\n");
2565 } else if(data
->host
[i
] == '.') {
2567 uri
->canon_uri
[uri
->canon_len
] = data
->host
[i
];
2570 octetDigitCount
= 0;
2571 octetHasDigit
= FALSE
;
2575 uri
->canon_uri
[uri
->canon_len
] = data
->host
[i
];
2579 octetHasDigit
= TRUE
;
2583 /* Make sure the canonicalized IP address has 4 dec-octets.
2584 * If doesn't add "0" ones until there is 4;
2586 for( ; octetCount
< 3; ++octetCount
) {
2588 uri
->canon_uri
[uri
->canon_len
] = '.';
2589 uri
->canon_uri
[uri
->canon_len
+1] = '0';
2592 uri
->canon_len
+= 2;
2595 /* Windows doesn't normalize addresses in unknown schemes. */
2597 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2598 uri
->canon_len
+= data
->host_len
;
2601 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2603 TRACE("(%p %p %x %d): Canonicalized IPv4 address, ip=%s len=%d\n",
2604 data
, uri
, flags
, computeOnly
,
2605 debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2612 /* Attempts to canonicalize the IPv6 address of the URI.
2614 * Multiple things happen during the canonicalization of an IPv6 address:
2615 * 1) Any leading zero's in a h16 component are removed.
2616 * Ex: [0001:0022::] -> [1:22::]
2618 * 2) The longest sequence of zero h16 components are compressed
2619 * into a "::" (elision). If there's a tie, the first is chosen.
2621 * Ex: [0:0:0:0:1:6:7:8] -> [::1:6:7:8]
2622 * [0:0:0:0:1:2::] -> [::1:2:0:0]
2623 * [0:0:1:2:0:0:7:8] -> [::1:2:0:0:7:8]
2625 * 3) If an IPv4 address is attached to the IPv6 address, it's
2627 * Ex: [::001.002.022.000] -> [::1.2.22.0]
2629 * 4) If an elision is present, but, only represents one h16 component
2632 * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
2634 * 5) If the IPv6 address contains an IPv4 address and there exists
2635 * at least 1 non-zero h16 component the IPv4 address is converted
2636 * into two h16 components, otherwise it's normalized and kept as is.
2638 * Ex: [::192.200.003.4] -> [::192.200.3.4]
2639 * [ffff::192.200.003.4] -> [ffff::c0c8:3041]
2642 * For unknown scheme types Windows simply copies the address over without any
2645 * IPv4 address can be included in an elision if all its components are 0's.
2647 static BOOL
canonicalize_ipv6address(const parse_data
*data
, Uri
*uri
,
2648 DWORD flags
, BOOL computeOnly
) {
2649 uri
->host_start
= uri
->canon_len
;
2651 if(data
->scheme_type
== URL_SCHEME_UNKNOWN
) {
2653 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2654 uri
->canon_len
+= data
->host_len
;
2658 DWORD i
, elision_len
;
2660 if(!ipv6_to_number(&(data
->ipv6_address
), values
)) {
2661 TRACE("(%p %p %x %d): Failed to compute numerical value for IPv6 address.\n",
2662 data
, uri
, flags
, computeOnly
);
2667 uri
->canon_uri
[uri
->canon_len
] = '[';
2670 /* Find where the elision should occur (if any). */
2671 compute_elision_location(&(data
->ipv6_address
), values
, &elision_start
, &elision_len
);
2673 TRACE("%p %p %x %d): Elision starts at %d, len=%u\n", data
, uri
, flags
,
2674 computeOnly
, elision_start
, elision_len
);
2676 for(i
= 0; i
< 8; ++i
) {
2677 BOOL in_elision
= (elision_start
> -1 && i
>= elision_start
&&
2678 i
< elision_start
+elision_len
);
2679 BOOL do_ipv4
= (i
== 6 && data
->ipv6_address
.ipv4
&& !in_elision
&&
2680 data
->ipv6_address
.h16_count
== 0);
2682 if(i
== elision_start
) {
2684 uri
->canon_uri
[uri
->canon_len
] = ':';
2685 uri
->canon_uri
[uri
->canon_len
+1] = ':';
2687 uri
->canon_len
+= 2;
2690 /* We can ignore the current component if we're in the elision. */
2694 /* We only add a ':' if we're not at i == 0, or when we're at
2695 * the very end of elision range since the ':' colon was handled
2696 * earlier. Otherwise we would end up with ":::" after elision.
2698 if(i
!= 0 && !(elision_start
> -1 && i
== elision_start
+elision_len
)) {
2700 uri
->canon_uri
[uri
->canon_len
] = ':';
2708 /* Combine the two parts of the IPv4 address values. */
2714 len
= ui2ipv4(uri
->canon_uri
+uri
->canon_len
, val
);
2716 len
= ui2ipv4(NULL
, val
);
2718 uri
->canon_len
+= len
;
2721 /* Write a regular h16 component to the URI. */
2723 /* Short circuit for the trivial case. */
2724 if(values
[i
] == 0) {
2726 uri
->canon_uri
[uri
->canon_len
] = '0';
2729 static const WCHAR formatW
[] = {'%','x',0};
2732 uri
->canon_len
+= sprintfW(uri
->canon_uri
+uri
->canon_len
,
2733 formatW
, values
[i
]);
2736 uri
->canon_len
+= sprintfW(tmp
, formatW
, values
[i
]);
2742 /* Add the closing ']'. */
2744 uri
->canon_uri
[uri
->canon_len
] = ']';
2748 uri
->host_len
= uri
->canon_len
- uri
->host_start
;
2751 TRACE("(%p %p %x %d): Canonicalized IPv6 address %s, len=%d\n", data
, uri
, flags
,
2752 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->host_start
, uri
->host_len
),
2758 /* Attempts to canonicalize the host of the URI (if any). */
2759 static BOOL
canonicalize_host(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2760 uri
->host_start
= -1;
2762 uri
->domain_offset
= -1;
2765 switch(data
->host_type
) {
2767 uri
->host_type
= Uri_HOST_DNS
;
2768 if(!canonicalize_reg_name(data
, uri
, flags
, computeOnly
))
2773 uri
->host_type
= Uri_HOST_IPV4
;
2774 if(!canonicalize_ipv4address(data
, uri
, flags
, computeOnly
))
2779 if(!canonicalize_ipv6address(data
, uri
, flags
, computeOnly
))
2782 uri
->host_type
= Uri_HOST_IPV6
;
2784 case Uri_HOST_UNKNOWN
:
2785 if(data
->host_len
> 0 || data
->scheme_type
!= URL_SCHEME_FILE
) {
2786 uri
->host_start
= uri
->canon_len
;
2788 /* Nothing happens to unknown host types. */
2790 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->host
, data
->host_len
*sizeof(WCHAR
));
2791 uri
->canon_len
+= data
->host_len
;
2792 uri
->host_len
= data
->host_len
;
2795 uri
->host_type
= Uri_HOST_UNKNOWN
;
2798 FIXME("(%p %p %x %d): Canonicalization for host type %d not supported.\n", data
,
2799 uri
, flags
, computeOnly
, data
->host_type
);
2807 static BOOL
canonicalize_port(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2808 BOOL has_default_port
= FALSE
;
2809 USHORT default_port
= 0;
2812 uri
->port_offset
= -1;
2814 /* Check if the scheme has a default port. */
2815 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
2816 if(default_ports
[i
].scheme
== data
->scheme_type
) {
2817 has_default_port
= TRUE
;
2818 default_port
= default_ports
[i
].port
;
2823 uri
->has_port
= data
->has_port
|| has_default_port
;
2826 * 1) Has a port which is the default port.
2827 * 2) Has a port (not the default).
2828 * 3) Doesn't have a port, but, scheme has a default port.
2831 if(has_default_port
&& data
->has_port
&& data
->port_value
== default_port
) {
2832 /* If it's the default port and this flag isn't set, don't do anything. */
2833 if(flags
& Uri_CREATE_NO_CANONICALIZE
) {
2834 uri
->port_offset
= uri
->canon_len
-uri
->authority_start
;
2836 uri
->canon_uri
[uri
->canon_len
] = ':';
2840 /* Copy the original port over. */
2842 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->port
, data
->port_len
*sizeof(WCHAR
));
2843 uri
->canon_len
+= data
->port_len
;
2846 uri
->canon_len
+= ui2str(uri
->canon_uri
+uri
->canon_len
, data
->port_value
);
2848 uri
->canon_len
+= ui2str(NULL
, data
->port_value
);
2852 uri
->port
= default_port
;
2853 } else if(data
->has_port
) {
2854 uri
->port_offset
= uri
->canon_len
-uri
->authority_start
;
2856 uri
->canon_uri
[uri
->canon_len
] = ':';
2859 if(flags
& Uri_CREATE_NO_CANONICALIZE
&& data
->port
) {
2860 /* Copy the original over without changes. */
2862 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->port
, data
->port_len
*sizeof(WCHAR
));
2863 uri
->canon_len
+= data
->port_len
;
2866 uri
->canon_len
+= ui2str(uri
->canon_uri
+uri
->canon_len
, data
->port_value
);
2868 uri
->canon_len
+= ui2str(NULL
, data
->port_value
);
2871 uri
->port
= data
->port_value
;
2872 } else if(has_default_port
)
2873 uri
->port
= default_port
;
2878 /* Canonicalizes the authority of the URI represented by the parse_data. */
2879 static BOOL
canonicalize_authority(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
2880 uri
->authority_start
= uri
->canon_len
;
2881 uri
->authority_len
= 0;
2883 if(!canonicalize_userinfo(data
, uri
, flags
, computeOnly
))
2886 if(!canonicalize_host(data
, uri
, flags
, computeOnly
))
2889 if(!canonicalize_port(data
, uri
, flags
, computeOnly
))
2892 if(uri
->host_start
!= -1 || (data
->is_relative
&& (data
->password
|| data
->username
)))
2893 uri
->authority_len
= uri
->canon_len
- uri
->authority_start
;
2895 uri
->authority_start
= -1;
2900 /* Attempts to canonicalize the path of a hierarchical URI.
2902 * Things that happen:
2903 * 1). Forbidden characters are percent encoded, unless the NO_ENCODE_FORBIDDEN
2904 * flag is set or it's a file URI. Forbidden characters are always encoded
2905 * for file schemes regardless and forbidden characters are never encoded
2906 * for unknown scheme types.
2908 * 2). For known scheme types '\\' are changed to '/'.
2910 * 3). Percent encoded, unreserved characters are decoded to their actual values.
2911 * Unless the scheme type is unknown. For file schemes any percent encoded
2912 * character in the unreserved or reserved set is decoded.
2914 * 4). For File schemes if the path is starts with a drive letter and doesn't
2915 * start with a '/' then one is appended.
2916 * Ex: file://c:/test.mp3 -> file:///c:/test.mp3
2918 * 5). Dot segments are removed from the path for all scheme types
2919 * unless NO_CANONICALIZE flag is set. Dot segments aren't removed
2920 * for wildcard scheme types.
2923 * file://c:/test%20test -> file:///c:/test%2520test
2924 * file://c:/test%3Etest -> file:///c:/test%253Etest
2925 * if Uri_CREATE_FILE_USE_DOS_PATH is not set:
2926 * file:///c:/test%20test -> file:///c:/test%20test
2927 * file:///c:/test%test -> file:///c:/test%25test
2929 static BOOL
canonicalize_path_hierarchical(const parse_data
*data
, Uri
*uri
,
2930 DWORD flags
, BOOL computeOnly
) {
2932 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
2933 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
2934 const BOOL is_res
= data
->scheme_type
== URL_SCHEME_RES
;
2936 BOOL escape_pct
= FALSE
;
2939 uri
->path_start
= -1;
2944 uri
->path_start
= uri
->canon_len
;
2947 if(is_file
&& uri
->host_start
== -1) {
2948 /* Check if a '/' needs to be appended for the file scheme. */
2949 if(data
->path_len
> 1 && is_drive_path(ptr
) && !(flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
2951 uri
->canon_uri
[uri
->canon_len
] = '/';
2954 } else if(*ptr
== '/') {
2955 if(!(flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
2956 /* Copy the extra '/' over. */
2958 uri
->canon_uri
[uri
->canon_len
] = '/';
2964 if(is_drive_path(ptr
)) {
2966 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
2967 /* If there's a '|' after the drive letter, convert it to a ':'. */
2968 uri
->canon_uri
[uri
->canon_len
+1] = ':';
2971 uri
->canon_len
+= 2;
2975 if(!is_file
&& *(data
->path
) && *(data
->path
) != '/') {
2976 /* Prepend a '/' to the path if it doesn't have one. */
2978 uri
->canon_uri
[uri
->canon_len
] = '/';
2982 for(; ptr
< data
->path
+data
->path_len
; ++ptr
) {
2983 BOOL do_default_action
= TRUE
;
2985 if(*ptr
== '%' && !is_res
) {
2986 const WCHAR
*tmp
= ptr
;
2989 /* Check if the % represents a valid encoded char, or if it needs encoding. */
2990 BOOL force_encode
= !check_pct_encoded(&tmp
) && is_file
&& !(flags
&Uri_CREATE_FILE_USE_DOS_PATH
);
2991 val
= decode_pct_val(ptr
);
2993 if(force_encode
|| escape_pct
) {
2994 /* Escape the percent sign in the file URI. */
2996 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
2997 uri
->canon_len
+= 3;
2998 do_default_action
= FALSE
;
2999 } else if((is_unreserved(val
) && known_scheme
) ||
3000 (is_file
&& (is_unreserved(val
) || is_reserved(val
) ||
3001 (val
&& flags
&Uri_CREATE_FILE_USE_DOS_PATH
&& !is_forbidden_dos_path_char(val
))))) {
3003 uri
->canon_uri
[uri
->canon_len
] = val
;
3009 } else if(*ptr
== '/' && is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
3010 /* Convert the '/' back to a '\\'. */
3012 uri
->canon_uri
[uri
->canon_len
] = '\\';
3014 do_default_action
= FALSE
;
3015 } else if(*ptr
== '\\' && known_scheme
) {
3016 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
))) {
3017 /* Convert '\\' into a '/'. */
3019 uri
->canon_uri
[uri
->canon_len
] = '/';
3021 do_default_action
= FALSE
;
3023 } else if(known_scheme
&& !is_res
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
) &&
3024 (!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) || is_file
)) {
3025 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
))) {
3026 /* Escape the forbidden character. */
3028 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3029 uri
->canon_len
+= 3;
3030 do_default_action
= FALSE
;
3034 if(do_default_action
) {
3036 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3041 uri
->path_len
= uri
->canon_len
- uri
->path_start
;
3043 /* Removing the dot segments only happens when it's not in
3044 * computeOnly mode and it's not a wildcard scheme. File schemes
3045 * with USE_DOS_PATH set don't get dot segments removed.
3047 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) &&
3048 data
->scheme_type
!= URL_SCHEME_WILDCARD
) {
3049 if(!(flags
& Uri_CREATE_NO_CANONICALIZE
) && !computeOnly
) {
3050 /* Remove the dot segments (if any) and reset everything to the new
3053 DWORD new_len
= remove_dot_segments(uri
->canon_uri
+uri
->path_start
, uri
->path_len
);
3054 uri
->canon_len
-= uri
->path_len
-new_len
;
3055 uri
->path_len
= new_len
;
3060 TRACE("Canonicalized path %s len=%d\n",
3061 debugstr_wn(uri
->canon_uri
+uri
->path_start
, uri
->path_len
),
3067 /* Attempts to canonicalize the path for an opaque URI.
3069 * For known scheme types:
3070 * 1) forbidden characters are percent encoded if
3071 * NO_ENCODE_FORBIDDEN_CHARACTERS isn't set.
3073 * 2) Percent encoded, unreserved characters are decoded
3074 * to their actual values, for known scheme types.
3076 * 3) '\\' are changed to '/' for known scheme types
3077 * except for mailto schemes.
3079 * 4) For file schemes, if USE_DOS_PATH is set all '/'
3080 * are converted to backslashes.
3082 * 5) For file schemes, if USE_DOS_PATH isn't set all '\'
3083 * are converted to forward slashes.
3085 static BOOL
canonicalize_path_opaque(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3087 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
3088 const BOOL is_file
= data
->scheme_type
== URL_SCHEME_FILE
;
3089 const BOOL is_mk
= data
->scheme_type
== URL_SCHEME_MK
;
3092 uri
->path_start
= -1;
3097 uri
->path_start
= uri
->canon_len
;
3100 /* hijack this flag for SCHEME_MK to tell the function when to start
3101 * converting slashes */
3102 flags
|= Uri_CREATE_FILE_USE_DOS_PATH
;
3105 /* For javascript: URIs, simply copy path part without any canonicalization */
3106 if(data
->scheme_type
== URL_SCHEME_JAVASCRIPT
) {
3108 memcpy(uri
->canon_uri
+uri
->canon_len
, data
->path
, data
->path_len
*sizeof(WCHAR
));
3109 uri
->path_len
= data
->path_len
;
3110 uri
->canon_len
+= data
->path_len
;
3114 /* Windows doesn't allow a "//" to appear after the scheme
3115 * of a URI, if it's an opaque URI.
3117 if(data
->scheme
&& *(data
->path
) == '/' && *(data
->path
+1) == '/') {
3118 /* So it inserts a "/." before the "//" if it exists. */
3120 uri
->canon_uri
[uri
->canon_len
] = '/';
3121 uri
->canon_uri
[uri
->canon_len
+1] = '.';
3124 uri
->canon_len
+= 2;
3127 for(ptr
= data
->path
; ptr
< data
->path
+data
->path_len
; ++ptr
) {
3128 BOOL do_default_action
= TRUE
;
3130 if(*ptr
== '%' && known_scheme
) {
3131 WCHAR val
= decode_pct_val(ptr
);
3133 if(is_unreserved(val
)) {
3135 uri
->canon_uri
[uri
->canon_len
] = val
;
3141 } else if(*ptr
== '/' && is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
3143 uri
->canon_uri
[uri
->canon_len
] = '\\';
3145 do_default_action
= FALSE
;
3146 } else if(*ptr
== '\\') {
3147 if((data
->is_relative
|| is_mk
|| is_file
) && !(flags
& Uri_CREATE_FILE_USE_DOS_PATH
)) {
3148 /* Convert to a '/'. */
3150 uri
->canon_uri
[uri
->canon_len
] = '/';
3152 do_default_action
= FALSE
;
3154 } else if(is_mk
&& *ptr
== ':' && ptr
+ 1 < data
->path
+ data
->path_len
&& *(ptr
+ 1) == ':') {
3155 flags
&= ~Uri_CREATE_FILE_USE_DOS_PATH
;
3156 } else if(known_scheme
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
) &&
3157 !(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
)) {
3158 if(!(is_file
&& (flags
& Uri_CREATE_FILE_USE_DOS_PATH
))) {
3160 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3161 uri
->canon_len
+= 3;
3162 do_default_action
= FALSE
;
3166 if(do_default_action
) {
3168 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3173 if(is_mk
&& !computeOnly
&& !(flags
& Uri_CREATE_NO_CANONICALIZE
)) {
3174 DWORD new_len
= remove_dot_segments(uri
->canon_uri
+ uri
->path_start
,
3175 uri
->canon_len
- uri
->path_start
);
3176 uri
->canon_len
= uri
->path_start
+ new_len
;
3179 uri
->path_len
= uri
->canon_len
- uri
->path_start
;
3182 TRACE("(%p %p %x %d): Canonicalized opaque URI path %s len=%d\n", data
, uri
, flags
, computeOnly
,
3183 debugstr_wn(uri
->canon_uri
+uri
->path_start
, uri
->path_len
), uri
->path_len
);
3187 /* Determines how the URI represented by the parse_data should be canonicalized.
3189 * Essentially, if the parse_data represents an hierarchical URI then it calls
3190 * canonicalize_authority and the canonicalization functions for the path. If the
3191 * URI is opaque it canonicalizes the path of the URI.
3193 static BOOL
canonicalize_hierpart(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3194 if(!data
->is_opaque
|| (data
->is_relative
&& (data
->password
|| data
->username
))) {
3195 /* "//" is only added for non-wildcard scheme types.
3197 * A "//" is only added to a relative URI if it has a
3198 * host or port component (this only happens if a IUriBuilder
3199 * is generating an IUri).
3201 if((data
->is_relative
&& (data
->host
|| data
->has_port
)) ||
3202 (!data
->is_relative
&& data
->scheme_type
!= URL_SCHEME_WILDCARD
)) {
3203 if(data
->scheme_type
== URL_SCHEME_WILDCARD
)
3207 INT pos
= uri
->canon_len
;
3209 uri
->canon_uri
[pos
] = '/';
3210 uri
->canon_uri
[pos
+1] = '/';
3212 uri
->canon_len
+= 2;
3215 if(!canonicalize_authority(data
, uri
, flags
, computeOnly
))
3218 if(data
->is_relative
&& (data
->password
|| data
->username
)) {
3219 if(!canonicalize_path_opaque(data
, uri
, flags
, computeOnly
))
3222 if(!canonicalize_path_hierarchical(data
, uri
, flags
, computeOnly
))
3226 /* Opaque URI's don't have an authority. */
3227 uri
->userinfo_start
= uri
->userinfo_split
= -1;
3228 uri
->userinfo_len
= 0;
3229 uri
->host_start
= -1;
3231 uri
->host_type
= Uri_HOST_UNKNOWN
;
3232 uri
->has_port
= FALSE
;
3233 uri
->authority_start
= -1;
3234 uri
->authority_len
= 0;
3235 uri
->domain_offset
= -1;
3236 uri
->port_offset
= -1;
3238 if(is_hierarchical_scheme(data
->scheme_type
)) {
3241 /* Absolute URIs aren't displayed for known scheme types
3242 * which should be hierarchical URIs.
3244 uri
->display_modifiers
|= URI_DISPLAY_NO_ABSOLUTE_URI
;
3246 /* Windows also sets the port for these (if they have one). */
3247 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
3248 if(data
->scheme_type
== default_ports
[i
].scheme
) {
3249 uri
->has_port
= TRUE
;
3250 uri
->port
= default_ports
[i
].port
;
3256 if(!canonicalize_path_opaque(data
, uri
, flags
, computeOnly
))
3260 if(uri
->path_start
> -1 && !computeOnly
)
3261 /* Finding file extensions happens for both types of URIs. */
3262 uri
->extension_offset
= find_file_extension(uri
->canon_uri
+uri
->path_start
, uri
->path_len
);
3264 uri
->extension_offset
= -1;
3269 /* Attempts to canonicalize the query string of the URI.
3271 * Things that happen:
3272 * 1) For known scheme types forbidden characters
3273 * are percent encoded, unless the NO_DECODE_EXTRA_INFO flag is set
3274 * or NO_ENCODE_FORBIDDEN_CHARACTERS is set.
3276 * 2) For known scheme types, percent encoded, unreserved characters
3277 * are decoded as long as the NO_DECODE_EXTRA_INFO flag isn't set.
3279 static BOOL
canonicalize_query(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3280 const WCHAR
*ptr
, *end
;
3281 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
3284 uri
->query_start
= -1;
3289 uri
->query_start
= uri
->canon_len
;
3291 end
= data
->query
+data
->query_len
;
3292 for(ptr
= data
->query
; ptr
< end
; ++ptr
) {
3294 if(known_scheme
&& !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3295 WCHAR val
= decode_pct_val(ptr
);
3296 if(is_unreserved(val
)) {
3298 uri
->canon_uri
[uri
->canon_len
] = val
;
3305 } else if(known_scheme
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
)) {
3306 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) &&
3307 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3309 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3310 uri
->canon_len
+= 3;
3316 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3320 uri
->query_len
= uri
->canon_len
- uri
->query_start
;
3323 TRACE("(%p %p %x %d): Canonicalized query string %s len=%d\n", data
, uri
, flags
,
3324 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->query_start
, uri
->query_len
),
3329 static BOOL
canonicalize_fragment(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3330 const WCHAR
*ptr
, *end
;
3331 const BOOL known_scheme
= data
->scheme_type
!= URL_SCHEME_UNKNOWN
;
3333 if(!data
->fragment
) {
3334 uri
->fragment_start
= -1;
3335 uri
->fragment_len
= 0;
3339 uri
->fragment_start
= uri
->canon_len
;
3341 end
= data
->fragment
+ data
->fragment_len
;
3342 for(ptr
= data
->fragment
; ptr
< end
; ++ptr
) {
3344 if(known_scheme
&& !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3345 WCHAR val
= decode_pct_val(ptr
);
3346 if(is_unreserved(val
)) {
3348 uri
->canon_uri
[uri
->canon_len
] = val
;
3355 } else if(known_scheme
&& !is_unreserved(*ptr
) && !is_reserved(*ptr
)) {
3356 if(!(flags
& Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
) &&
3357 !(flags
& Uri_CREATE_NO_DECODE_EXTRA_INFO
)) {
3359 pct_encode_val(*ptr
, uri
->canon_uri
+uri
->canon_len
);
3360 uri
->canon_len
+= 3;
3366 uri
->canon_uri
[uri
->canon_len
] = *ptr
;
3370 uri
->fragment_len
= uri
->canon_len
- uri
->fragment_start
;
3373 TRACE("(%p %p %x %d): Canonicalized fragment %s len=%d\n", data
, uri
, flags
,
3374 computeOnly
, debugstr_wn(uri
->canon_uri
+uri
->fragment_start
, uri
->fragment_len
),
3379 /* Canonicalizes the scheme information specified in the parse_data using the specified flags. */
3380 static BOOL
canonicalize_scheme(const parse_data
*data
, Uri
*uri
, DWORD flags
, BOOL computeOnly
) {
3381 uri
->scheme_start
= -1;
3382 uri
->scheme_len
= 0;
3385 /* The only type of URI that doesn't have to have a scheme is a relative
3388 if(!data
->is_relative
) {
3389 FIXME("(%p %p %x): Unable to determine the scheme type of %s.\n", data
,
3390 uri
, flags
, debugstr_w(data
->uri
));
3396 INT pos
= uri
->canon_len
;
3398 for(i
= 0; i
< data
->scheme_len
; ++i
) {
3399 /* Scheme name must be lower case after canonicalization. */
3400 uri
->canon_uri
[i
+ pos
] = tolowerW(data
->scheme
[i
]);
3403 uri
->canon_uri
[i
+ pos
] = ':';
3404 uri
->scheme_start
= pos
;
3406 TRACE("(%p %p %x): Canonicalized scheme=%s, len=%d.\n", data
, uri
, flags
,
3407 debugstr_wn(uri
->canon_uri
, uri
->scheme_len
), data
->scheme_len
);
3410 /* This happens in both computation modes. */
3411 uri
->canon_len
+= data
->scheme_len
+ 1;
3412 uri
->scheme_len
= data
->scheme_len
;
3417 /* Computes what the length of the URI specified by the parse_data will be
3418 * after canonicalization occurs using the specified flags.
3420 * This function will return a non-zero value indicating the length of the canonicalized
3421 * URI, or -1 on error.
3423 static int compute_canonicalized_length(const parse_data
*data
, DWORD flags
) {
3426 memset(&uri
, 0, sizeof(Uri
));
3428 TRACE("(%p %x): Beginning to compute canonicalized length for URI %s\n", data
, flags
,
3429 debugstr_w(data
->uri
));
3431 if(!canonicalize_scheme(data
, &uri
, flags
, TRUE
)) {
3432 ERR("(%p %x): Failed to compute URI scheme length.\n", data
, flags
);
3436 if(!canonicalize_hierpart(data
, &uri
, flags
, TRUE
)) {
3437 ERR("(%p %x): Failed to compute URI hierpart length.\n", data
, flags
);
3441 if(!canonicalize_query(data
, &uri
, flags
, TRUE
)) {
3442 ERR("(%p %x): Failed to compute query string length.\n", data
, flags
);
3446 if(!canonicalize_fragment(data
, &uri
, flags
, TRUE
)) {
3447 ERR("(%p %x): Failed to compute fragment length.\n", data
, flags
);
3451 TRACE("(%p %x): Finished computing canonicalized URI length. length=%d\n", data
, flags
, uri
.canon_len
);
3453 return uri
.canon_len
;
3456 /* Canonicalizes the URI data specified in the parse_data, using the given flags. If the
3457 * canonicalization succeeds it will store all the canonicalization information
3458 * in the pointer to the Uri.
3460 * To canonicalize a URI this function first computes what the length of the URI
3461 * specified by the parse_data will be. Once this is done it will then perform the actual
3462 * canonicalization of the URI.
3464 static HRESULT
canonicalize_uri(const parse_data
*data
, Uri
*uri
, DWORD flags
) {
3467 uri
->canon_uri
= NULL
;
3468 uri
->canon_size
= uri
->canon_len
= 0;
3470 TRACE("(%p %p %x): beginning to canonicalize URI %s.\n", data
, uri
, flags
, debugstr_w(data
->uri
));
3472 /* First try to compute the length of the URI. */
3473 len
= compute_canonicalized_length(data
, flags
);
3475 ERR("(%p %p %x): Could not compute the canonicalized length of %s.\n", data
, uri
, flags
,
3476 debugstr_w(data
->uri
));
3477 return E_INVALIDARG
;
3480 uri
->canon_uri
= heap_alloc((len
+1)*sizeof(WCHAR
));
3482 return E_OUTOFMEMORY
;
3484 uri
->canon_size
= len
;
3485 if(!canonicalize_scheme(data
, uri
, flags
, FALSE
)) {
3486 ERR("(%p %p %x): Unable to canonicalize the scheme of the URI.\n", data
, uri
, flags
);
3487 return E_INVALIDARG
;
3489 uri
->scheme_type
= data
->scheme_type
;
3491 if(!canonicalize_hierpart(data
, uri
, flags
, FALSE
)) {
3492 ERR("(%p %p %x): Unable to canonicalize the heirpart of the URI\n", data
, uri
, flags
);
3493 return E_INVALIDARG
;
3496 if(!canonicalize_query(data
, uri
, flags
, FALSE
)) {
3497 ERR("(%p %p %x): Unable to canonicalize query string of the URI.\n",
3499 return E_INVALIDARG
;
3502 if(!canonicalize_fragment(data
, uri
, flags
, FALSE
)) {
3503 ERR("(%p %p %x): Unable to canonicalize fragment of the URI.\n",
3505 return E_INVALIDARG
;
3508 /* There's a possibility we didn't use all the space we allocated
3511 if(uri
->canon_len
< uri
->canon_size
) {
3512 /* This happens if the URI is hierarchical and dot
3513 * segments were removed from its path.
3515 WCHAR
*tmp
= heap_realloc(uri
->canon_uri
, (uri
->canon_len
+1)*sizeof(WCHAR
));
3517 return E_OUTOFMEMORY
;
3519 uri
->canon_uri
= tmp
;
3520 uri
->canon_size
= uri
->canon_len
;
3523 uri
->canon_uri
[uri
->canon_len
] = '\0';
3524 TRACE("(%p %p %x): finished canonicalizing the URI. uri=%s\n", data
, uri
, flags
, debugstr_w(uri
->canon_uri
));
3529 static HRESULT
get_builder_component(LPWSTR
*component
, DWORD
*component_len
,
3530 LPCWSTR source
, DWORD source_len
,
3531 LPCWSTR
*output
, DWORD
*output_len
)
3544 if(!(*component
) && source
) {
3545 /* Allocate 'component', and copy the contents from 'source'
3546 * into the new allocation.
3548 *component
= heap_alloc((source_len
+1)*sizeof(WCHAR
));
3550 return E_OUTOFMEMORY
;
3552 memcpy(*component
, source
, source_len
*sizeof(WCHAR
));
3553 (*component
)[source_len
] = '\0';
3554 *component_len
= source_len
;
3557 *output
= *component
;
3558 *output_len
= *component_len
;
3559 return *output
? S_OK
: S_FALSE
;
3562 /* Allocates 'component' and copies the string from 'new_value' into 'component'.
3563 * If 'prefix' is set and 'new_value' isn't NULL, then it checks if 'new_value'
3564 * starts with 'prefix'. If it doesn't then 'prefix' is prepended to 'component'.
3566 * If everything is successful, then will set 'success_flag' in 'flags'.
3568 static HRESULT
set_builder_component(LPWSTR
*component
, DWORD
*component_len
, LPCWSTR new_value
,
3569 WCHAR prefix
, DWORD
*flags
, DWORD success_flag
)
3571 heap_free(*component
);
3577 BOOL add_prefix
= FALSE
;
3578 DWORD len
= lstrlenW(new_value
);
3581 if(prefix
&& *new_value
!= prefix
) {
3583 *component
= heap_alloc((len
+2)*sizeof(WCHAR
));
3585 *component
= heap_alloc((len
+1)*sizeof(WCHAR
));
3588 return E_OUTOFMEMORY
;
3591 (*component
)[pos
++] = prefix
;
3593 memcpy(*component
+pos
, new_value
, (len
+1)*sizeof(WCHAR
));
3594 *component_len
= len
+pos
;
3597 *flags
|= success_flag
;
3601 static void reset_builder(UriBuilder
*builder
) {
3603 IUri_Release(&builder
->uri
->IUri_iface
);
3604 builder
->uri
= NULL
;
3606 heap_free(builder
->fragment
);
3607 builder
->fragment
= NULL
;
3608 builder
->fragment_len
= 0;
3610 heap_free(builder
->host
);
3611 builder
->host
= NULL
;
3612 builder
->host_len
= 0;
3614 heap_free(builder
->password
);
3615 builder
->password
= NULL
;
3616 builder
->password_len
= 0;
3618 heap_free(builder
->path
);
3619 builder
->path
= NULL
;
3620 builder
->path_len
= 0;
3622 heap_free(builder
->query
);
3623 builder
->query
= NULL
;
3624 builder
->query_len
= 0;
3626 heap_free(builder
->scheme
);
3627 builder
->scheme
= NULL
;
3628 builder
->scheme_len
= 0;
3630 heap_free(builder
->username
);
3631 builder
->username
= NULL
;
3632 builder
->username_len
= 0;
3634 builder
->has_port
= FALSE
;
3636 builder
->modified_props
= 0;
3639 static HRESULT
validate_scheme_name(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3640 const WCHAR
*component
;
3645 if(builder
->scheme
) {
3646 ptr
= builder
->scheme
;
3647 expected_len
= builder
->scheme_len
;
3648 } else if(builder
->uri
&& builder
->uri
->scheme_start
> -1) {
3649 ptr
= builder
->uri
->canon_uri
+builder
->uri
->scheme_start
;
3650 expected_len
= builder
->uri
->scheme_len
;
3652 static const WCHAR nullW
[] = {0};
3659 if(parse_scheme(pptr
, data
, flags
, ALLOW_NULL_TERM_SCHEME
) &&
3660 data
->scheme_len
== expected_len
) {
3662 TRACE("(%p %p %x): Found valid scheme component %s len=%d.\n", builder
, data
, flags
,
3663 debugstr_wn(data
->scheme
, data
->scheme_len
), data
->scheme_len
);
3665 TRACE("(%p %p %x): Invalid scheme component found %s.\n", builder
, data
, flags
,
3666 debugstr_wn(component
, expected_len
));
3667 return INET_E_INVALID_URL
;
3673 static HRESULT
validate_username(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3678 if(builder
->username
) {
3679 ptr
= builder
->username
;
3680 expected_len
= builder
->username_len
;
3681 } else if(!(builder
->modified_props
& Uri_HAS_USER_NAME
) && builder
->uri
&&
3682 builder
->uri
->userinfo_start
> -1 && builder
->uri
->userinfo_split
!= 0) {
3683 /* Just use the username from the base Uri. */
3684 data
->username
= builder
->uri
->canon_uri
+builder
->uri
->userinfo_start
;
3685 data
->username_len
= (builder
->uri
->userinfo_split
> -1) ?
3686 builder
->uri
->userinfo_split
: builder
->uri
->userinfo_len
;
3694 const WCHAR
*component
= ptr
;
3696 if(parse_username(pptr
, data
, flags
, ALLOW_NULL_TERM_USER_NAME
) &&
3697 data
->username_len
== expected_len
)
3698 TRACE("(%p %p %x): Found valid username component %s len=%d.\n", builder
, data
, flags
,
3699 debugstr_wn(data
->username
, data
->username_len
), data
->username_len
);
3701 TRACE("(%p %p %x): Invalid username component found %s.\n", builder
, data
, flags
,
3702 debugstr_wn(component
, expected_len
));
3703 return INET_E_INVALID_URL
;
3710 static HRESULT
validate_password(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3715 if(builder
->password
) {
3716 ptr
= builder
->password
;
3717 expected_len
= builder
->password_len
;
3718 } else if(!(builder
->modified_props
& Uri_HAS_PASSWORD
) && builder
->uri
&&
3719 builder
->uri
->userinfo_split
> -1) {
3720 data
->password
= builder
->uri
->canon_uri
+builder
->uri
->userinfo_start
+builder
->uri
->userinfo_split
+1;
3721 data
->password_len
= builder
->uri
->userinfo_len
-builder
->uri
->userinfo_split
-1;
3729 const WCHAR
*component
= ptr
;
3731 if(parse_password(pptr
, data
, flags
, ALLOW_NULL_TERM_PASSWORD
) &&
3732 data
->password_len
== expected_len
)
3733 TRACE("(%p %p %x): Found valid password component %s len=%d.\n", builder
, data
, flags
,
3734 debugstr_wn(data
->password
, data
->password_len
), data
->password_len
);
3736 TRACE("(%p %p %x): Invalid password component found %s.\n", builder
, data
, flags
,
3737 debugstr_wn(component
, expected_len
));
3738 return INET_E_INVALID_URL
;
3745 static HRESULT
validate_userinfo(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3748 hr
= validate_username(builder
, data
, flags
);
3752 hr
= validate_password(builder
, data
, flags
);
3759 static HRESULT
validate_host(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3765 ptr
= builder
->host
;
3766 expected_len
= builder
->host_len
;
3767 } else if(!(builder
->modified_props
& Uri_HAS_HOST
) && builder
->uri
&& builder
->uri
->host_start
> -1) {
3768 ptr
= builder
->uri
->canon_uri
+ builder
->uri
->host_start
;
3769 expected_len
= builder
->uri
->host_len
;
3774 const WCHAR
*component
= ptr
;
3775 DWORD extras
= ALLOW_BRACKETLESS_IP_LITERAL
|IGNORE_PORT_DELIMITER
|SKIP_IP_FUTURE_CHECK
;
3778 if(parse_host(pptr
, data
, flags
, extras
) && data
->host_len
== expected_len
)
3779 TRACE("(%p %p %x): Found valid host name %s len=%d type=%d.\n", builder
, data
, flags
,
3780 debugstr_wn(data
->host
, data
->host_len
), data
->host_len
, data
->host_type
);
3782 TRACE("(%p %p %x): Invalid host name found %s.\n", builder
, data
, flags
,
3783 debugstr_wn(component
, expected_len
));
3784 return INET_E_INVALID_URL
;
3791 static void setup_port(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3792 if(builder
->modified_props
& Uri_HAS_PORT
) {
3793 if(builder
->has_port
) {
3794 data
->has_port
= TRUE
;
3795 data
->port_value
= builder
->port
;
3797 } else if(builder
->uri
&& builder
->uri
->has_port
) {
3798 data
->has_port
= TRUE
;
3799 data
->port_value
= builder
->uri
->port
;
3803 TRACE("(%p %p %x): Using %u as port for IUri.\n", builder
, data
, flags
, data
->port_value
);
3806 static HRESULT
validate_path(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3807 const WCHAR
*ptr
= NULL
;
3808 const WCHAR
*component
;
3811 BOOL check_len
= TRUE
;
3815 ptr
= builder
->path
;
3816 expected_len
= builder
->path_len
;
3817 } else if(!(builder
->modified_props
& Uri_HAS_PATH
) &&
3818 builder
->uri
&& builder
->uri
->path_start
> -1) {
3819 ptr
= builder
->uri
->canon_uri
+builder
->uri
->path_start
;
3820 expected_len
= builder
->uri
->path_len
;
3822 static const WCHAR nullW
[] = {0};
3831 /* How the path is validated depends on what type of
3834 valid
= data
->is_opaque
?
3835 parse_path_opaque(pptr
, data
, flags
) : parse_path_hierarchical(pptr
, data
, flags
);
3837 if(!valid
|| (check_len
&& expected_len
!= data
->path_len
)) {
3838 TRACE("(%p %p %x): Invalid path component %s.\n", builder
, data
, flags
,
3839 debugstr_wn(component
, expected_len
) );
3840 return INET_E_INVALID_URL
;
3843 TRACE("(%p %p %x): Valid path component %s len=%d.\n", builder
, data
, flags
,
3844 debugstr_wn(data
->path
, data
->path_len
), data
->path_len
);
3849 static HRESULT
validate_query(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3850 const WCHAR
*ptr
= NULL
;
3854 if(builder
->query
) {
3855 ptr
= builder
->query
;
3856 expected_len
= builder
->query_len
;
3857 } else if(!(builder
->modified_props
& Uri_HAS_QUERY
) && builder
->uri
&&
3858 builder
->uri
->query_start
> -1) {
3859 ptr
= builder
->uri
->canon_uri
+builder
->uri
->query_start
;
3860 expected_len
= builder
->uri
->query_len
;
3864 const WCHAR
*component
= ptr
;
3867 if(parse_query(pptr
, data
, flags
) && expected_len
== data
->query_len
)
3868 TRACE("(%p %p %x): Valid query component %s len=%d.\n", builder
, data
, flags
,
3869 debugstr_wn(data
->query
, data
->query_len
), data
->query_len
);
3871 TRACE("(%p %p %x): Invalid query component %s.\n", builder
, data
, flags
,
3872 debugstr_wn(component
, expected_len
));
3873 return INET_E_INVALID_URL
;
3880 static HRESULT
validate_fragment(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3881 const WCHAR
*ptr
= NULL
;
3885 if(builder
->fragment
) {
3886 ptr
= builder
->fragment
;
3887 expected_len
= builder
->fragment_len
;
3888 } else if(!(builder
->modified_props
& Uri_HAS_FRAGMENT
) && builder
->uri
&&
3889 builder
->uri
->fragment_start
> -1) {
3890 ptr
= builder
->uri
->canon_uri
+builder
->uri
->fragment_start
;
3891 expected_len
= builder
->uri
->fragment_len
;
3895 const WCHAR
*component
= ptr
;
3898 if(parse_fragment(pptr
, data
, flags
) && expected_len
== data
->fragment_len
)
3899 TRACE("(%p %p %x): Valid fragment component %s len=%d.\n", builder
, data
, flags
,
3900 debugstr_wn(data
->fragment
, data
->fragment_len
), data
->fragment_len
);
3902 TRACE("(%p %p %x): Invalid fragment component %s.\n", builder
, data
, flags
,
3903 debugstr_wn(component
, expected_len
));
3904 return INET_E_INVALID_URL
;
3911 static HRESULT
validate_components(const UriBuilder
*builder
, parse_data
*data
, DWORD flags
) {
3914 memset(data
, 0, sizeof(parse_data
));
3916 TRACE("(%p %p %x): Beginning to validate builder components.\n", builder
, data
, flags
);
3918 hr
= validate_scheme_name(builder
, data
, flags
);
3922 /* Extra validation for file schemes. */
3923 if(data
->scheme_type
== URL_SCHEME_FILE
) {
3924 if((builder
->password
|| (builder
->uri
&& builder
->uri
->userinfo_split
> -1)) ||
3925 (builder
->username
|| (builder
->uri
&& builder
->uri
->userinfo_start
> -1))) {
3926 TRACE("(%p %p %x): File schemes can't contain a username or password.\n",
3927 builder
, data
, flags
);
3928 return INET_E_INVALID_URL
;
3932 hr
= validate_userinfo(builder
, data
, flags
);
3936 hr
= validate_host(builder
, data
, flags
);
3940 setup_port(builder
, data
, flags
);
3942 /* The URI is opaque if it doesn't have an authority component. */
3943 if(!data
->is_relative
)
3944 data
->is_opaque
= !data
->username
&& !data
->password
&& !data
->host
&& !data
->has_port
;
3946 data
->is_opaque
= !data
->host
&& !data
->has_port
;
3948 hr
= validate_path(builder
, data
, flags
);
3952 hr
= validate_query(builder
, data
, flags
);
3956 hr
= validate_fragment(builder
, data
, flags
);
3960 TRACE("(%p %p %x): Finished validating builder components.\n", builder
, data
, flags
);
3965 static void convert_to_dos_path(const WCHAR
*path
, DWORD path_len
,
3966 WCHAR
*output
, DWORD
*output_len
)
3968 const WCHAR
*ptr
= path
;
3970 if(path_len
> 3 && *ptr
== '/' && is_drive_path(path
+1))
3971 /* Skip over the leading / before the drive path. */
3974 for(; ptr
< path
+path_len
; ++ptr
) {
3987 /* Generates a raw uri string using the parse_data. */
3988 static DWORD
generate_raw_uri(const parse_data
*data
, BSTR uri
, DWORD flags
) {
3993 memcpy(uri
, data
->scheme
, data
->scheme_len
*sizeof(WCHAR
));
3994 uri
[data
->scheme_len
] = ':';
3996 length
+= data
->scheme_len
+1;
3999 if(!data
->is_opaque
) {
4000 /* For the "//" which appears before the authority component. */
4003 uri
[length
+1] = '/';
4007 /* Check if we need to add the "\\" before the host name
4008 * of a UNC server name in a DOS path.
4010 if(flags
& RAW_URI_CONVERT_TO_DOS_PATH
&&
4011 data
->scheme_type
== URL_SCHEME_FILE
&& data
->host
) {
4014 uri
[length
+1] = '\\';
4020 if(data
->username
) {
4022 memcpy(uri
+length
, data
->username
, data
->username_len
*sizeof(WCHAR
));
4023 length
+= data
->username_len
;
4026 if(data
->password
) {
4029 memcpy(uri
+length
+1, data
->password
, data
->password_len
*sizeof(WCHAR
));
4031 length
+= data
->password_len
+1;
4034 if(data
->password
|| data
->username
) {
4041 /* IPv6 addresses get the brackets added around them if they don't already
4044 const BOOL add_brackets
= data
->host_type
== Uri_HOST_IPV6
&& *(data
->host
) != '[';
4052 memcpy(uri
+length
, data
->host
, data
->host_len
*sizeof(WCHAR
));
4053 length
+= data
->host_len
;
4062 if(data
->has_port
) {
4063 /* The port isn't included in the raw uri if it's the default
4064 * port for the scheme type.
4067 BOOL is_default
= FALSE
;
4069 for(i
= 0; i
< sizeof(default_ports
)/sizeof(default_ports
[0]); ++i
) {
4070 if(data
->scheme_type
== default_ports
[i
].scheme
&&
4071 data
->port_value
== default_ports
[i
].port
)
4075 if(!is_default
|| flags
& RAW_URI_FORCE_PORT_DISP
) {
4081 length
+= ui2str(uri
+length
, data
->port_value
);
4083 length
+= ui2str(NULL
, data
->port_value
);
4087 /* Check if a '/' should be added before the path for hierarchical URIs. */
4088 if(!data
->is_opaque
&& data
->path
&& *(data
->path
) != '/') {
4095 if(!data
->is_opaque
&& data
->scheme_type
== URL_SCHEME_FILE
&&
4096 flags
& RAW_URI_CONVERT_TO_DOS_PATH
) {
4100 convert_to_dos_path(data
->path
, data
->path_len
, uri
+length
, &len
);
4102 convert_to_dos_path(data
->path
, data
->path_len
, NULL
, &len
);
4107 memcpy(uri
+length
, data
->path
, data
->path_len
*sizeof(WCHAR
));
4108 length
+= data
->path_len
;
4114 memcpy(uri
+length
, data
->query
, data
->query_len
*sizeof(WCHAR
));
4115 length
+= data
->query_len
;
4118 if(data
->fragment
) {
4120 memcpy(uri
+length
, data
->fragment
, data
->fragment_len
*sizeof(WCHAR
));
4121 length
+= data
->fragment_len
;
4125 TRACE("(%p %p): Generated raw uri=%s len=%d\n", data
, uri
, debugstr_wn(uri
, length
), length
);
4127 TRACE("(%p %p): Computed raw uri len=%d\n", data
, uri
, length
);
4132 static HRESULT
generate_uri(const UriBuilder
*builder
, const parse_data
*data
, Uri
*uri
, DWORD flags
) {
4134 DWORD length
= generate_raw_uri(data
, NULL
, 0);
4135 uri
->raw_uri
= SysAllocStringLen(NULL
, length
);
4137 return E_OUTOFMEMORY
;
4139 generate_raw_uri(data
, uri
->raw_uri
, 0);
4141 hr
= canonicalize_uri(data
, uri
, flags
);
4143 if(hr
== E_INVALIDARG
)
4144 return INET_E_INVALID_URL
;
4148 uri
->create_flags
= flags
;
4152 static inline Uri
* impl_from_IUri(IUri
*iface
)
4154 return CONTAINING_RECORD(iface
, Uri
, IUri_iface
);
4157 static inline void destory_uri_obj(Uri
*This
)
4159 SysFreeString(This
->raw_uri
);
4160 heap_free(This
->canon_uri
);
4164 static HRESULT WINAPI
Uri_QueryInterface(IUri
*iface
, REFIID riid
, void **ppv
)
4166 Uri
*This
= impl_from_IUri(iface
);
4168 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
4169 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
4170 *ppv
= &This
->IUri_iface
;
4171 }else if(IsEqualGUID(&IID_IUri
, riid
)) {
4172 TRACE("(%p)->(IID_IUri %p)\n", This
, ppv
);
4173 *ppv
= &This
->IUri_iface
;
4174 }else if(IsEqualGUID(&IID_IUriBuilderFactory
, riid
)) {
4175 TRACE("(%p)->(IID_IUriBuilderFactory %p)\n", This
, riid
);
4176 *ppv
= &This
->IUriBuilderFactory_iface
;
4177 }else if(IsEqualGUID(&IID_IUriObj
, riid
)) {
4178 TRACE("(%p)->(IID_IUriObj %p)\n", This
, ppv
);
4182 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
4184 return E_NOINTERFACE
;
4187 IUnknown_AddRef((IUnknown
*)*ppv
);
4191 static ULONG WINAPI
Uri_AddRef(IUri
*iface
)
4193 Uri
*This
= impl_from_IUri(iface
);
4194 LONG ref
= InterlockedIncrement(&This
->ref
);
4196 TRACE("(%p) ref=%d\n", This
, ref
);
4201 static ULONG WINAPI
Uri_Release(IUri
*iface
)
4203 Uri
*This
= impl_from_IUri(iface
);
4204 LONG ref
= InterlockedDecrement(&This
->ref
);
4206 TRACE("(%p) ref=%d\n", This
, ref
);
4209 destory_uri_obj(This
);
4214 static HRESULT WINAPI
Uri_GetPropertyBSTR(IUri
*iface
, Uri_PROPERTY uriProp
, BSTR
*pbstrProperty
, DWORD dwFlags
)
4216 Uri
*This
= impl_from_IUri(iface
);
4218 TRACE("(%p %s)->(%d %p %x)\n", This
, debugstr_w(This
->canon_uri
), uriProp
, pbstrProperty
, dwFlags
);
4223 if(uriProp
> Uri_PROPERTY_STRING_LAST
) {
4224 /* Windows allocates an empty BSTR for invalid Uri_PROPERTY's. */
4225 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4226 if(!(*pbstrProperty
))
4227 return E_OUTOFMEMORY
;
4229 /* It only returns S_FALSE for the ZONE property... */
4230 if(uriProp
== Uri_PROPERTY_ZONE
)
4236 /* Don't have support for flags yet. */
4238 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pbstrProperty
, dwFlags
);
4243 case Uri_PROPERTY_ABSOLUTE_URI
:
4244 if(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
) {
4245 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4248 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
&& This
->userinfo_start
> -1) {
4249 if(This
->userinfo_len
== 0) {
4250 /* Don't include the '@' after the userinfo component. */
4251 *pbstrProperty
= SysAllocStringLen(NULL
, This
->canon_len
-1);
4253 if(*pbstrProperty
) {
4254 /* Copy everything before it. */
4255 memcpy(*pbstrProperty
, This
->canon_uri
, This
->userinfo_start
*sizeof(WCHAR
));
4257 /* And everything after it. */
4258 memcpy(*pbstrProperty
+This
->userinfo_start
, This
->canon_uri
+This
->userinfo_start
+1,
4259 (This
->canon_len
-This
->userinfo_start
-1)*sizeof(WCHAR
));
4261 } else if(This
->userinfo_split
== 0 && This
->userinfo_len
== 1) {
4262 /* Don't include the ":@" */
4263 *pbstrProperty
= SysAllocStringLen(NULL
, This
->canon_len
-2);
4265 if(*pbstrProperty
) {
4266 memcpy(*pbstrProperty
, This
->canon_uri
, This
->userinfo_start
*sizeof(WCHAR
));
4267 memcpy(*pbstrProperty
+This
->userinfo_start
, This
->canon_uri
+This
->userinfo_start
+2,
4268 (This
->canon_len
-This
->userinfo_start
-2)*sizeof(WCHAR
));
4271 *pbstrProperty
= SysAllocString(This
->canon_uri
);
4275 *pbstrProperty
= SysAllocString(This
->canon_uri
);
4280 if(!(*pbstrProperty
))
4281 hres
= E_OUTOFMEMORY
;
4284 case Uri_PROPERTY_AUTHORITY
:
4285 if(This
->authority_start
> -1) {
4286 if(This
->port_offset
> -1 && is_default_port(This
->scheme_type
, This
->port
) &&
4287 This
->display_modifiers
& URI_DISPLAY_NO_DEFAULT_PORT_AUTH
)
4288 /* Don't include the port in the authority component. */
4289 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->authority_start
, This
->port_offset
);
4291 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->authority_start
, This
->authority_len
);
4294 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4298 if(!(*pbstrProperty
))
4299 hres
= E_OUTOFMEMORY
;
4302 case Uri_PROPERTY_DISPLAY_URI
:
4303 /* The Display URI contains everything except for the userinfo for known
4306 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
&& This
->userinfo_start
> -1) {
4307 *pbstrProperty
= SysAllocStringLen(NULL
, This
->canon_len
-This
->userinfo_len
);
4309 if(*pbstrProperty
) {
4310 /* Copy everything before the userinfo over. */
4311 memcpy(*pbstrProperty
, This
->canon_uri
, This
->userinfo_start
*sizeof(WCHAR
));
4312 /* Copy everything after the userinfo over. */
4313 memcpy(*pbstrProperty
+This
->userinfo_start
,
4314 This
->canon_uri
+This
->userinfo_start
+This
->userinfo_len
+1,
4315 (This
->canon_len
-(This
->userinfo_start
+This
->userinfo_len
+1))*sizeof(WCHAR
));
4318 *pbstrProperty
= SysAllocString(This
->canon_uri
);
4320 if(!(*pbstrProperty
))
4321 hres
= E_OUTOFMEMORY
;
4326 case Uri_PROPERTY_DOMAIN
:
4327 if(This
->domain_offset
> -1) {
4328 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->host_start
+This
->domain_offset
,
4329 This
->host_len
-This
->domain_offset
);
4332 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4336 if(!(*pbstrProperty
))
4337 hres
= E_OUTOFMEMORY
;
4340 case Uri_PROPERTY_EXTENSION
:
4341 if(This
->extension_offset
> -1) {
4342 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->path_start
+This
->extension_offset
,
4343 This
->path_len
-This
->extension_offset
);
4346 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4350 if(!(*pbstrProperty
))
4351 hres
= E_OUTOFMEMORY
;
4354 case Uri_PROPERTY_FRAGMENT
:
4355 if(This
->fragment_start
> -1) {
4356 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->fragment_start
, This
->fragment_len
);
4359 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4363 if(!(*pbstrProperty
))
4364 hres
= E_OUTOFMEMORY
;
4367 case Uri_PROPERTY_HOST
:
4368 if(This
->host_start
> -1) {
4369 /* The '[' and ']' aren't included for IPv6 addresses. */
4370 if(This
->host_type
== Uri_HOST_IPV6
)
4371 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->host_start
+1, This
->host_len
-2);
4373 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->host_start
, This
->host_len
);
4377 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4381 if(!(*pbstrProperty
))
4382 hres
= E_OUTOFMEMORY
;
4385 case Uri_PROPERTY_PASSWORD
:
4386 if(This
->userinfo_split
> -1) {
4387 *pbstrProperty
= SysAllocStringLen(
4388 This
->canon_uri
+This
->userinfo_start
+This
->userinfo_split
+1,
4389 This
->userinfo_len
-This
->userinfo_split
-1);
4392 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4396 if(!(*pbstrProperty
))
4397 return E_OUTOFMEMORY
;
4400 case Uri_PROPERTY_PATH
:
4401 if(This
->path_start
> -1) {
4402 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->path_start
, This
->path_len
);
4405 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4409 if(!(*pbstrProperty
))
4410 hres
= E_OUTOFMEMORY
;
4413 case Uri_PROPERTY_PATH_AND_QUERY
:
4414 if(This
->path_start
> -1) {
4415 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->path_start
, This
->path_len
+This
->query_len
);
4417 } else if(This
->query_start
> -1) {
4418 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->query_start
, This
->query_len
);
4421 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4425 if(!(*pbstrProperty
))
4426 hres
= E_OUTOFMEMORY
;
4429 case Uri_PROPERTY_QUERY
:
4430 if(This
->query_start
> -1) {
4431 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->query_start
, This
->query_len
);
4434 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4438 if(!(*pbstrProperty
))
4439 hres
= E_OUTOFMEMORY
;
4442 case Uri_PROPERTY_RAW_URI
:
4443 *pbstrProperty
= SysAllocString(This
->raw_uri
);
4444 if(!(*pbstrProperty
))
4445 hres
= E_OUTOFMEMORY
;
4449 case Uri_PROPERTY_SCHEME_NAME
:
4450 if(This
->scheme_start
> -1) {
4451 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+ This
->scheme_start
, This
->scheme_len
);
4454 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4458 if(!(*pbstrProperty
))
4459 hres
= E_OUTOFMEMORY
;
4462 case Uri_PROPERTY_USER_INFO
:
4463 if(This
->userinfo_start
> -1) {
4464 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+This
->userinfo_start
, This
->userinfo_len
);
4467 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4471 if(!(*pbstrProperty
))
4472 hres
= E_OUTOFMEMORY
;
4475 case Uri_PROPERTY_USER_NAME
:
4476 if(This
->userinfo_start
> -1 && This
->userinfo_split
!= 0) {
4477 /* If userinfo_split is set, that means a password exists
4478 * so the username is only from userinfo_start to userinfo_split.
4480 if(This
->userinfo_split
> -1) {
4481 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+ This
->userinfo_start
, This
->userinfo_split
);
4484 *pbstrProperty
= SysAllocStringLen(This
->canon_uri
+ This
->userinfo_start
, This
->userinfo_len
);
4488 *pbstrProperty
= SysAllocStringLen(NULL
, 0);
4492 if(!(*pbstrProperty
))
4493 return E_OUTOFMEMORY
;
4497 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pbstrProperty
, dwFlags
);
4504 static HRESULT WINAPI
Uri_GetPropertyLength(IUri
*iface
, Uri_PROPERTY uriProp
, DWORD
*pcchProperty
, DWORD dwFlags
)
4506 Uri
*This
= impl_from_IUri(iface
);
4508 TRACE("(%p %s)->(%d %p %x)\n", This
, debugstr_w(This
->canon_uri
), uriProp
, pcchProperty
, dwFlags
);
4511 return E_INVALIDARG
;
4513 /* Can only return a length for a property if it's a string. */
4514 if(uriProp
> Uri_PROPERTY_STRING_LAST
)
4515 return E_INVALIDARG
;
4517 /* Don't have support for flags yet. */
4519 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4524 case Uri_PROPERTY_ABSOLUTE_URI
:
4525 if(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
) {
4529 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
) {
4530 if(This
->userinfo_start
> -1 && This
->userinfo_len
== 0)
4531 /* Don't include the '@' in the length. */
4532 *pcchProperty
= This
->canon_len
-1;
4533 else if(This
->userinfo_start
> -1 && This
->userinfo_len
== 1 &&
4534 This
->userinfo_split
== 0)
4535 /* Don't include the ":@" in the length. */
4536 *pcchProperty
= This
->canon_len
-2;
4538 *pcchProperty
= This
->canon_len
;
4540 *pcchProperty
= This
->canon_len
;
4546 case Uri_PROPERTY_AUTHORITY
:
4547 if(This
->port_offset
> -1 &&
4548 This
->display_modifiers
& URI_DISPLAY_NO_DEFAULT_PORT_AUTH
&&
4549 is_default_port(This
->scheme_type
, This
->port
))
4550 /* Only count up until the port in the authority. */
4551 *pcchProperty
= This
->port_offset
;
4553 *pcchProperty
= This
->authority_len
;
4554 hres
= (This
->authority_start
> -1) ? S_OK
: S_FALSE
;
4556 case Uri_PROPERTY_DISPLAY_URI
:
4557 if(This
->scheme_type
!= URL_SCHEME_UNKNOWN
&& This
->userinfo_start
> -1)
4558 *pcchProperty
= This
->canon_len
-This
->userinfo_len
-1;
4560 *pcchProperty
= This
->canon_len
;
4564 case Uri_PROPERTY_DOMAIN
:
4565 if(This
->domain_offset
> -1)
4566 *pcchProperty
= This
->host_len
- This
->domain_offset
;
4570 hres
= (This
->domain_offset
> -1) ? S_OK
: S_FALSE
;
4572 case Uri_PROPERTY_EXTENSION
:
4573 if(This
->extension_offset
> -1) {
4574 *pcchProperty
= This
->path_len
- This
->extension_offset
;
4582 case Uri_PROPERTY_FRAGMENT
:
4583 *pcchProperty
= This
->fragment_len
;
4584 hres
= (This
->fragment_start
> -1) ? S_OK
: S_FALSE
;
4586 case Uri_PROPERTY_HOST
:
4587 *pcchProperty
= This
->host_len
;
4589 /* '[' and ']' aren't included in the length. */
4590 if(This
->host_type
== Uri_HOST_IPV6
)
4593 hres
= (This
->host_start
> -1) ? S_OK
: S_FALSE
;
4595 case Uri_PROPERTY_PASSWORD
:
4596 *pcchProperty
= (This
->userinfo_split
> -1) ? This
->userinfo_len
-This
->userinfo_split
-1 : 0;
4597 hres
= (This
->userinfo_split
> -1) ? S_OK
: S_FALSE
;
4599 case Uri_PROPERTY_PATH
:
4600 *pcchProperty
= This
->path_len
;
4601 hres
= (This
->path_start
> -1) ? S_OK
: S_FALSE
;
4603 case Uri_PROPERTY_PATH_AND_QUERY
:
4604 *pcchProperty
= This
->path_len
+This
->query_len
;
4605 hres
= (This
->path_start
> -1 || This
->query_start
> -1) ? S_OK
: S_FALSE
;
4607 case Uri_PROPERTY_QUERY
:
4608 *pcchProperty
= This
->query_len
;
4609 hres
= (This
->query_start
> -1) ? S_OK
: S_FALSE
;
4611 case Uri_PROPERTY_RAW_URI
:
4612 *pcchProperty
= SysStringLen(This
->raw_uri
);
4615 case Uri_PROPERTY_SCHEME_NAME
:
4616 *pcchProperty
= This
->scheme_len
;
4617 hres
= (This
->scheme_start
> -1) ? S_OK
: S_FALSE
;
4619 case Uri_PROPERTY_USER_INFO
:
4620 *pcchProperty
= This
->userinfo_len
;
4621 hres
= (This
->userinfo_start
> -1) ? S_OK
: S_FALSE
;
4623 case Uri_PROPERTY_USER_NAME
:
4624 *pcchProperty
= (This
->userinfo_split
> -1) ? This
->userinfo_split
: This
->userinfo_len
;
4625 if(This
->userinfo_split
== 0)
4628 hres
= (This
->userinfo_start
> -1) ? S_OK
: S_FALSE
;
4631 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4638 static HRESULT WINAPI
Uri_GetPropertyDWORD(IUri
*iface
, Uri_PROPERTY uriProp
, DWORD
*pcchProperty
, DWORD dwFlags
)
4640 Uri
*This
= impl_from_IUri(iface
);
4643 TRACE("(%p %s)->(%d %p %x)\n", This
, debugstr_w(This
->canon_uri
), uriProp
, pcchProperty
, dwFlags
);
4646 return E_INVALIDARG
;
4648 /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
4649 * From what I can tell, instead of checking which URLZONE the URI belongs to it
4650 * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies to the GetZone
4653 if(uriProp
== Uri_PROPERTY_ZONE
) {
4654 *pcchProperty
= URLZONE_INVALID
;
4658 if(uriProp
< Uri_PROPERTY_DWORD_START
) {
4660 return E_INVALIDARG
;
4664 case Uri_PROPERTY_HOST_TYPE
:
4665 *pcchProperty
= This
->host_type
;
4668 case Uri_PROPERTY_PORT
:
4669 if(!This
->has_port
) {
4673 *pcchProperty
= This
->port
;
4678 case Uri_PROPERTY_SCHEME
:
4679 *pcchProperty
= This
->scheme_type
;
4683 FIXME("(%p)->(%d %p %x)\n", This
, uriProp
, pcchProperty
, dwFlags
);
4690 static HRESULT WINAPI
Uri_HasProperty(IUri
*iface
, Uri_PROPERTY uriProp
, BOOL
*pfHasProperty
)
4692 Uri
*This
= impl_from_IUri(iface
);
4694 TRACE("(%p %s)->(%d %p)\n", This
, debugstr_w(This
->canon_uri
), uriProp
, pfHasProperty
);
4697 return E_INVALIDARG
;
4700 case Uri_PROPERTY_ABSOLUTE_URI
:
4701 *pfHasProperty
= !(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
);
4703 case Uri_PROPERTY_AUTHORITY
:
4704 *pfHasProperty
= This
->authority_start
> -1;
4706 case Uri_PROPERTY_DISPLAY_URI
:
4707 *pfHasProperty
= TRUE
;
4709 case Uri_PROPERTY_DOMAIN
:
4710 *pfHasProperty
= This
->domain_offset
> -1;
4712 case Uri_PROPERTY_EXTENSION
:
4713 *pfHasProperty
= This
->extension_offset
> -1;
4715 case Uri_PROPERTY_FRAGMENT
:
4716 *pfHasProperty
= This
->fragment_start
> -1;
4718 case Uri_PROPERTY_HOST
:
4719 *pfHasProperty
= This
->host_start
> -1;
4721 case Uri_PROPERTY_PASSWORD
:
4722 *pfHasProperty
= This
->userinfo_split
> -1;
4724 case Uri_PROPERTY_PATH
:
4725 *pfHasProperty
= This
->path_start
> -1;
4727 case Uri_PROPERTY_PATH_AND_QUERY
:
4728 *pfHasProperty
= (This
->path_start
> -1 || This
->query_start
> -1);
4730 case Uri_PROPERTY_QUERY
:
4731 *pfHasProperty
= This
->query_start
> -1;
4733 case Uri_PROPERTY_RAW_URI
:
4734 *pfHasProperty
= TRUE
;
4736 case Uri_PROPERTY_SCHEME_NAME
:
4737 *pfHasProperty
= This
->scheme_start
> -1;
4739 case Uri_PROPERTY_USER_INFO
:
4740 *pfHasProperty
= This
->userinfo_start
> -1;
4742 case Uri_PROPERTY_USER_NAME
:
4743 if(This
->userinfo_split
== 0)
4744 *pfHasProperty
= FALSE
;
4746 *pfHasProperty
= This
->userinfo_start
> -1;
4748 case Uri_PROPERTY_HOST_TYPE
:
4749 *pfHasProperty
= TRUE
;
4751 case Uri_PROPERTY_PORT
:
4752 *pfHasProperty
= This
->has_port
;
4754 case Uri_PROPERTY_SCHEME
:
4755 *pfHasProperty
= TRUE
;
4757 case Uri_PROPERTY_ZONE
:
4758 *pfHasProperty
= FALSE
;
4761 FIXME("(%p)->(%d %p): Unsupported property type.\n", This
, uriProp
, pfHasProperty
);
4768 static HRESULT WINAPI
Uri_GetAbsoluteUri(IUri
*iface
, BSTR
*pstrAbsoluteUri
)
4770 TRACE("(%p)->(%p)\n", iface
, pstrAbsoluteUri
);
4771 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_ABSOLUTE_URI
, pstrAbsoluteUri
, 0);
4774 static HRESULT WINAPI
Uri_GetAuthority(IUri
*iface
, BSTR
*pstrAuthority
)
4776 TRACE("(%p)->(%p)\n", iface
, pstrAuthority
);
4777 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_AUTHORITY
, pstrAuthority
, 0);
4780 static HRESULT WINAPI
Uri_GetDisplayUri(IUri
*iface
, BSTR
*pstrDisplayUri
)
4782 TRACE("(%p)->(%p)\n", iface
, pstrDisplayUri
);
4783 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_DISPLAY_URI
, pstrDisplayUri
, 0);
4786 static HRESULT WINAPI
Uri_GetDomain(IUri
*iface
, BSTR
*pstrDomain
)
4788 TRACE("(%p)->(%p)\n", iface
, pstrDomain
);
4789 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_DOMAIN
, pstrDomain
, 0);
4792 static HRESULT WINAPI
Uri_GetExtension(IUri
*iface
, BSTR
*pstrExtension
)
4794 TRACE("(%p)->(%p)\n", iface
, pstrExtension
);
4795 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_EXTENSION
, pstrExtension
, 0);
4798 static HRESULT WINAPI
Uri_GetFragment(IUri
*iface
, BSTR
*pstrFragment
)
4800 TRACE("(%p)->(%p)\n", iface
, pstrFragment
);
4801 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_FRAGMENT
, pstrFragment
, 0);
4804 static HRESULT WINAPI
Uri_GetHost(IUri
*iface
, BSTR
*pstrHost
)
4806 TRACE("(%p)->(%p)\n", iface
, pstrHost
);
4807 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_HOST
, pstrHost
, 0);
4810 static HRESULT WINAPI
Uri_GetPassword(IUri
*iface
, BSTR
*pstrPassword
)
4812 TRACE("(%p)->(%p)\n", iface
, pstrPassword
);
4813 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_PASSWORD
, pstrPassword
, 0);
4816 static HRESULT WINAPI
Uri_GetPath(IUri
*iface
, BSTR
*pstrPath
)
4818 TRACE("(%p)->(%p)\n", iface
, pstrPath
);
4819 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_PATH
, pstrPath
, 0);
4822 static HRESULT WINAPI
Uri_GetPathAndQuery(IUri
*iface
, BSTR
*pstrPathAndQuery
)
4824 TRACE("(%p)->(%p)\n", iface
, pstrPathAndQuery
);
4825 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_PATH_AND_QUERY
, pstrPathAndQuery
, 0);
4828 static HRESULT WINAPI
Uri_GetQuery(IUri
*iface
, BSTR
*pstrQuery
)
4830 TRACE("(%p)->(%p)\n", iface
, pstrQuery
);
4831 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_QUERY
, pstrQuery
, 0);
4834 static HRESULT WINAPI
Uri_GetRawUri(IUri
*iface
, BSTR
*pstrRawUri
)
4836 TRACE("(%p)->(%p)\n", iface
, pstrRawUri
);
4837 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_RAW_URI
, pstrRawUri
, 0);
4840 static HRESULT WINAPI
Uri_GetSchemeName(IUri
*iface
, BSTR
*pstrSchemeName
)
4842 TRACE("(%p)->(%p)\n", iface
, pstrSchemeName
);
4843 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_SCHEME_NAME
, pstrSchemeName
, 0);
4846 static HRESULT WINAPI
Uri_GetUserInfo(IUri
*iface
, BSTR
*pstrUserInfo
)
4848 TRACE("(%p)->(%p)\n", iface
, pstrUserInfo
);
4849 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_USER_INFO
, pstrUserInfo
, 0);
4852 static HRESULT WINAPI
Uri_GetUserName(IUri
*iface
, BSTR
*pstrUserName
)
4854 TRACE("(%p)->(%p)\n", iface
, pstrUserName
);
4855 return IUri_GetPropertyBSTR(iface
, Uri_PROPERTY_USER_NAME
, pstrUserName
, 0);
4858 static HRESULT WINAPI
Uri_GetHostType(IUri
*iface
, DWORD
*pdwHostType
)
4860 TRACE("(%p)->(%p)\n", iface
, pdwHostType
);
4861 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_HOST_TYPE
, pdwHostType
, 0);
4864 static HRESULT WINAPI
Uri_GetPort(IUri
*iface
, DWORD
*pdwPort
)
4866 TRACE("(%p)->(%p)\n", iface
, pdwPort
);
4867 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_PORT
, pdwPort
, 0);
4870 static HRESULT WINAPI
Uri_GetScheme(IUri
*iface
, DWORD
*pdwScheme
)
4872 TRACE("(%p)->(%p)\n", iface
, pdwScheme
);
4873 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_SCHEME
, pdwScheme
, 0);
4876 static HRESULT WINAPI
Uri_GetZone(IUri
*iface
, DWORD
*pdwZone
)
4878 TRACE("(%p)->(%p)\n", iface
, pdwZone
);
4879 return IUri_GetPropertyDWORD(iface
, Uri_PROPERTY_ZONE
,pdwZone
, 0);
4882 static HRESULT WINAPI
Uri_GetProperties(IUri
*iface
, DWORD
*pdwProperties
)
4884 Uri
*This
= impl_from_IUri(iface
);
4885 TRACE("(%p %s)->(%p)\n", This
, debugstr_w(This
->canon_uri
), pdwProperties
);
4888 return E_INVALIDARG
;
4890 /* All URIs have these. */
4891 *pdwProperties
= Uri_HAS_DISPLAY_URI
|Uri_HAS_RAW_URI
|Uri_HAS_SCHEME
|Uri_HAS_HOST_TYPE
;
4893 if(!(This
->display_modifiers
& URI_DISPLAY_NO_ABSOLUTE_URI
))
4894 *pdwProperties
|= Uri_HAS_ABSOLUTE_URI
;
4896 if(This
->scheme_start
> -1)
4897 *pdwProperties
|= Uri_HAS_SCHEME_NAME
;
4899 if(This
->authority_start
> -1) {
4900 *pdwProperties
|= Uri_HAS_AUTHORITY
;
4901 if(This
->userinfo_start
> -1) {
4902 *pdwProperties
|= Uri_HAS_USER_INFO
;
4903 if(This
->userinfo_split
!= 0)
4904 *pdwProperties
|= Uri_HAS_USER_NAME
;
4906 if(This
->userinfo_split
> -1)
4907 *pdwProperties
|= Uri_HAS_PASSWORD
;
4908 if(This
->host_start
> -1)
4909 *pdwProperties
|= Uri_HAS_HOST
;
4910 if(This
->domain_offset
> -1)
4911 *pdwProperties
|= Uri_HAS_DOMAIN
;
4915 *pdwProperties
|= Uri_HAS_PORT
;
4916 if(This
->path_start
> -1)
4917 *pdwProperties
|= Uri_HAS_PATH
|Uri_HAS_PATH_AND_QUERY
;
4918 if(This
->query_start
> -1)
4919 *pdwProperties
|= Uri_HAS_QUERY
|Uri_HAS_PATH_AND_QUERY
;
4921 if(This
->extension_offset
> -1)
4922 *pdwProperties
|= Uri_HAS_EXTENSION
;
4924 if(This
->fragment_start
> -1)
4925 *pdwProperties
|= Uri_HAS_FRAGMENT
;
4930 static HRESULT WINAPI
Uri_IsEqual(IUri
*iface
, IUri
*pUri
, BOOL
*pfEqual
)
4932 Uri
*This
= impl_from_IUri(iface
);
4935 TRACE("(%p %s)->(%p %p)\n", This
, debugstr_w(This
->canon_uri
), pUri
, pfEqual
);
4943 /* For some reason Windows returns S_OK here... */
4947 /* Try to convert it to a Uri (allows for a more simple comparison). */
4948 if((other
= get_uri_obj(pUri
))) {
4949 TRACE("comparing to %s\n", debugstr_w(other
->canon_uri
));
4950 *pfEqual
= are_equal_simple(This
, other
);
4952 /* Do it the hard way. */
4953 FIXME("(%p)->(%p %p) No support for unknown IUri's yet.\n", iface
, pUri
, pfEqual
);
4960 static const IUriVtbl UriVtbl
= {
4964 Uri_GetPropertyBSTR
,
4965 Uri_GetPropertyLength
,
4966 Uri_GetPropertyDWORD
,
4977 Uri_GetPathAndQuery
,
4991 static inline Uri
* impl_from_IUriBuilderFactory(IUriBuilderFactory
*iface
)
4993 return CONTAINING_RECORD(iface
, Uri
, IUriBuilderFactory_iface
);
4996 static HRESULT WINAPI
UriBuilderFactory_QueryInterface(IUriBuilderFactory
*iface
, REFIID riid
, void **ppv
)
4998 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5000 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
5001 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
5002 *ppv
= &This
->IUriBuilderFactory_iface
;
5003 }else if(IsEqualGUID(&IID_IUriBuilderFactory
, riid
)) {
5004 TRACE("(%p)->(IID_IUriBuilderFactory %p)\n", This
, ppv
);
5005 *ppv
= &This
->IUriBuilderFactory_iface
;
5006 }else if(IsEqualGUID(&IID_IUri
, riid
)) {
5007 TRACE("(%p)->(IID_IUri %p)\n", This
, ppv
);
5008 *ppv
= &This
->IUri_iface
;
5010 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
5012 return E_NOINTERFACE
;
5015 IUnknown_AddRef((IUnknown
*)*ppv
);
5019 static ULONG WINAPI
UriBuilderFactory_AddRef(IUriBuilderFactory
*iface
)
5021 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5022 LONG ref
= InterlockedIncrement(&This
->ref
);
5024 TRACE("(%p) ref=%d\n", This
, ref
);
5029 static ULONG WINAPI
UriBuilderFactory_Release(IUriBuilderFactory
*iface
)
5031 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5032 LONG ref
= InterlockedDecrement(&This
->ref
);
5034 TRACE("(%p) ref=%d\n", This
, ref
);
5037 destory_uri_obj(This
);
5042 static HRESULT WINAPI
UriBuilderFactory_CreateIUriBuilder(IUriBuilderFactory
*iface
,
5044 DWORD_PTR dwReserved
,
5045 IUriBuilder
**ppIUriBuilder
)
5047 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5048 TRACE("(%p)->(%08x %08x %p)\n", This
, dwFlags
, (DWORD
)dwReserved
, ppIUriBuilder
);
5053 if(dwFlags
|| dwReserved
) {
5054 *ppIUriBuilder
= NULL
;
5055 return E_INVALIDARG
;
5058 return CreateIUriBuilder(NULL
, 0, 0, ppIUriBuilder
);
5061 static HRESULT WINAPI
UriBuilderFactory_CreateInitializedIUriBuilder(IUriBuilderFactory
*iface
,
5063 DWORD_PTR dwReserved
,
5064 IUriBuilder
**ppIUriBuilder
)
5066 Uri
*This
= impl_from_IUriBuilderFactory(iface
);
5067 TRACE("(%p)->(%08x %08x %p)\n", This
, dwFlags
, (DWORD
)dwReserved
, ppIUriBuilder
);
5072 if(dwFlags
|| dwReserved
) {
5073 *ppIUriBuilder
= NULL
;
5074 return E_INVALIDARG
;
5077 return CreateIUriBuilder(&This
->IUri_iface
, 0, 0, ppIUriBuilder
);
5080 static const IUriBuilderFactoryVtbl UriBuilderFactoryVtbl
= {
5081 UriBuilderFactory_QueryInterface
,
5082 UriBuilderFactory_AddRef
,
5083 UriBuilderFactory_Release
,
5084 UriBuilderFactory_CreateIUriBuilder
,
5085 UriBuilderFactory_CreateInitializedIUriBuilder
5088 static Uri
* create_uri_obj(void) {
5089 Uri
*ret
= heap_alloc_zero(sizeof(Uri
));
5091 ret
->IUri_iface
.lpVtbl
= &UriVtbl
;
5092 ret
->IUriBuilderFactory_iface
.lpVtbl
= &UriBuilderFactoryVtbl
;
5099 /***********************************************************************
5100 * CreateUri (urlmon.@)
5102 * Creates a new IUri object using the URI represented by pwzURI. This function
5103 * parses and validates the components of pwzURI and then canonicalizes the
5104 * parsed components.
5107 * pwzURI [I] The URI to parse, validate, and canonicalize.
5108 * dwFlags [I] Flags which can affect how the parsing/canonicalization is performed.
5109 * dwReserved [I] Reserved (not used).
5110 * ppURI [O] The resulting IUri after parsing/canonicalization occurs.
5113 * Success: Returns S_OK. ppURI contains the pointer to the newly allocated IUri.
5114 * Failure: E_INVALIDARG if there are invalid flag combinations in dwFlags, or an
5115 * invalid parameter, or pwzURI doesn't represent a valid URI.
5116 * E_OUTOFMEMORY if any memory allocation fails.
5120 * Uri_CREATE_CANONICALIZE, Uri_CREATE_DECODE_EXTRA_INFO, Uri_CREATE_CRACK_UNKNOWN_SCHEMES,
5121 * Uri_CREATE_PRE_PROCESS_HTML_URI, Uri_CREATE_NO_IE_SETTINGS.
5123 HRESULT WINAPI
CreateUri(LPCWSTR pwzURI
, DWORD dwFlags
, DWORD_PTR dwReserved
, IUri
**ppURI
)
5125 const DWORD supported_flags
= Uri_CREATE_ALLOW_RELATIVE
|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME
|
5126 Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME
|Uri_CREATE_NO_CANONICALIZE
|Uri_CREATE_CANONICALIZE
|
5127 Uri_CREATE_DECODE_EXTRA_INFO
|Uri_CREATE_NO_DECODE_EXTRA_INFO
|Uri_CREATE_CRACK_UNKNOWN_SCHEMES
|
5128 Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES
|Uri_CREATE_PRE_PROCESS_HTML_URI
|Uri_CREATE_NO_PRE_PROCESS_HTML_URI
|
5129 Uri_CREATE_NO_IE_SETTINGS
|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS
|Uri_CREATE_FILE_USE_DOS_PATH
;
5134 TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI
), dwFlags
, (DWORD
)dwReserved
, ppURI
);
5137 return E_INVALIDARG
;
5141 return E_INVALIDARG
;
5144 /* Check for invalid flags. */
5145 if(has_invalid_flag_combination(dwFlags
)) {
5147 return E_INVALIDARG
;
5150 /* Currently unsupported. */
5151 if(dwFlags
& ~supported_flags
)
5152 FIXME("Ignoring unsupported flag(s) %x\n", dwFlags
& ~supported_flags
);
5154 ret
= create_uri_obj();
5157 return E_OUTOFMEMORY
;
5160 /* Explicitly set the default flags if it doesn't cause a flag conflict. */
5161 apply_default_flags(&dwFlags
);
5163 /* Pre process the URI, unless told otherwise. */
5164 if(!(dwFlags
& Uri_CREATE_NO_PRE_PROCESS_HTML_URI
))
5165 ret
->raw_uri
= pre_process_uri(pwzURI
);
5167 ret
->raw_uri
= SysAllocString(pwzURI
);
5171 return E_OUTOFMEMORY
;
5174 memset(&data
, 0, sizeof(parse_data
));
5175 data
.uri
= ret
->raw_uri
;
5177 /* Validate and parse the URI into its components. */
5178 if(!parse_uri(&data
, dwFlags
)) {
5179 /* Encountered an unsupported or invalid URI */
5180 IUri_Release(&ret
->IUri_iface
);
5182 return E_INVALIDARG
;
5185 /* Canonicalize the URI. */
5186 hr
= canonicalize_uri(&data
, ret
, dwFlags
);
5188 IUri_Release(&ret
->IUri_iface
);
5193 ret
->create_flags
= dwFlags
;
5195 *ppURI
= &ret
->IUri_iface
;
5199 /***********************************************************************
5200 * CreateUriWithFragment (urlmon.@)
5202 * Creates a new IUri object. This is almost the same as CreateUri, expect that
5203 * it allows you to explicitly specify a fragment (pwzFragment) for pwzURI.
5206 * pwzURI [I] The URI to parse and perform canonicalization on.
5207 * pwzFragment [I] The explicit fragment string which should be added to pwzURI.
5208 * dwFlags [I] The flags which will be passed to CreateUri.
5209 * dwReserved [I] Reserved (not used).
5210 * ppURI [O] The resulting IUri after parsing/canonicalization.
5213 * Success: S_OK. ppURI contains the pointer to the newly allocated IUri.
5214 * Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment
5215 * isn't NULL. Will also return E_INVALIDARG for the same reasons as
5216 * CreateUri will. E_OUTOFMEMORY if any allocation fails.
5218 HRESULT WINAPI
CreateUriWithFragment(LPCWSTR pwzURI
, LPCWSTR pwzFragment
, DWORD dwFlags
,
5219 DWORD_PTR dwReserved
, IUri
**ppURI
)
5222 TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI
), debugstr_w(pwzFragment
), dwFlags
, (DWORD
)dwReserved
, ppURI
);
5225 return E_INVALIDARG
;
5229 return E_INVALIDARG
;
5232 /* Check if a fragment should be appended to the URI string. */
5235 DWORD uri_len
, frag_len
;
5238 /* Check if the original URI already has a fragment component. */
5239 if(StrChrW(pwzURI
, '#')) {
5241 return E_INVALIDARG
;
5244 uri_len
= lstrlenW(pwzURI
);
5245 frag_len
= lstrlenW(pwzFragment
);
5247 /* If the fragment doesn't start with a '#', one will be added. */
5248 add_pound
= *pwzFragment
!= '#';
5251 uriW
= heap_alloc((uri_len
+frag_len
+2)*sizeof(WCHAR
));
5253 uriW
= heap_alloc((uri_len
+frag_len
+1)*sizeof(WCHAR
));
5256 return E_OUTOFMEMORY
;
5258 memcpy(uriW
, pwzURI
, uri_len
*sizeof(WCHAR
));
5260 uriW
[uri_len
++] = '#';
5261 memcpy(uriW
+uri_len
, pwzFragment
, (frag_len
+1)*sizeof(WCHAR
));
5263 hres
= CreateUri(uriW
, dwFlags
, 0, ppURI
);
5267 /* A fragment string wasn't specified, so just forward the call. */
5268 hres
= CreateUri(pwzURI
, dwFlags
, 0, ppURI
);
5273 static HRESULT
build_uri(const UriBuilder
*builder
, IUri
**uri
, DWORD create_flags
,
5274 DWORD use_orig_flags
, DWORD encoding_mask
)
5283 if(encoding_mask
&& (!builder
->uri
|| builder
->modified_props
)) {
5288 /* Decide what flags should be used when creating the Uri. */
5289 if((use_orig_flags
& UriBuilder_USE_ORIGINAL_FLAGS
) && builder
->uri
)
5290 create_flags
= builder
->uri
->create_flags
;
5292 if(has_invalid_flag_combination(create_flags
)) {
5294 return E_INVALIDARG
;
5297 /* Set the default flags if they don't cause a conflict. */
5298 apply_default_flags(&create_flags
);
5301 /* Return the base IUri if no changes have been made and the create_flags match. */
5302 if(builder
->uri
&& !builder
->modified_props
&& builder
->uri
->create_flags
== create_flags
) {
5303 *uri
= &builder
->uri
->IUri_iface
;
5308 hr
= validate_components(builder
, &data
, create_flags
);
5314 ret
= create_uri_obj();
5317 return E_OUTOFMEMORY
;
5320 hr
= generate_uri(builder
, &data
, ret
, create_flags
);
5322 IUri_Release(&ret
->IUri_iface
);
5327 *uri
= &ret
->IUri_iface
;
5331 static inline UriBuilder
* impl_from_IUriBuilder(IUriBuilder
*iface
)
5333 return CONTAINING_RECORD(iface
, UriBuilder
, IUriBuilder_iface
);
5336 static HRESULT WINAPI
UriBuilder_QueryInterface(IUriBuilder
*iface
, REFIID riid
, void **ppv
)
5338 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5340 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
5341 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
5342 *ppv
= &This
->IUriBuilder_iface
;
5343 }else if(IsEqualGUID(&IID_IUriBuilder
, riid
)) {
5344 TRACE("(%p)->(IID_IUriBuilder %p)\n", This
, ppv
);
5345 *ppv
= &This
->IUriBuilder_iface
;
5347 TRACE("(%p)->(%s %p)\n", This
, debugstr_guid(riid
), ppv
);
5349 return E_NOINTERFACE
;
5352 IUnknown_AddRef((IUnknown
*)*ppv
);
5356 static ULONG WINAPI
UriBuilder_AddRef(IUriBuilder
*iface
)
5358 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5359 LONG ref
= InterlockedIncrement(&This
->ref
);
5361 TRACE("(%p) ref=%d\n", This
, ref
);
5366 static ULONG WINAPI
UriBuilder_Release(IUriBuilder
*iface
)
5368 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5369 LONG ref
= InterlockedDecrement(&This
->ref
);
5371 TRACE("(%p) ref=%d\n", This
, ref
);
5374 if(This
->uri
) IUri_Release(&This
->uri
->IUri_iface
);
5375 heap_free(This
->fragment
);
5376 heap_free(This
->host
);
5377 heap_free(This
->password
);
5378 heap_free(This
->path
);
5379 heap_free(This
->query
);
5380 heap_free(This
->scheme
);
5381 heap_free(This
->username
);
5388 static HRESULT WINAPI
UriBuilder_CreateUriSimple(IUriBuilder
*iface
,
5389 DWORD dwAllowEncodingPropertyMask
,
5390 DWORD_PTR dwReserved
,
5393 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5395 TRACE("(%p)->(%d %d %p)\n", This
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5397 hr
= build_uri(This
, ppIUri
, 0, UriBuilder_USE_ORIGINAL_FLAGS
, dwAllowEncodingPropertyMask
);
5399 FIXME("(%p)->(%d %d %p)\n", This
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5403 static HRESULT WINAPI
UriBuilder_CreateUri(IUriBuilder
*iface
,
5404 DWORD dwCreateFlags
,
5405 DWORD dwAllowEncodingPropertyMask
,
5406 DWORD_PTR dwReserved
,
5409 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5411 TRACE("(%p)->(0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5413 if(dwCreateFlags
== -1)
5414 hr
= build_uri(This
, ppIUri
, 0, UriBuilder_USE_ORIGINAL_FLAGS
, dwAllowEncodingPropertyMask
);
5416 hr
= build_uri(This
, ppIUri
, dwCreateFlags
, 0, dwAllowEncodingPropertyMask
);
5419 FIXME("(%p)->(0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5423 static HRESULT WINAPI
UriBuilder_CreateUriWithFlags(IUriBuilder
*iface
,
5424 DWORD dwCreateFlags
,
5425 DWORD dwUriBuilderFlags
,
5426 DWORD dwAllowEncodingPropertyMask
,
5427 DWORD_PTR dwReserved
,
5430 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5432 TRACE("(%p)->(0x%08x 0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwUriBuilderFlags
,
5433 dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5435 hr
= build_uri(This
, ppIUri
, dwCreateFlags
, dwUriBuilderFlags
, dwAllowEncodingPropertyMask
);
5437 FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This
, dwCreateFlags
, dwUriBuilderFlags
,
5438 dwAllowEncodingPropertyMask
, (DWORD
)dwReserved
, ppIUri
);
5442 static HRESULT WINAPI
UriBuilder_GetIUri(IUriBuilder
*iface
, IUri
**ppIUri
)
5444 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5445 TRACE("(%p)->(%p)\n", This
, ppIUri
);
5451 IUri
*uri
= &This
->uri
->IUri_iface
;
5460 static HRESULT WINAPI
UriBuilder_SetIUri(IUriBuilder
*iface
, IUri
*pIUri
)
5462 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5463 TRACE("(%p)->(%p)\n", This
, pIUri
);
5468 if((uri
= get_uri_obj(pIUri
))) {
5469 /* Only reset the builder if it's Uri isn't the same as
5470 * the Uri passed to the function.
5472 if(This
->uri
!= uri
) {
5473 reset_builder(This
);
5477 This
->port
= uri
->port
;
5482 FIXME("(%p)->(%p) Unknown IUri types not supported yet.\n", This
, pIUri
);
5485 } else if(This
->uri
)
5486 /* Only reset the builder if it's Uri isn't NULL. */
5487 reset_builder(This
);
5492 static HRESULT WINAPI
UriBuilder_GetFragment(IUriBuilder
*iface
, DWORD
*pcchFragment
, LPCWSTR
*ppwzFragment
)
5494 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5495 TRACE("(%p)->(%p %p)\n", This
, pcchFragment
, ppwzFragment
);
5497 if(!This
->uri
|| This
->uri
->fragment_start
== -1 || This
->modified_props
& Uri_HAS_FRAGMENT
)
5498 return get_builder_component(&This
->fragment
, &This
->fragment_len
, NULL
, 0, ppwzFragment
, pcchFragment
);
5500 return get_builder_component(&This
->fragment
, &This
->fragment_len
, This
->uri
->canon_uri
+This
->uri
->fragment_start
,
5501 This
->uri
->fragment_len
, ppwzFragment
, pcchFragment
);
5504 static HRESULT WINAPI
UriBuilder_GetHost(IUriBuilder
*iface
, DWORD
*pcchHost
, LPCWSTR
*ppwzHost
)
5506 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5507 TRACE("(%p)->(%p %p)\n", This
, pcchHost
, ppwzHost
);
5509 if(!This
->uri
|| This
->uri
->host_start
== -1 || This
->modified_props
& Uri_HAS_HOST
)
5510 return get_builder_component(&This
->host
, &This
->host_len
, NULL
, 0, ppwzHost
, pcchHost
);
5512 if(This
->uri
->host_type
== Uri_HOST_IPV6
)
5513 /* Don't include the '[' and ']' around the address. */
5514 return get_builder_component(&This
->host
, &This
->host_len
, This
->uri
->canon_uri
+This
->uri
->host_start
+1,
5515 This
->uri
->host_len
-2, ppwzHost
, pcchHost
);
5517 return get_builder_component(&This
->host
, &This
->host_len
, This
->uri
->canon_uri
+This
->uri
->host_start
,
5518 This
->uri
->host_len
, ppwzHost
, pcchHost
);
5522 static HRESULT WINAPI
UriBuilder_GetPassword(IUriBuilder
*iface
, DWORD
*pcchPassword
, LPCWSTR
*ppwzPassword
)
5524 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5525 TRACE("(%p)->(%p %p)\n", This
, pcchPassword
, ppwzPassword
);
5527 if(!This
->uri
|| This
->uri
->userinfo_split
== -1 || This
->modified_props
& Uri_HAS_PASSWORD
)
5528 return get_builder_component(&This
->password
, &This
->password_len
, NULL
, 0, ppwzPassword
, pcchPassword
);
5530 const WCHAR
*start
= This
->uri
->canon_uri
+This
->uri
->userinfo_start
+This
->uri
->userinfo_split
+1;
5531 DWORD len
= This
->uri
->userinfo_len
-This
->uri
->userinfo_split
-1;
5532 return get_builder_component(&This
->password
, &This
->password_len
, start
, len
, ppwzPassword
, pcchPassword
);
5536 static HRESULT WINAPI
UriBuilder_GetPath(IUriBuilder
*iface
, DWORD
*pcchPath
, LPCWSTR
*ppwzPath
)
5538 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5539 TRACE("(%p)->(%p %p)\n", This
, pcchPath
, ppwzPath
);
5541 if(!This
->uri
|| This
->uri
->path_start
== -1 || This
->modified_props
& Uri_HAS_PATH
)
5542 return get_builder_component(&This
->path
, &This
->path_len
, NULL
, 0, ppwzPath
, pcchPath
);
5544 return get_builder_component(&This
->path
, &This
->path_len
, This
->uri
->canon_uri
+This
->uri
->path_start
,
5545 This
->uri
->path_len
, ppwzPath
, pcchPath
);
5548 static HRESULT WINAPI
UriBuilder_GetPort(IUriBuilder
*iface
, BOOL
*pfHasPort
, DWORD
*pdwPort
)
5550 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5551 TRACE("(%p)->(%p %p)\n", This
, pfHasPort
, pdwPort
);
5564 *pfHasPort
= This
->has_port
;
5565 *pdwPort
= This
->port
;
5569 static HRESULT WINAPI
UriBuilder_GetQuery(IUriBuilder
*iface
, DWORD
*pcchQuery
, LPCWSTR
*ppwzQuery
)
5571 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5572 TRACE("(%p)->(%p %p)\n", This
, pcchQuery
, ppwzQuery
);
5574 if(!This
->uri
|| This
->uri
->query_start
== -1 || This
->modified_props
& Uri_HAS_QUERY
)
5575 return get_builder_component(&This
->query
, &This
->query_len
, NULL
, 0, ppwzQuery
, pcchQuery
);
5577 return get_builder_component(&This
->query
, &This
->query_len
, This
->uri
->canon_uri
+This
->uri
->query_start
,
5578 This
->uri
->query_len
, ppwzQuery
, pcchQuery
);
5581 static HRESULT WINAPI
UriBuilder_GetSchemeName(IUriBuilder
*iface
, DWORD
*pcchSchemeName
, LPCWSTR
*ppwzSchemeName
)
5583 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5584 TRACE("(%p)->(%p %p)\n", This
, pcchSchemeName
, ppwzSchemeName
);
5586 if(!This
->uri
|| This
->uri
->scheme_start
== -1 || This
->modified_props
& Uri_HAS_SCHEME_NAME
)
5587 return get_builder_component(&This
->scheme
, &This
->scheme_len
, NULL
, 0, ppwzSchemeName
, pcchSchemeName
);
5589 return get_builder_component(&This
->scheme
, &This
->scheme_len
, This
->uri
->canon_uri
+This
->uri
->scheme_start
,
5590 This
->uri
->scheme_len
, ppwzSchemeName
, pcchSchemeName
);
5593 static HRESULT WINAPI
UriBuilder_GetUserName(IUriBuilder
*iface
, DWORD
*pcchUserName
, LPCWSTR
*ppwzUserName
)
5595 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5596 TRACE("(%p)->(%p %p)\n", This
, pcchUserName
, ppwzUserName
);
5598 if(!This
->uri
|| This
->uri
->userinfo_start
== -1 || This
->uri
->userinfo_split
== 0 ||
5599 This
->modified_props
& Uri_HAS_USER_NAME
)
5600 return get_builder_component(&This
->username
, &This
->username_len
, NULL
, 0, ppwzUserName
, pcchUserName
);
5602 const WCHAR
*start
= This
->uri
->canon_uri
+This
->uri
->userinfo_start
;
5604 /* Check if there's a password in the userinfo section. */
5605 if(This
->uri
->userinfo_split
> -1)
5606 /* Don't include the password. */
5607 return get_builder_component(&This
->username
, &This
->username_len
, start
,
5608 This
->uri
->userinfo_split
, ppwzUserName
, pcchUserName
);
5610 return get_builder_component(&This
->username
, &This
->username_len
, start
,
5611 This
->uri
->userinfo_len
, ppwzUserName
, pcchUserName
);
5615 static HRESULT WINAPI
UriBuilder_SetFragment(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5617 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5618 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5619 return set_builder_component(&This
->fragment
, &This
->fragment_len
, pwzNewValue
, '#',
5620 &This
->modified_props
, Uri_HAS_FRAGMENT
);
5623 static HRESULT WINAPI
UriBuilder_SetHost(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5625 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5626 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5628 /* Host name can't be set to NULL. */
5630 return E_INVALIDARG
;
5632 return set_builder_component(&This
->host
, &This
->host_len
, pwzNewValue
, 0,
5633 &This
->modified_props
, Uri_HAS_HOST
);
5636 static HRESULT WINAPI
UriBuilder_SetPassword(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5638 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5639 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5640 return set_builder_component(&This
->password
, &This
->password_len
, pwzNewValue
, 0,
5641 &This
->modified_props
, Uri_HAS_PASSWORD
);
5644 static HRESULT WINAPI
UriBuilder_SetPath(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5646 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5647 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5648 return set_builder_component(&This
->path
, &This
->path_len
, pwzNewValue
, 0,
5649 &This
->modified_props
, Uri_HAS_PATH
);
5652 static HRESULT WINAPI
UriBuilder_SetPort(IUriBuilder
*iface
, BOOL fHasPort
, DWORD dwNewValue
)
5654 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5655 TRACE("(%p)->(%d %d)\n", This
, fHasPort
, dwNewValue
);
5657 This
->has_port
= fHasPort
;
5658 This
->port
= dwNewValue
;
5659 This
->modified_props
|= Uri_HAS_PORT
;
5663 static HRESULT WINAPI
UriBuilder_SetQuery(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5665 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5666 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5667 return set_builder_component(&This
->query
, &This
->query_len
, pwzNewValue
, '?',
5668 &This
->modified_props
, Uri_HAS_QUERY
);
5671 static HRESULT WINAPI
UriBuilder_SetSchemeName(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5673 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5674 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5676 /* Only set the scheme name if it's not NULL or empty. */
5677 if(!pwzNewValue
|| !*pwzNewValue
)
5678 return E_INVALIDARG
;
5680 return set_builder_component(&This
->scheme
, &This
->scheme_len
, pwzNewValue
, 0,
5681 &This
->modified_props
, Uri_HAS_SCHEME_NAME
);
5684 static HRESULT WINAPI
UriBuilder_SetUserName(IUriBuilder
*iface
, LPCWSTR pwzNewValue
)
5686 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5687 TRACE("(%p)->(%s)\n", This
, debugstr_w(pwzNewValue
));
5688 return set_builder_component(&This
->username
, &This
->username_len
, pwzNewValue
, 0,
5689 &This
->modified_props
, Uri_HAS_USER_NAME
);
5692 static HRESULT WINAPI
UriBuilder_RemoveProperties(IUriBuilder
*iface
, DWORD dwPropertyMask
)
5694 const DWORD accepted_flags
= Uri_HAS_AUTHORITY
|Uri_HAS_DOMAIN
|Uri_HAS_EXTENSION
|Uri_HAS_FRAGMENT
|Uri_HAS_HOST
|
5695 Uri_HAS_PASSWORD
|Uri_HAS_PATH
|Uri_HAS_PATH_AND_QUERY
|Uri_HAS_QUERY
|
5696 Uri_HAS_USER_INFO
|Uri_HAS_USER_NAME
;
5698 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5699 TRACE("(%p)->(0x%08x)\n", This
, dwPropertyMask
);
5701 if(dwPropertyMask
& ~accepted_flags
)
5702 return E_INVALIDARG
;
5704 if(dwPropertyMask
& Uri_HAS_FRAGMENT
)
5705 UriBuilder_SetFragment(iface
, NULL
);
5707 /* Even though you can't set the host name to NULL or an
5708 * empty string, you can still remove it... for some reason.
5710 if(dwPropertyMask
& Uri_HAS_HOST
)
5711 set_builder_component(&This
->host
, &This
->host_len
, NULL
, 0,
5712 &This
->modified_props
, Uri_HAS_HOST
);
5714 if(dwPropertyMask
& Uri_HAS_PASSWORD
)
5715 UriBuilder_SetPassword(iface
, NULL
);
5717 if(dwPropertyMask
& Uri_HAS_PATH
)
5718 UriBuilder_SetPath(iface
, NULL
);
5720 if(dwPropertyMask
& Uri_HAS_PORT
)
5721 UriBuilder_SetPort(iface
, FALSE
, 0);
5723 if(dwPropertyMask
& Uri_HAS_QUERY
)
5724 UriBuilder_SetQuery(iface
, NULL
);
5726 if(dwPropertyMask
& Uri_HAS_USER_NAME
)
5727 UriBuilder_SetUserName(iface
, NULL
);
5732 static HRESULT WINAPI
UriBuilder_HasBeenModified(IUriBuilder
*iface
, BOOL
*pfModified
)
5734 UriBuilder
*This
= impl_from_IUriBuilder(iface
);
5735 TRACE("(%p)->(%p)\n", This
, pfModified
);
5740 *pfModified
= This
->modified_props
> 0;
5744 static const IUriBuilderVtbl UriBuilderVtbl
= {
5745 UriBuilder_QueryInterface
,
5748 UriBuilder_CreateUriSimple
,
5749 UriBuilder_CreateUri
,
5750 UriBuilder_CreateUriWithFlags
,
5753 UriBuilder_GetFragment
,
5755 UriBuilder_GetPassword
,
5758 UriBuilder_GetQuery
,
5759 UriBuilder_GetSchemeName
,
5760 UriBuilder_GetUserName
,
5761 UriBuilder_SetFragment
,
5763 UriBuilder_SetPassword
,
5766 UriBuilder_SetQuery
,
5767 UriBuilder_SetSchemeName
,
5768 UriBuilder_SetUserName
,
5769 UriBuilder_RemoveProperties
,
5770 UriBuilder_HasBeenModified
,
5773 /***********************************************************************
5774 * CreateIUriBuilder (urlmon.@)
5776 HRESULT WINAPI
CreateIUriBuilder(IUri
*pIUri
, DWORD dwFlags
, DWORD_PTR dwReserved
, IUriBuilder
**ppIUriBuilder
)
5780 TRACE("(%p %x %x %p)\n", pIUri
, dwFlags
, (DWORD
)dwReserved
, ppIUriBuilder
);
5785 ret
= heap_alloc_zero(sizeof(UriBuilder
));
5787 return E_OUTOFMEMORY
;
5789 ret
->IUriBuilder_iface
.lpVtbl
= &UriBuilderVtbl
;
5795 if((uri
= get_uri_obj(pIUri
))) {
5800 /* Windows doesn't set 'has_port' to TRUE in this case. */
5801 ret
->port
= uri
->port
;
5805 *ppIUriBuilder
= NULL
;
5806 FIXME("(%p %x %x %p): Unknown IUri types not supported yet.\n", pIUri
, dwFlags
,
5807 (DWORD
)dwReserved
, ppIUriBuilder
);
5812 *ppIUriBuilder
= &ret
->IUriBuilder_iface
;
5816 /* Merges the base path with the relative path and stores the resulting path
5817 * and path len in 'result' and 'result_len'.
5819 static HRESULT
merge_paths(parse_data
*data
, const WCHAR
*base
, DWORD base_len
, const WCHAR
*relative
,
5820 DWORD relative_len
, WCHAR
**result
, DWORD
*result_len
, DWORD flags
)
5822 const WCHAR
*end
= NULL
;
5823 DWORD base_copy_len
= 0;
5827 /* Find the characters that will be copied over from
5830 end
= memrchrW(base
, '/', base_len
);
5831 if(!end
&& data
->scheme_type
== URL_SCHEME_FILE
)
5832 /* Try looking for a '\\'. */
5833 end
= memrchrW(base
, '\\', base_len
);
5837 base_copy_len
= (end
+1)-base
;
5838 *result
= heap_alloc((base_copy_len
+relative_len
+1)*sizeof(WCHAR
));
5840 *result
= heap_alloc((relative_len
+1)*sizeof(WCHAR
));
5844 return E_OUTOFMEMORY
;
5849 memcpy(ptr
, base
, base_copy_len
*sizeof(WCHAR
));
5850 ptr
+= base_copy_len
;
5853 memcpy(ptr
, relative
, relative_len
*sizeof(WCHAR
));
5854 ptr
+= relative_len
;
5857 *result_len
= (ptr
-*result
);
5861 static HRESULT
combine_uri(Uri
*base
, Uri
*relative
, DWORD flags
, IUri
**result
, DWORD extras
) {
5865 DWORD create_flags
= 0, len
= 0;
5867 memset(&data
, 0, sizeof(parse_data
));
5869 /* Base case is when the relative Uri has a scheme name,
5870 * if it does, then 'result' will contain the same data
5871 * as the relative Uri.
5873 if(relative
->scheme_start
> -1) {
5874 data
.uri
= SysAllocString(relative
->raw_uri
);
5877 return E_OUTOFMEMORY
;
5880 parse_uri(&data
, 0);
5882 ret
= create_uri_obj();
5885 return E_OUTOFMEMORY
;
5888 if(extras
& COMBINE_URI_FORCE_FLAG_USE
) {
5889 if(flags
& URL_DONT_SIMPLIFY
)
5890 create_flags
|= Uri_CREATE_NO_CANONICALIZE
;
5891 if(flags
& URL_DONT_UNESCAPE_EXTRA_INFO
)
5892 create_flags
|= Uri_CREATE_NO_DECODE_EXTRA_INFO
;
5895 ret
->raw_uri
= data
.uri
;
5896 hr
= canonicalize_uri(&data
, ret
, create_flags
);
5898 IUri_Release(&ret
->IUri_iface
);
5903 apply_default_flags(&create_flags
);
5904 ret
->create_flags
= create_flags
;
5906 *result
= &ret
->IUri_iface
;
5909 DWORD raw_flags
= 0;
5911 if(base
->scheme_start
> -1) {
5912 data
.scheme
= base
->canon_uri
+base
->scheme_start
;
5913 data
.scheme_len
= base
->scheme_len
;
5914 data
.scheme_type
= base
->scheme_type
;
5916 data
.is_relative
= TRUE
;
5917 data
.scheme_type
= URL_SCHEME_UNKNOWN
;
5918 create_flags
|= Uri_CREATE_ALLOW_RELATIVE
;
5921 if(base
->authority_start
> -1) {
5922 if(base
->userinfo_start
> -1 && base
->userinfo_split
!= 0) {
5923 data
.username
= base
->canon_uri
+base
->userinfo_start
;
5924 data
.username_len
= (base
->userinfo_split
> -1) ? base
->userinfo_split
: base
->userinfo_len
;
5927 if(base
->userinfo_split
> -1) {
5928 data
.password
= base
->canon_uri
+base
->userinfo_start
+base
->userinfo_split
+1;
5929 data
.password_len
= base
->userinfo_len
-base
->userinfo_split
-1;
5932 if(base
->host_start
> -1) {
5933 data
.host
= base
->canon_uri
+base
->host_start
;
5934 data
.host_len
= base
->host_len
;
5935 data
.host_type
= base
->host_type
;
5938 if(base
->has_port
) {
5939 data
.has_port
= TRUE
;
5940 data
.port_value
= base
->port
;
5942 } else if(base
->scheme_type
!= URL_SCHEME_FILE
)
5943 data
.is_opaque
= TRUE
;
5945 if(relative
->path_start
== -1 || !relative
->path_len
) {
5946 if(base
->path_start
> -1) {
5947 data
.path
= base
->canon_uri
+base
->path_start
;
5948 data
.path_len
= base
->path_len
;
5949 } else if((base
->path_start
== -1 || !base
->path_len
) && !data
.is_opaque
) {
5950 /* Just set the path as a '/' if the base didn't have
5951 * one and if it's an hierarchical URI.
5953 static const WCHAR slashW
[] = {'/',0};
5958 if(relative
->query_start
> -1) {
5959 data
.query
= relative
->canon_uri
+relative
->query_start
;
5960 data
.query_len
= relative
->query_len
;
5961 } else if(base
->query_start
> -1) {
5962 data
.query
= base
->canon_uri
+base
->query_start
;
5963 data
.query_len
= base
->query_len
;
5966 const WCHAR
*ptr
, **pptr
;
5967 DWORD path_offset
= 0, path_len
= 0;
5969 /* There's two possibilities on what will happen to the path component
5970 * of the result IUri. First, if the relative path begins with a '/'
5971 * then the resulting path will just be the relative path. Second, if
5972 * relative path doesn't begin with a '/' then the base path and relative
5973 * path are merged together.
5975 if(relative
->path_len
&& *(relative
->canon_uri
+relative
->path_start
) == '/') {
5977 BOOL copy_drive_path
= FALSE
;
5979 /* If the relative IUri's path starts with a '/', then we
5980 * don't use the base IUri's path. Unless the base IUri
5981 * is a file URI, in which case it uses the drive path of
5982 * the base IUri (if it has any) in the new path.
5984 if(base
->scheme_type
== URL_SCHEME_FILE
) {
5985 if(base
->path_len
> 3 && *(base
->canon_uri
+base
->path_start
) == '/' &&
5986 is_drive_path(base
->canon_uri
+base
->path_start
+1)) {
5988 copy_drive_path
= TRUE
;
5992 path_len
+= relative
->path_len
;
5994 path
= heap_alloc((path_len
+1)*sizeof(WCHAR
));
5997 return E_OUTOFMEMORY
;
6002 /* Copy the base paths, drive path over. */
6003 if(copy_drive_path
) {
6004 memcpy(tmp
, base
->canon_uri
+base
->path_start
, 3*sizeof(WCHAR
));
6008 memcpy(tmp
, relative
->canon_uri
+relative
->path_start
, relative
->path_len
*sizeof(WCHAR
));
6009 path
[path_len
] = '\0';
6011 /* Merge the base path with the relative path. */
6012 hr
= merge_paths(&data
, base
->canon_uri
+base
->path_start
, base
->path_len
,
6013 relative
->canon_uri
+relative
->path_start
, relative
->path_len
,
6014 &path
, &path_len
, flags
);
6020 /* If the resulting IUri is a file URI, the drive path isn't
6021 * reduced out when the dot segments are removed.
6023 if(path_len
>= 3 && data
.scheme_type
== URL_SCHEME_FILE
&& !data
.host
) {
6024 if(*path
== '/' && is_drive_path(path
+1))
6026 else if(is_drive_path(path
))
6031 /* Check if the dot segments need to be removed from the path. */
6032 if(!(flags
& URL_DONT_SIMPLIFY
) && !data
.is_opaque
) {
6033 DWORD offset
= (path_offset
> 0) ? path_offset
+1 : 0;
6034 DWORD new_len
= remove_dot_segments(path
+offset
,path_len
-offset
);
6036 if(new_len
!= path_len
) {
6037 WCHAR
*tmp
= heap_realloc(path
, (offset
+new_len
+1)*sizeof(WCHAR
));
6041 return E_OUTOFMEMORY
;
6044 tmp
[new_len
+offset
] = '\0';
6046 path_len
= new_len
+offset
;
6050 if(relative
->query_start
> -1) {
6051 data
.query
= relative
->canon_uri
+relative
->query_start
;
6052 data
.query_len
= relative
->query_len
;
6055 /* Make sure the path component is valid. */
6058 if((data
.is_opaque
&& !parse_path_opaque(pptr
, &data
, 0)) ||
6059 (!data
.is_opaque
&& !parse_path_hierarchical(pptr
, &data
, 0))) {
6062 return E_INVALIDARG
;
6066 if(relative
->fragment_start
> -1) {
6067 data
.fragment
= relative
->canon_uri
+relative
->fragment_start
;
6068 data
.fragment_len
= relative
->fragment_len
;
6071 if(flags
& URL_DONT_SIMPLIFY
)
6072 raw_flags
|= RAW_URI_FORCE_PORT_DISP
;
6073 if(flags
& URL_FILE_USE_PATHURL
)
6074 raw_flags
|= RAW_URI_CONVERT_TO_DOS_PATH
;
6076 len
= generate_raw_uri(&data
, data
.uri
, raw_flags
);
6077 data
.uri
= SysAllocStringLen(NULL
, len
);
6081 return E_OUTOFMEMORY
;
6084 generate_raw_uri(&data
, data
.uri
, raw_flags
);
6086 ret
= create_uri_obj();
6088 SysFreeString(data
.uri
);
6091 return E_OUTOFMEMORY
;
6094 if(flags
& URL_DONT_SIMPLIFY
)
6095 create_flags
|= Uri_CREATE_NO_CANONICALIZE
;
6096 if(flags
& URL_FILE_USE_PATHURL
)
6097 create_flags
|= Uri_CREATE_FILE_USE_DOS_PATH
;
6099 ret
->raw_uri
= data
.uri
;
6100 hr
= canonicalize_uri(&data
, ret
, create_flags
);
6102 IUri_Release(&ret
->IUri_iface
);
6107 if(flags
& URL_DONT_SIMPLIFY
)
6108 ret
->display_modifiers
|= URI_DISPLAY_NO_DEFAULT_PORT_AUTH
;
6110 apply_default_flags(&create_flags
);
6111 ret
->create_flags
= create_flags
;
6112 *result
= &ret
->IUri_iface
;
6120 /***********************************************************************
6121 * CoInternetCombineIUri (urlmon.@)
6123 HRESULT WINAPI
CoInternetCombineIUri(IUri
*pBaseUri
, IUri
*pRelativeUri
, DWORD dwCombineFlags
,
6124 IUri
**ppCombinedUri
, DWORD_PTR dwReserved
)
6127 IInternetProtocolInfo
*info
;
6128 Uri
*relative
, *base
;
6129 TRACE("(%p %p %x %p %x)\n", pBaseUri
, pRelativeUri
, dwCombineFlags
, ppCombinedUri
, (DWORD
)dwReserved
);
6132 return E_INVALIDARG
;
6134 if(!pBaseUri
|| !pRelativeUri
) {
6135 *ppCombinedUri
= NULL
;
6136 return E_INVALIDARG
;
6139 relative
= get_uri_obj(pRelativeUri
);
6140 base
= get_uri_obj(pBaseUri
);
6141 if(!relative
|| !base
) {
6142 *ppCombinedUri
= NULL
;
6143 FIXME("(%p %p %x %p %x) Unknown IUri types not supported yet.\n",
6144 pBaseUri
, pRelativeUri
, dwCombineFlags
, ppCombinedUri
, (DWORD
)dwReserved
);
6148 info
= get_protocol_info(base
->canon_uri
);
6150 WCHAR result
[INTERNET_MAX_URL_LENGTH
+1];
6151 DWORD result_len
= 0;
6153 hr
= IInternetProtocolInfo_CombineUrl(info
, base
->canon_uri
, relative
->canon_uri
, dwCombineFlags
,
6154 result
, INTERNET_MAX_URL_LENGTH
+1, &result_len
, 0);
6155 IInternetProtocolInfo_Release(info
);
6157 hr
= CreateUri(result
, Uri_CREATE_ALLOW_RELATIVE
, 0, ppCombinedUri
);
6163 return combine_uri(base
, relative
, dwCombineFlags
, ppCombinedUri
, 0);
6166 /***********************************************************************
6167 * CoInternetCombineUrlEx (urlmon.@)
6169 HRESULT WINAPI
CoInternetCombineUrlEx(IUri
*pBaseUri
, LPCWSTR pwzRelativeUrl
, DWORD dwCombineFlags
,
6170 IUri
**ppCombinedUri
, DWORD_PTR dwReserved
)
6175 IInternetProtocolInfo
*info
;
6177 TRACE("(%p %s %x %p %x) stub\n", pBaseUri
, debugstr_w(pwzRelativeUrl
), dwCombineFlags
,
6178 ppCombinedUri
, (DWORD
)dwReserved
);
6183 if(!pwzRelativeUrl
) {
6184 *ppCombinedUri
= NULL
;
6185 return E_UNEXPECTED
;
6189 *ppCombinedUri
= NULL
;
6190 return E_INVALIDARG
;
6193 base
= get_uri_obj(pBaseUri
);
6195 *ppCombinedUri
= NULL
;
6196 FIXME("(%p %s %x %p %x) Unknown IUri's not supported yet.\n", pBaseUri
, debugstr_w(pwzRelativeUrl
),
6197 dwCombineFlags
, ppCombinedUri
, (DWORD
)dwReserved
);
6201 info
= get_protocol_info(base
->canon_uri
);
6203 WCHAR result
[INTERNET_MAX_URL_LENGTH
+1];
6204 DWORD result_len
= 0;
6206 hr
= IInternetProtocolInfo_CombineUrl(info
, base
->canon_uri
, pwzRelativeUrl
, dwCombineFlags
,
6207 result
, INTERNET_MAX_URL_LENGTH
+1, &result_len
, 0);
6208 IInternetProtocolInfo_Release(info
);
6210 hr
= CreateUri(result
, Uri_CREATE_ALLOW_RELATIVE
, 0, ppCombinedUri
);
6216 hr
= CreateUri(pwzRelativeUrl
, Uri_CREATE_ALLOW_RELATIVE
, 0, &relative
);
6218 *ppCombinedUri
= NULL
;
6222 hr
= combine_uri(base
, get_uri_obj(relative
), dwCombineFlags
, ppCombinedUri
, COMBINE_URI_FORCE_FLAG_USE
);
6224 IUri_Release(relative
);
6228 static HRESULT
parse_canonicalize(const Uri
*uri
, DWORD flags
, LPWSTR output
,
6229 DWORD output_len
, DWORD
*result_len
)
6231 const WCHAR
*ptr
= NULL
;
6234 WCHAR buffer
[INTERNET_MAX_URL_LENGTH
+1];
6238 /* URL_UNESCAPE only has effect if none of the URL_ESCAPE flags are set. */
6239 const BOOL allow_unescape
= !(flags
& URL_ESCAPE_UNSAFE
) &&
6240 !(flags
& URL_ESCAPE_SPACES_ONLY
) &&
6241 !(flags
& URL_ESCAPE_PERCENT
);
6244 /* Check if the dot segments need to be removed from the
6247 if(uri
->scheme_start
> -1 && uri
->path_start
> -1) {
6248 ptr
= uri
->canon_uri
+uri
->scheme_start
+uri
->scheme_len
+1;
6251 reduce_path
= !(flags
& URL_NO_META
) &&
6252 !(flags
& URL_DONT_SIMPLIFY
) &&
6253 ptr
&& check_hierarchical(pptr
);
6255 for(ptr
= uri
->canon_uri
; ptr
< uri
->canon_uri
+uri
->canon_len
; ++ptr
) {
6256 BOOL do_default_action
= TRUE
;
6258 /* Keep track of the path if we need to remove dot segments from
6261 if(reduce_path
&& !path
&& ptr
== uri
->canon_uri
+uri
->path_start
)
6264 /* Check if it's time to reduce the path. */
6265 if(reduce_path
&& ptr
== uri
->canon_uri
+uri
->path_start
+uri
->path_len
) {
6266 DWORD current_path_len
= (buffer
+len
) - path
;
6267 DWORD new_path_len
= remove_dot_segments(path
, current_path_len
);
6269 /* Update the current length. */
6270 len
-= (current_path_len
-new_path_len
);
6271 reduce_path
= FALSE
;
6275 const WCHAR decoded
= decode_pct_val(ptr
);
6277 if(allow_unescape
&& (flags
& URL_UNESCAPE
)) {
6278 buffer
[len
++] = decoded
;
6280 do_default_action
= FALSE
;
6284 /* See if %'s needed to encoded. */
6285 if(do_default_action
&& (flags
& URL_ESCAPE_PERCENT
)) {
6286 pct_encode_val(*ptr
, buffer
+len
);
6288 do_default_action
= FALSE
;
6290 } else if(*ptr
== ' ') {
6291 if((flags
& URL_ESCAPE_SPACES_ONLY
) &&
6292 !(flags
& URL_ESCAPE_UNSAFE
)) {
6293 pct_encode_val(*ptr
, buffer
+len
);
6295 do_default_action
= FALSE
;
6297 } else if(!is_reserved(*ptr
) && !is_unreserved(*ptr
)) {
6298 if(flags
& URL_ESCAPE_UNSAFE
) {
6299 pct_encode_val(*ptr
, buffer
+len
);
6301 do_default_action
= FALSE
;
6305 if(do_default_action
)
6306 buffer
[len
++] = *ptr
;
6309 /* Sometimes the path is the very last component of the IUri, so
6310 * see if the dot segments need to be reduced now.
6312 if(reduce_path
&& path
) {
6313 DWORD current_path_len
= (buffer
+len
) - path
;
6314 DWORD new_path_len
= remove_dot_segments(path
, current_path_len
);
6316 /* Update the current length. */
6317 len
-= (current_path_len
-new_path_len
);
6322 /* The null terminator isn't included in the length. */
6323 *result_len
= len
-1;
6324 if(len
> output_len
)
6325 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6327 memcpy(output
, buffer
, len
*sizeof(WCHAR
));
6332 static HRESULT
parse_friendly(IUri
*uri
, LPWSTR output
, DWORD output_len
,
6339 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_DISPLAY_URI
, &display_len
, 0);
6345 *result_len
= display_len
;
6346 if(display_len
+1 > output_len
)
6347 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6349 hr
= IUri_GetDisplayUri(uri
, &display
);
6355 memcpy(output
, display
, (display_len
+1)*sizeof(WCHAR
));
6356 SysFreeString(display
);
6360 static HRESULT
parse_rootdocument(const Uri
*uri
, LPWSTR output
, DWORD output_len
,
6363 static const WCHAR colon_slashesW
[] = {':','/','/'};
6368 /* Windows only returns the root document if the URI has an authority
6369 * and it's not an unknown scheme type or a file scheme type.
6371 if(uri
->authority_start
== -1 ||
6372 uri
->scheme_type
== URL_SCHEME_UNKNOWN
||
6373 uri
->scheme_type
== URL_SCHEME_FILE
) {
6376 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6382 len
= uri
->scheme_len
+uri
->authority_len
;
6383 /* For the "://" and '/' which will be added. */
6386 if(len
+1 > output_len
) {
6388 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6392 memcpy(ptr
, uri
->canon_uri
+uri
->scheme_start
, uri
->scheme_len
*sizeof(WCHAR
));
6394 /* Add the "://". */
6395 ptr
+= uri
->scheme_len
;
6396 memcpy(ptr
, colon_slashesW
, sizeof(colon_slashesW
));
6398 /* Add the authority. */
6399 ptr
+= sizeof(colon_slashesW
)/sizeof(WCHAR
);
6400 memcpy(ptr
, uri
->canon_uri
+uri
->authority_start
, uri
->authority_len
*sizeof(WCHAR
));
6402 /* Add the '/' after the authority. */
6403 ptr
+= uri
->authority_len
;
6411 static HRESULT
parse_document(const Uri
*uri
, LPWSTR output
, DWORD output_len
,
6416 /* It has to be a known scheme type, but, it can't be a file
6417 * scheme. It also has to hierarchical.
6419 if(uri
->scheme_type
== URL_SCHEME_UNKNOWN
||
6420 uri
->scheme_type
== URL_SCHEME_FILE
||
6421 uri
->authority_start
== -1) {
6424 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6430 if(uri
->fragment_start
> -1)
6431 len
= uri
->fragment_start
;
6433 len
= uri
->canon_len
;
6436 if(len
+1 > output_len
)
6437 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6439 memcpy(output
, uri
->canon_uri
, len
*sizeof(WCHAR
));
6444 static HRESULT
parse_path_from_url(const Uri
*uri
, LPWSTR output
, DWORD output_len
,
6447 const WCHAR
*path_ptr
;
6448 WCHAR buffer
[INTERNET_MAX_URL_LENGTH
+1];
6451 if(uri
->scheme_type
!= URL_SCHEME_FILE
) {
6455 return E_INVALIDARG
;
6459 if(uri
->host_start
> -1) {
6460 static const WCHAR slash_slashW
[] = {'\\','\\'};
6462 memcpy(ptr
, slash_slashW
, sizeof(slash_slashW
));
6463 ptr
+= sizeof(slash_slashW
)/sizeof(WCHAR
);
6464 memcpy(ptr
, uri
->canon_uri
+uri
->host_start
, uri
->host_len
*sizeof(WCHAR
));
6465 ptr
+= uri
->host_len
;
6468 path_ptr
= uri
->canon_uri
+uri
->path_start
;
6469 if(uri
->path_len
> 3 && *path_ptr
== '/' && is_drive_path(path_ptr
+1))
6470 /* Skip past the '/' in front of the drive path. */
6473 for(; path_ptr
< uri
->canon_uri
+uri
->path_start
+uri
->path_len
; ++path_ptr
, ++ptr
) {
6474 BOOL do_default_action
= TRUE
;
6476 if(*path_ptr
== '%') {
6477 const WCHAR decoded
= decode_pct_val(path_ptr
);
6481 do_default_action
= FALSE
;
6483 } else if(*path_ptr
== '/') {
6485 do_default_action
= FALSE
;
6488 if(do_default_action
)
6494 *result_len
= ptr
-buffer
;
6495 if(*result_len
+1 > output_len
)
6496 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6498 memcpy(output
, buffer
, (*result_len
+1)*sizeof(WCHAR
));
6502 static HRESULT
parse_url_from_path(IUri
*uri
, LPWSTR output
, DWORD output_len
,
6509 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_ABSOLUTE_URI
, &len
, 0);
6516 if(len
+1 > output_len
)
6517 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6519 hr
= IUri_GetAbsoluteUri(uri
, &received
);
6525 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6526 SysFreeString(received
);
6531 static HRESULT
parse_schema(IUri
*uri
, LPWSTR output
, DWORD output_len
,
6538 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_SCHEME_NAME
, &len
, 0);
6545 if(len
+1 > output_len
)
6546 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6548 hr
= IUri_GetSchemeName(uri
, &received
);
6554 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6555 SysFreeString(received
);
6560 static HRESULT
parse_site(IUri
*uri
, LPWSTR output
, DWORD output_len
, DWORD
*result_len
)
6566 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_HOST
, &len
, 0);
6573 if(len
+1 > output_len
)
6574 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6576 hr
= IUri_GetHost(uri
, &received
);
6582 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6583 SysFreeString(received
);
6588 static HRESULT
parse_domain(IUri
*uri
, LPWSTR output
, DWORD output_len
, DWORD
*result_len
)
6594 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_DOMAIN
, &len
, 0);
6601 if(len
+1 > output_len
)
6602 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6604 hr
= IUri_GetDomain(uri
, &received
);
6610 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6611 SysFreeString(received
);
6616 static HRESULT
parse_anchor(IUri
*uri
, LPWSTR output
, DWORD output_len
, DWORD
*result_len
)
6622 hr
= IUri_GetPropertyLength(uri
, Uri_PROPERTY_FRAGMENT
, &len
, 0);
6629 if(len
+1 > output_len
)
6630 return STRSAFE_E_INSUFFICIENT_BUFFER
;
6632 hr
= IUri_GetFragment(uri
, &received
);
6638 memcpy(output
, received
, (len
+1)*sizeof(WCHAR
));
6639 SysFreeString(received
);
6644 /***********************************************************************
6645 * CoInternetParseIUri (urlmon.@)
6647 HRESULT WINAPI
CoInternetParseIUri(IUri
*pIUri
, PARSEACTION ParseAction
, DWORD dwFlags
,
6648 LPWSTR pwzResult
, DWORD cchResult
, DWORD
*pcchResult
,
6649 DWORD_PTR dwReserved
)
6653 IInternetProtocolInfo
*info
;
6655 TRACE("(%p %d %x %p %d %p %x)\n", pIUri
, ParseAction
, dwFlags
, pwzResult
,
6656 cchResult
, pcchResult
, (DWORD
)dwReserved
);
6661 if(!pwzResult
|| !pIUri
) {
6663 return E_INVALIDARG
;
6666 if(!(uri
= get_uri_obj(pIUri
))) {
6668 FIXME("(%p %d %x %p %d %p %x) Unknown IUri's not supported for this action.\n",
6669 pIUri
, ParseAction
, dwFlags
, pwzResult
, cchResult
, pcchResult
, (DWORD
)dwReserved
);
6673 info
= get_protocol_info(uri
->canon_uri
);
6675 hr
= IInternetProtocolInfo_ParseUrl(info
, uri
->canon_uri
, ParseAction
, dwFlags
,
6676 pwzResult
, cchResult
, pcchResult
, 0);
6677 IInternetProtocolInfo_Release(info
);
6678 if(SUCCEEDED(hr
)) return hr
;
6681 switch(ParseAction
) {
6682 case PARSE_CANONICALIZE
:
6683 hr
= parse_canonicalize(uri
, dwFlags
, pwzResult
, cchResult
, pcchResult
);
6685 case PARSE_FRIENDLY
:
6686 hr
= parse_friendly(pIUri
, pwzResult
, cchResult
, pcchResult
);
6688 case PARSE_ROOTDOCUMENT
:
6689 hr
= parse_rootdocument(uri
, pwzResult
, cchResult
, pcchResult
);
6691 case PARSE_DOCUMENT
:
6692 hr
= parse_document(uri
, pwzResult
, cchResult
, pcchResult
);
6694 case PARSE_PATH_FROM_URL
:
6695 hr
= parse_path_from_url(uri
, pwzResult
, cchResult
, pcchResult
);
6697 case PARSE_URL_FROM_PATH
:
6698 hr
= parse_url_from_path(pIUri
, pwzResult
, cchResult
, pcchResult
);
6701 hr
= parse_schema(pIUri
, pwzResult
, cchResult
, pcchResult
);
6704 hr
= parse_site(pIUri
, pwzResult
, cchResult
, pcchResult
);
6707 hr
= parse_domain(pIUri
, pwzResult
, cchResult
, pcchResult
);
6709 case PARSE_LOCATION
:
6711 hr
= parse_anchor(pIUri
, pwzResult
, cchResult
, pcchResult
);
6713 case PARSE_SECURITY_URL
:
6716 case PARSE_SECURITY_DOMAIN
:
6723 FIXME("(%p %d %x %p %d %p %x) Partial stub.\n", pIUri
, ParseAction
, dwFlags
,
6724 pwzResult
, cchResult
, pcchResult
, (DWORD
)dwReserved
);