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
26 #define UINT_MAX 0xffffffff
27 #define USHORT_MAX 0xffff
29 #define ALLOW_NULL_TERM_SCHEME 0x01
30 #define ALLOW_NULL_TERM_USER_NAME 0x02
31 #define ALLOW_NULL_TERM_PASSWORD 0x04
32 #define ALLOW_BRACKETLESS_IP_LITERAL 0x08
33 #define SKIP_IP_FUTURE_CHECK 0x10
34 #define IGNORE_PORT_DELIMITER 0x20
36 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
38 static const IID IID_IUriObj = {0x4b364760,0x9f51,0x11df,{0x98,0x1c,0x08,0x00,0x20,0x0c,0x9a,0x66}};
41 const IUriVtbl *lpIUriVtbl;
46 /* Information about the canonicalized URI's buffer. */
50 BOOL display_absolute;
55 URL_SCHEME scheme_type;
63 Uri_HOST_TYPE host_type;
85 const IUriBuilderVtbl *lpIUriBuilderVtbl;
122 /* IPv6 addresses can hold up to 8 h16 components. */
126 /* An IPv6 can have 1 elision ("::"). */
127 const WCHAR *elision;
129 /* An IPv6 can contain 1 IPv4 address as the last 32bits of the address. */
142 BOOL has_implicit_scheme;
143 BOOL has_implicit_ip;
148 URL_SCHEME scheme_type;
150 const WCHAR *username;
153 const WCHAR *password;
158 Uri_HOST_TYPE host_type;
161 ipv6_address ipv6_address;
174 const WCHAR *fragment;
178 static const CHAR hexDigits[] = "0123456789ABCDEF";
180 /* List of scheme types/scheme names that are recognized by the IUri interface as of IE 7. */
181 static const struct {
183 WCHAR scheme_name[16];
184 } recognized_schemes[] = {
185 {URL_SCHEME_FTP, {'f','t','p',0}},
186 {URL_SCHEME_HTTP, {'h','t','t','p',0}},
187 {URL_SCHEME_GOPHER, {'g','o','p','h','e','r',0}},
188 {URL_SCHEME_MAILTO, {'m','a','i','l','t','o',0}},
189 {URL_SCHEME_NEWS, {'n','e','w','s',0}},
190 {URL_SCHEME_NNTP, {'n','n','t','p',0}},
191 {URL_SCHEME_TELNET, {'t','e','l','n','e','t',0}},
192 {URL_SCHEME_WAIS, {'w','a','i','s',0}},
193 {URL_SCHEME_FILE, {'f','i','l','e',0}},
194 {URL_SCHEME_MK, {'m','k',0}},
195 {URL_SCHEME_HTTPS, {'h','t','t','p','s',0}},
196 {URL_SCHEME_SHELL, {'s','h','e','l','l',0}},
197 {URL_SCHEME_SNEWS, {'s','n','e','w','s',0}},
198 {URL_SCHEME_LOCAL, {'l','o','c','a','l',0}},
199 {URL_SCHEME_JAVASCRIPT, {'j','a','v','a','s','c','r','i','p','t',0}},
200 {URL_SCHEME_VBSCRIPT, {'v','b','s','c','r','i','p','t',0}},
201 {URL_SCHEME_ABOUT, {'a','b','o','u','t',0}},
202 {URL_SCHEME_RES, {'r','e','s',0}},
203 {URL_SCHEME_MSSHELLROOTED, {'m','s','-','s','h','e','l','l','-','r','o','o','t','e','d',0}},
204 {URL_SCHEME_MSSHELLIDLIST, {'m','s','-','s','h','e','l','l','-','i','d','l','i','s','t',0}},
205 {URL_SCHEME_MSHELP, {'h','c','p',0}},
206 {URL_SCHEME_WILDCARD, {'*',0}}
209 /* List of default ports Windows recognizes. */
210 static const struct {
213 } default_ports[] = {
214 {URL_SCHEME_FTP, 21},
215 {URL_SCHEME_HTTP, 80},
216 {URL_SCHEME_GOPHER, 70},
217 {URL_SCHEME_NNTP, 119},
218 {URL_SCHEME_TELNET, 23},
219 {URL_SCHEME_WAIS, 210},
220 {URL_SCHEME_HTTPS, 443},
223 /* List of 3 character top level domain names Windows seems to recognize.
224 * There might be more, but, these are the only ones I've found so far.
226 static const struct {
228 } recognized_tlds[] = {
238 static Uri *get_uri_obj(IUri *uri)
243 hres = IUri_QueryInterface(uri, &IID_IUriObj, (void**)&ret);
244 return SUCCEEDED(hres) ? ret : NULL;
247 static inline BOOL is_alpha(WCHAR val) {
248 return ((val >= 'a' && val <= 'z') || (val >= 'A' && val <= 'Z'));
251 static inline BOOL is_num(WCHAR val) {
252 return (val >= '0' && val <= '9');
255 static inline BOOL is_drive_path(const WCHAR *str) {
256 return (is_alpha(str[0]) && (str[1] == ':' || str[1] == '|'));
259 static inline BOOL is_unc_path(const WCHAR *str) {
260 return (str[0] == '\\' && str[0] == '\\');
263 static inline BOOL is_forbidden_dos_path_char(WCHAR val) {
264 return (val == '>' || val == '<' || val == '\"');
267 /* A URI is implicitly a file path if it begins with
268 * a drive letter (eg X:) or starts with "\\" (UNC path).
270 static inline BOOL is_implicit_file_path(const WCHAR *str) {
271 return (is_unc_path(str) || (is_alpha(str[0]) && str[1] == ':'));
274 /* Checks if the URI is a hierarchical URI. A hierarchical
275 * URI is one that has "//" after the scheme.
277 static BOOL check_hierarchical(const WCHAR **ptr) {
278 const WCHAR *start = *ptr;
293 /* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" */
294 static inline BOOL is_unreserved(WCHAR val) {
295 return (is_alpha(val) || is_num(val) || val == '-' || val == '.' ||
296 val == '_' || val == '~');
299 /* sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
300 * / "*" / "+" / "," / ";" / "="
302 static inline BOOL is_subdelim(WCHAR val) {
303 return (val == '!' || val == '$' || val == '&' ||
304 val == '\'' || val == '(' || val == ')' ||
305 val == '*' || val == '+' || val == ',' ||
306 val == ';' || val == '=');
309 /* gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@" */
310 static inline BOOL is_gendelim(WCHAR val) {
311 return (val == ':' || val == '/' || val == '?' ||
312 val == '#' || val == '[' || val == ']' ||
316 /* Characters that delimit the end of the authority
317 * section of a URI. Sometimes a '\\' is considered
318 * an authority delimeter.
320 static inline BOOL is_auth_delim(WCHAR val, BOOL acceptSlash) {
321 return (val == '#' || val == '/' || val == '?' ||
322 val == '\0' || (acceptSlash && val == '\\'));
325 /* reserved = gen-delims / sub-delims */
326 static inline BOOL is_reserved(WCHAR val) {
327 return (is_subdelim(val) || is_gendelim(val));
330 static inline BOOL is_hexdigit(WCHAR val) {
331 return ((val >= 'a' && val <= 'f') ||
332 (val >= 'A' && val <= 'F') ||
333 (val >= '0' && val <= '9'));
336 static inline BOOL is_path_delim(WCHAR val) {
337 return (!val || val == '#' || val == '?');
340 /* List of schemes types Windows seems to expect to be hierarchical. */
341 static inline BOOL is_hierarchical_scheme(URL_SCHEME type) {
342 return(type == URL_SCHEME_HTTP || type == URL_SCHEME_FTP ||
343 type == URL_SCHEME_GOPHER || type == URL_SCHEME_NNTP ||
344 type == URL_SCHEME_TELNET || type == URL_SCHEME_WAIS ||
345 type == URL_SCHEME_FILE || type == URL_SCHEME_HTTPS ||
346 type == URL_SCHEME_RES);
349 /* Checks if 'flags' contains an invalid combination of Uri_CREATE flags. */
350 static inline BOOL has_invalid_flag_combination(DWORD flags) {
351 return((flags & Uri_CREATE_DECODE_EXTRA_INFO && flags & Uri_CREATE_NO_DECODE_EXTRA_INFO) ||
352 (flags & Uri_CREATE_CANONICALIZE && flags & Uri_CREATE_NO_CANONICALIZE) ||
353 (flags & Uri_CREATE_CRACK_UNKNOWN_SCHEMES && flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES) ||
354 (flags & Uri_CREATE_PRE_PROCESS_HTML_URI && flags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI) ||
355 (flags & Uri_CREATE_IE_SETTINGS && flags & Uri_CREATE_NO_IE_SETTINGS));
358 /* Applies each default Uri_CREATE flags to 'flags' if it
359 * doesn't cause a flag conflict.
361 static void apply_default_flags(DWORD *flags) {
362 if(!(*flags & Uri_CREATE_NO_CANONICALIZE))
363 *flags |= Uri_CREATE_CANONICALIZE;
364 if(!(*flags & Uri_CREATE_NO_DECODE_EXTRA_INFO))
365 *flags |= Uri_CREATE_DECODE_EXTRA_INFO;
366 if(!(*flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES))
367 *flags |= Uri_CREATE_CRACK_UNKNOWN_SCHEMES;
368 if(!(*flags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI))
369 *flags |= Uri_CREATE_PRE_PROCESS_HTML_URI;
370 if(!(*flags & Uri_CREATE_IE_SETTINGS))
371 *flags |= Uri_CREATE_NO_IE_SETTINGS;
374 /* Determines if the URI is hierarchical using the information already parsed into
375 * data and using the current location of parsing in the URI string.
377 * Windows considers a URI hierarchical if on of the following is true:
378 * A.) It's a wildcard scheme.
379 * B.) It's an implicit file scheme.
380 * C.) It's a known hierarchical scheme and it has two '\\' after the scheme name.
381 * (the '\\' will be converted into "//" during canonicalization).
382 * D.) It's not a relative URI and "//" appears after the scheme name.
384 static inline BOOL is_hierarchical_uri(const WCHAR **ptr, const parse_data *data) {
385 const WCHAR *start = *ptr;
387 if(data->scheme_type == URL_SCHEME_WILDCARD)
389 else if(data->scheme_type == URL_SCHEME_FILE && data->has_implicit_scheme)
391 else if(is_hierarchical_scheme(data->scheme_type) && (*ptr)[0] == '\\' && (*ptr)[1] == '\\') {
394 } else if(!data->is_relative && check_hierarchical(ptr))
401 /* Checks if the two Uri's are logically equivalent. It's a simple
402 * comparison, since they are both of type Uri, and it can access
403 * the properties of each Uri directly without the need to go
404 * through the "IUri_Get*" interface calls.
406 static BOOL are_equal_simple(const Uri *a, const Uri *b) {
407 if(a->scheme_type == b->scheme_type) {
408 const BOOL known_scheme = a->scheme_type != URL_SCHEME_UNKNOWN;
409 const BOOL are_hierarchical =
410 (a->authority_start > -1 && b->authority_start > -1);
412 if(a->scheme_type == URL_SCHEME_FILE) {
413 if(a->canon_len == b->canon_len)
414 return !StrCmpIW(a->canon_uri, b->canon_uri);
417 /* Only compare the scheme names (if any) if their unknown scheme types. */
419 if((a->scheme_start > -1 && b->scheme_start > -1) &&
420 (a->scheme_len == b->scheme_len)) {
421 /* Make sure the schemes are the same. */
422 if(StrCmpNW(a->canon_uri+a->scheme_start, b->canon_uri+b->scheme_start, a->scheme_len))
424 } else if(a->scheme_len != b->scheme_len)
425 /* One of the Uri's has a scheme name, while the other doesn't. */
429 /* If they have a userinfo component, perform case sensitive compare. */
430 if((a->userinfo_start > -1 && b->userinfo_start > -1) &&
431 (a->userinfo_len == b->userinfo_len)) {
432 if(StrCmpNW(a->canon_uri+a->userinfo_start, b->canon_uri+b->userinfo_start, a->userinfo_len))
434 } else if(a->userinfo_len != b->userinfo_len)
435 /* One of the Uri's had a userinfo, while the other one doesn't. */
438 /* Check if they have a host name. */
439 if((a->host_start > -1 && b->host_start > -1) &&
440 (a->host_len == b->host_len)) {
441 /* Perform a case insensitive compare if they are a known scheme type. */
443 if(StrCmpNIW(a->canon_uri+a->host_start, b->canon_uri+b->host_start, a->host_len))
445 } else if(StrCmpNW(a->canon_uri+a->host_start, b->canon_uri+b->host_start, a->host_len))
447 } else if(a->host_len != b->host_len)
448 /* One of the Uri's had a host, while the other one didn't. */
451 if(a->has_port && b->has_port) {
452 if(a->port != b->port)
454 } else if(a->has_port || b->has_port)
455 /* One had a port, while the other one didn't. */
458 /* Windows is weird with how it handles paths. For example
459 * One URI could be "http://google.com" (after canonicalization)
460 * and one could be "http://google.com/" and the IsEqual function
461 * would still evaluate to TRUE, but, only if they are both hierarchical
464 if((a->path_start > -1 && b->path_start > -1) &&
465 (a->path_len == b->path_len)) {
466 if(StrCmpNW(a->canon_uri+a->path_start, b->canon_uri+b->path_start, a->path_len))
468 } else if(are_hierarchical && a->path_len == -1 && b->path_len == 0) {
469 if(*(a->canon_uri+a->path_start) != '/')
471 } else if(are_hierarchical && b->path_len == 1 && a->path_len == 0) {
472 if(*(b->canon_uri+b->path_start) != '/')
474 } else if(a->path_len != b->path_len)
477 /* Compare the query strings of the two URIs. */
478 if((a->query_start > -1 && b->query_start > -1) &&
479 (a->query_len == b->query_len)) {
480 if(StrCmpNW(a->canon_uri+a->query_start, b->canon_uri+b->query_start, a->query_len))
482 } else if(a->query_len != b->query_len)
485 if((a->fragment_start > -1 && b->fragment_start > -1) &&
486 (a->fragment_len == b->fragment_len)) {
487 if(StrCmpNW(a->canon_uri+a->fragment_start, b->canon_uri+b->fragment_start, a->fragment_len))
489 } else if(a->fragment_len != b->fragment_len)
492 /* If we get here, the two URIs are equivalent. */
499 /* Computes the size of the given IPv6 address.
500 * Each h16 component is 16bits, if there is an IPv4 address, it's
501 * 32bits. If there's an elision it can be 16bits to 128bits, depending
502 * on the number of other components.
504 * Modeled after google-url's CheckIPv6ComponentsSize function
506 static void compute_ipv6_comps_size(ipv6_address *address) {
507 address->components_size = address->h16_count * 2;
510 /* IPv4 address is 4 bytes. */
511 address->components_size += 4;
513 if(address->elision) {
514 /* An elision can be anywhere from 2 bytes up to 16 bytes.
515 * It size depends on the size of the h16 and IPv4 components.
517 address->elision_size = 16 - address->components_size;
518 if(address->elision_size < 2)
519 address->elision_size = 2;
521 address->elision_size = 0;
524 /* Taken from dlls/jscript/lex.c */
525 static int hex_to_int(WCHAR val) {
526 if(val >= '0' && val <= '9')
528 else if(val >= 'a' && val <= 'f')
529 return val - 'a' + 10;
530 else if(val >= 'A' && val <= 'F')
531 return val - 'A' + 10;
536 /* Helper function for converting a percent encoded string
537 * representation of a WCHAR value into its actual WCHAR value. If
538 * the two characters following the '%' aren't valid hex values then
539 * this function returns the NULL character.
542 * "%2E" will result in '.' being returned by this function.
544 static WCHAR decode_pct_val(const WCHAR *ptr) {
547 if(*ptr == '%' && is_hexdigit(*(ptr + 1)) && is_hexdigit(*(ptr + 2))) {
548 INT a = hex_to_int(*(ptr + 1));
549 INT b = hex_to_int(*(ptr + 2));
558 /* Helper function for percent encoding a given character
559 * and storing the encoded value into a given buffer (dest).
561 * It's up to the calling function to ensure that there is
562 * at least enough space in 'dest' for the percent encoded
563 * value to be stored (so dest + 3 spaces available).
565 static inline void pct_encode_val(WCHAR val, WCHAR *dest) {
567 dest[1] = hexDigits[(val >> 4) & 0xf];
568 dest[2] = hexDigits[val & 0xf];
571 /* Scans the range of characters [str, end] and returns the last occurrence
572 * of 'ch' or returns NULL.
574 static const WCHAR *str_last_of(const WCHAR *str, const WCHAR *end, WCHAR ch) {
575 const WCHAR *ptr = end;
586 /* Attempts to parse the domain name from the host.
588 * This function also includes the Top-level Domain (TLD) name
589 * of the host when it tries to find the domain name. If it finds
590 * a valid domain name it will assign 'domain_start' the offset
591 * into 'host' where the domain name starts.
593 * It's implied that if a domain name its range is implied to be
594 * [host+domain_start, host+host_len).
596 static void find_domain_name(const WCHAR *host, DWORD host_len,
598 const WCHAR *last_tld, *sec_last_tld, *end;
600 end = host+host_len-1;
604 /* There has to be at least enough room for a '.' followed by a
605 * 3 character TLD for a domain to even exist in the host name.
610 last_tld = str_last_of(host, end, '.');
612 /* http://hostname -> has no domain name. */
615 sec_last_tld = str_last_of(host, last_tld-1, '.');
617 /* If the '.' is at the beginning of the host there
618 * has to be at least 3 characters in the TLD for it
620 * Ex: .com -> .com as the domain name.
621 * .co -> has no domain name.
623 if(last_tld-host == 0) {
624 if(end-(last_tld-1) < 3)
626 } else if(last_tld-host == 3) {
629 /* If there's three characters in front of last_tld and
630 * they are on the list of recognized TLDs, then this
631 * host doesn't have a domain (since the host only contains
633 * Ex: edu.uk -> has no domain name.
634 * foo.uk -> foo.uk as the domain name.
636 for(i = 0; i < sizeof(recognized_tlds)/sizeof(recognized_tlds[0]); ++i) {
637 if(!StrCmpNIW(host, recognized_tlds[i].tld_name, 3))
640 } else if(last_tld-host < 3)
641 /* Anything less than 3 characters is considered part
643 * Ex: ak.uk -> Has no domain name.
647 /* Otherwise the domain name is the whole host name. */
649 } else if(end+1-last_tld > 3) {
650 /* If the last_tld has more than 3 characters, then it's automatically
651 * considered the TLD of the domain name.
652 * Ex: www.winehq.org.uk.test -> uk.test as the domain name.
654 *domain_start = (sec_last_tld+1)-host;
655 } else if(last_tld - (sec_last_tld+1) < 4) {
657 /* If the sec_last_tld is 3 characters long it HAS to be on the list of
658 * recognized to still be considered part of the TLD name, otherwise
659 * its considered the domain name.
660 * Ex: www.google.com.uk -> google.com.uk as the domain name.
661 * www.google.foo.uk -> foo.uk as the domain name.
663 if(last_tld - (sec_last_tld+1) == 3) {
664 for(i = 0; i < sizeof(recognized_tlds)/sizeof(recognized_tlds[0]); ++i) {
665 if(!StrCmpNIW(sec_last_tld+1, recognized_tlds[i].tld_name, 3)) {
666 const WCHAR *domain = str_last_of(host, sec_last_tld-1, '.');
671 *domain_start = (domain+1) - host;
672 TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start,
673 (host+host_len)-(host+*domain_start)));
678 *domain_start = (sec_last_tld+1)-host;
680 /* Since the sec_last_tld is less than 3 characters it's considered
682 * Ex: www.google.fo.uk -> google.fo.uk as the domain name.
684 const WCHAR *domain = str_last_of(host, sec_last_tld-1, '.');
689 *domain_start = (domain+1) - host;
692 /* The second to last TLD has more than 3 characters making it
694 * Ex: www.google.test.us -> test.us as the domain name.
696 *domain_start = (sec_last_tld+1)-host;
699 TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start,
700 (host+host_len)-(host+*domain_start)));
703 /* Removes the dot segments from a hierarchical URIs path component. This
704 * function performs the removal in place.
706 * This is a modified version of Qt's QUrl function "removeDotsFromPath".
708 * This function returns the new length of the path string.
710 static DWORD remove_dot_segments(WCHAR *path, DWORD path_len) {
712 const WCHAR *in = out;
713 const WCHAR *end = out + path_len;
717 /* A. if the input buffer begins with a prefix of "/./" or "/.",
718 * where "." is a complete path segment, then replace that
719 * prefix with "/" in the input buffer; otherwise,
721 if(in <= end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '/') {
724 } else if(in == end - 2 && in[0] == '/' && in[1] == '.') {
730 /* B. if the input buffer begins with a prefix of "/../" or "/..",
731 * where ".." is a complete path segment, then replace that
732 * prefix with "/" in the input buffer and remove the last
733 * segment and its preceding "/" (if any) from the output
736 if(in <= end - 4 && in[0] == '/' && in[1] == '.' && in[2] == '.' && in[3] == '/') {
737 while(out > path && *(--out) != '/');
741 } else if(in == end - 3 && in[0] == '/' && in[1] == '.' && in[2] == '.') {
742 while(out > path && *(--out) != '/');
751 /* C. move the first path segment in the input buffer to the end of
752 * the output buffer, including the initial "/" character (if
753 * any) and any subsequent characters up to, but not including,
754 * the next "/" character or the end of the input buffer.
757 while(in < end && *in != '/')
762 TRACE("(%p %d): Path after dot segments removed %s len=%d\n", path, path_len,
763 debugstr_wn(path, len), len);
767 /* Attempts to find the file extension in a given path. */
768 static INT find_file_extension(const WCHAR *path, DWORD path_len) {
771 for(end = path+path_len-1; end >= path && *end != '/' && *end != '\\'; --end) {
779 /* Computes the location where the elision should occur in the IPv6
780 * address using the numerical values of each component stored in
781 * 'values'. If the address shouldn't contain an elision then 'index'
782 * is assigned -1 as it's value. Otherwise 'index' will contain the
783 * starting index (into values) where the elision should be, and 'count'
784 * will contain the number of cells the elision covers.
787 * Windows will expand an elision if the elision only represents 1 h16
788 * component of the URI.
790 * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
792 * If the IPv6 address contains an IPv4 address, the IPv4 address is also
793 * considered for being included as part of an elision if all it's components
796 * Ex: [1:2:3:4:5:6:0.0.0.0] -> [1:2:3:4:5:6::]
798 static void compute_elision_location(const ipv6_address *address, const USHORT values[8],
799 INT *index, DWORD *count) {
800 DWORD i, max_len, cur_len;
801 INT max_index, cur_index;
803 max_len = cur_len = 0;
804 max_index = cur_index = -1;
805 for(i = 0; i < 8; ++i) {
806 BOOL check_ipv4 = (address->ipv4 && i == 6);
807 BOOL is_end = (check_ipv4 || i == 7);
810 /* Check if the IPv4 address contains only zeros. */
811 if(values[i] == 0 && values[i+1] == 0) {
818 } else if(values[i] == 0) {
825 if(is_end || values[i] != 0) {
826 /* We only consider it for an elision if it's
827 * more than 1 component long.
829 if(cur_len > 1 && cur_len > max_len) {
830 /* Found the new elision location. */
832 max_index = cur_index;
835 /* Reset the current range for the next range of zeros. */
845 /* Removes all the leading and trailing white spaces or
846 * control characters from the URI and removes all control
847 * characters inside of the URI string.
849 static BSTR pre_process_uri(LPCWSTR uri) {
852 const WCHAR *start, *end;
858 /* Skip leading controls and whitespace. */
859 while(iscntrlW(*start) || isspaceW(*start)) ++start;
863 /* URI consisted only of control/whitespace. */
864 ret = SysAllocStringLen(NULL, 0);
866 while(iscntrlW(*end) || isspaceW(*end)) --end;
868 buf = heap_alloc(((end+1)-start)*sizeof(WCHAR));
872 for(ptr = buf; start < end+1; ++start) {
873 if(!iscntrlW(*start))
877 ret = SysAllocStringLen(buf, ptr-buf);
884 /* Converts the specified IPv4 address into an uint value.
886 * This function assumes that the IPv4 address has already been validated.
888 static UINT ipv4toui(const WCHAR *ip, DWORD len) {
890 DWORD comp_value = 0;
893 for(ptr = ip; ptr < ip+len; ++ptr) {
899 comp_value = comp_value*10 + (*ptr-'0');
908 /* Converts an IPv4 address in numerical form into it's fully qualified
909 * string form. This function returns the number of characters written
910 * to 'dest'. If 'dest' is NULL this function will return the number of
911 * characters that would have been written.
913 * It's up to the caller to ensure there's enough space in 'dest' for the
916 static DWORD ui2ipv4(WCHAR *dest, UINT address) {
917 static const WCHAR formatW[] =
918 {'%','u','.','%','u','.','%','u','.','%','u',0};
922 digits[0] = (address >> 24) & 0xff;
923 digits[1] = (address >> 16) & 0xff;
924 digits[2] = (address >> 8) & 0xff;
925 digits[3] = address & 0xff;
929 ret = sprintfW(tmp, formatW, digits[0], digits[1], digits[2], digits[3]);
931 ret = sprintfW(dest, formatW, digits[0], digits[1], digits[2], digits[3]);
936 static DWORD ui2str(WCHAR *dest, UINT value) {
937 static const WCHAR formatW[] = {'%','u',0};
942 ret = sprintfW(tmp, formatW, value);
944 ret = sprintfW(dest, formatW, value);
949 /* Converts an h16 component (from an IPv6 address) into it's
952 * This function assumes that the h16 component has already been validated.
954 static USHORT h16tous(h16 component) {
958 for(i = 0; i < component.len; ++i) {
960 ret += hex_to_int(component.str[i]);
966 /* Converts an IPv6 address into it's 128 bits (16 bytes) numerical value.
968 * This function assumes that the ipv6_address has already been validated.
970 static BOOL ipv6_to_number(const ipv6_address *address, USHORT number[8]) {
971 DWORD i, cur_component = 0;
972 BOOL already_passed_elision = FALSE;
974 for(i = 0; i < address->h16_count; ++i) {
975 if(address->elision) {
976 if(address->components[i].str > address->elision && !already_passed_elision) {
977 /* Means we just passed the elision and need to add it's values to
978 * 'number' before we do anything else.
981 for(j = 0; j < address->elision_size; j+=2)
982 number[cur_component++] = 0;
984 already_passed_elision = TRUE;
988 number[cur_component++] = h16tous(address->components[i]);
991 /* Case when the elision appears after the h16 components. */
992 if(!already_passed_elision && address->elision) {
993 for(i = 0; i < address->elision_size; i+=2)
994 number[cur_component++] = 0;
995 already_passed_elision = TRUE;
999 UINT value = ipv4toui(address->ipv4, address->ipv4_len);
1001 if(cur_component != 6) {
1002 ERR("(%p %p): Failed sanity check with %d\n", address, number, cur_component);
1006 number[cur_component++] = (value >> 16) & 0xffff;
1007 number[cur_component] = value & 0xffff;
1013 /* Checks if the characters pointed to by 'ptr' are
1014 * a percent encoded data octet.
1016 * pct-encoded = "%" HEXDIG HEXDIG
1018 static BOOL check_pct_encoded(const WCHAR **ptr) {
1019 const WCHAR *start = *ptr;
1025 if(!is_hexdigit(**ptr)) {
1031 if(!is_hexdigit(**ptr)) {
1040 /* dec-octet = DIGIT ; 0-9
1041 * / %x31-39 DIGIT ; 10-99
1042 * / "1" 2DIGIT ; 100-199
1043 * / "2" %x30-34 DIGIT ; 200-249
1044 * / "25" %x30-35 ; 250-255
1046 static BOOL check_dec_octet(const WCHAR **ptr) {
1047 const WCHAR *c1, *c2, *c3;
1050 /* A dec-octet must be at least 1 digit long. */
1051 if(*c1 < '0' || *c1 > '9')
1057 /* Since the 1 digit requirment was meet, it doesn't
1058 * matter if this is a DIGIT value, it's considered a
1061 if(*c2 < '0' || *c2 > '9')
1067 /* Same explanation as above. */
1068 if(*c3 < '0' || *c3 > '9')
1071 /* Anything > 255 isn't a valid IP dec-octet. */
1072 if(*c1 >= '2' && *c2 >= '5' && *c3 >= '5') {
1081 /* Checks if there is an implicit IPv4 address in the host component of the URI.
1082 * The max value of an implicit IPv4 address is UINT_MAX.
1085 * "234567" would be considered an implicit IPv4 address.
1087 static BOOL check_implicit_ipv4(const WCHAR **ptr, UINT *val) {
1088 const WCHAR *start = *ptr;
1092 while(is_num(**ptr)) {
1093 ret = ret*10 + (**ptr - '0');
1095 if(ret > UINT_MAX) {
1109 /* Checks if the string contains an IPv4 address.
1111 * This function has a strict mode or a non-strict mode of operation
1112 * When 'strict' is set to FALSE this function will return TRUE if
1113 * the string contains at least 'dec-octet "." dec-octet' since partial
1114 * IPv4 addresses will be normalized out into full IPv4 addresses. When
1115 * 'strict' is set this function expects there to be a full IPv4 address.
1117 * IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
1119 static BOOL check_ipv4address(const WCHAR **ptr, BOOL strict) {
1120 const WCHAR *start = *ptr;
1122 if(!check_dec_octet(ptr)) {
1133 if(!check_dec_octet(ptr)) {
1147 if(!check_dec_octet(ptr)) {
1161 if(!check_dec_octet(ptr)) {
1166 /* Found a four digit ip address. */
1169 /* Tries to parse the scheme name of the URI.
1171 * scheme = ALPHA *(ALPHA | NUM | '+' | '-' | '.') as defined by RFC 3896.
1172 * NOTE: Windows accepts a number as the first character of a scheme.
1174 static BOOL parse_scheme_name(const WCHAR **ptr, parse_data *data, DWORD extras) {
1175 const WCHAR *start = *ptr;
1177 data->scheme = NULL;
1178 data->scheme_len = 0;
1181 if(**ptr == '*' && *ptr == start) {
1182 /* Might have found a wildcard scheme. If it is the next
1183 * char has to be a ':' for it to be a valid URI
1187 } else if(!is_num(**ptr) && !is_alpha(**ptr) && **ptr != '+' &&
1188 **ptr != '-' && **ptr != '.')
1197 /* Schemes must end with a ':' */
1198 if(**ptr != ':' && !((extras & ALLOW_NULL_TERM_SCHEME) && !**ptr)) {
1203 data->scheme = start;
1204 data->scheme_len = *ptr - start;
1210 /* Tries to deduce the corresponding URL_SCHEME for the given URI. Stores
1211 * the deduced URL_SCHEME in data->scheme_type.
1213 static BOOL parse_scheme_type(parse_data *data) {
1214 /* If there's scheme data then see if it's a recognized scheme. */
1215 if(data->scheme && data->scheme_len) {
1218 for(i = 0; i < sizeof(recognized_schemes)/sizeof(recognized_schemes[0]); ++i) {
1219 if(lstrlenW(recognized_schemes[i].scheme_name) == data->scheme_len) {
1220 /* Has to be a case insensitive compare. */
1221 if(!StrCmpNIW(recognized_schemes[i].scheme_name, data->scheme, data->scheme_len)) {
1222 data->scheme_type = recognized_schemes[i].scheme;
1228 /* If we get here it means it's not a recognized scheme. */
1229 data->scheme_type = URL_SCHEME_UNKNOWN;
1231 } else if(data->is_relative) {
1232 /* Relative URI's have no scheme. */
1233 data->scheme_type = URL_SCHEME_UNKNOWN;
1236 /* Should never reach here! what happened... */
1237 FIXME("(%p): Unable to determine scheme type for URI %s\n", data, debugstr_w(data->uri));
1242 /* Tries to parse (or deduce) the scheme_name of a URI. If it can't
1243 * parse a scheme from the URI it will try to deduce the scheme_name and scheme_type
1244 * using the flags specified in 'flags' (if any). Flags that affect how this function
1245 * operates are the Uri_CREATE_ALLOW_* flags.
1247 * All parsed/deduced information will be stored in 'data' when the function returns.
1249 * Returns TRUE if it was able to successfully parse the information.
1251 static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) {
1252 static const WCHAR fileW[] = {'f','i','l','e',0};
1253 static const WCHAR wildcardW[] = {'*',0};
1255 /* First check to see if the uri could implicitly be a file path. */
1256 if(is_implicit_file_path(*ptr)) {
1257 if(flags & Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME) {
1258 data->scheme = fileW;
1259 data->scheme_len = lstrlenW(fileW);
1260 data->has_implicit_scheme = TRUE;
1262 TRACE("(%p %p %x): URI is an implicit file path.\n", ptr, data, flags);
1264 /* Window's does not consider anything that can implicitly be a file
1265 * path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set...
1267 TRACE("(%p %p %x): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n",
1271 } else if(!parse_scheme_name(ptr, data, extras)) {
1272 /* No Scheme was found, this means it could be:
1273 * a) an implicit Wildcard scheme
1277 if(flags & Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME) {
1278 data->scheme = wildcardW;
1279 data->scheme_len = lstrlenW(wildcardW);
1280 data->has_implicit_scheme = TRUE;
1282 TRACE("(%p %p %x): URI is an implicit wildcard scheme.\n", ptr, data, flags);
1283 } else if (flags & Uri_CREATE_ALLOW_RELATIVE) {
1284 data->is_relative = TRUE;
1285 TRACE("(%p %p %x): URI is relative.\n", ptr, data, flags);
1287 TRACE("(%p %p %x): Malformed URI found. Unable to deduce scheme name.\n", ptr, data, flags);
1292 if(!data->is_relative)
1293 TRACE("(%p %p %x): Found scheme=%s scheme_len=%d\n", ptr, data, flags,
1294 debugstr_wn(data->scheme, data->scheme_len), data->scheme_len);
1296 if(!parse_scheme_type(data))
1299 TRACE("(%p %p %x): Assigned %d as the URL_SCHEME.\n", ptr, data, flags, data->scheme_type);
1303 static BOOL parse_username(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) {
1304 data->username = *ptr;
1306 while(**ptr != ':' && **ptr != '@') {
1308 if(!check_pct_encoded(ptr)) {
1309 if(data->scheme_type != URL_SCHEME_UNKNOWN) {
1310 *ptr = data->username;
1311 data->username = NULL;
1316 } else if(extras & ALLOW_NULL_TERM_USER_NAME && !**ptr)
1318 else if(is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) {
1319 *ptr = data->username;
1320 data->username = NULL;
1327 data->username_len = *ptr - data->username;
1331 static BOOL parse_password(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) {
1332 data->password = *ptr;
1334 while(**ptr != '@') {
1336 if(!check_pct_encoded(ptr)) {
1337 if(data->scheme_type != URL_SCHEME_UNKNOWN) {
1338 *ptr = data->password;
1339 data->password = NULL;
1344 } else if(extras & ALLOW_NULL_TERM_PASSWORD && !**ptr)
1346 else if(is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) {
1347 *ptr = data->password;
1348 data->password = NULL;
1355 data->password_len = *ptr - data->password;
1359 /* Parses the userinfo part of the URI (if it exists). The userinfo field of
1360 * a URI can consist of "username:password@", or just "username@".
1363 * userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
1366 * 1) If there is more than one ':' in the userinfo part of the URI Windows
1367 * uses the first occurrence of ':' to delimit the username and password
1371 * ftp://user:pass:word@winehq.org
1373 * Would yield, "user" as the username and "pass:word" as the password.
1375 * 2) Windows allows any character to appear in the "userinfo" part of
1376 * a URI, as long as it's not an authority delimeter character set.
1378 static void parse_userinfo(const WCHAR **ptr, parse_data *data, DWORD flags) {
1379 const WCHAR *start = *ptr;
1381 if(!parse_username(ptr, data, flags, 0)) {
1382 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags);
1388 if(!parse_password(ptr, data, flags, 0)) {
1390 data->username = NULL;
1391 data->username_len = 0;
1392 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags);
1399 data->username = NULL;
1400 data->username_len = 0;
1401 data->password = NULL;
1402 data->password_len = 0;
1404 TRACE("(%p %p %x): URI contained no userinfo.\n", ptr, data, flags);
1409 TRACE("(%p %p %x): Found username %s len=%d.\n", ptr, data, flags,
1410 debugstr_wn(data->username, data->username_len), data->username_len);
1413 TRACE("(%p %p %x): Found password %s len=%d.\n", ptr, data, flags,
1414 debugstr_wn(data->password, data->password_len), data->password_len);
1419 /* Attempts to parse a port from the URI.
1422 * Windows seems to have a cap on what the maximum value
1423 * for a port can be. The max value is USHORT_MAX.
1427 static BOOL parse_port(const WCHAR **ptr, parse_data *data, DWORD flags) {
1431 while(!is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)) {
1432 if(!is_num(**ptr)) {
1438 port = port*10 + (**ptr-'0');
1440 if(port > USHORT_MAX) {
1449 data->has_port = TRUE;
1450 data->port_value = port;
1451 data->port_len = *ptr - data->port;
1453 TRACE("(%p %p %x): Found port %s len=%d value=%u\n", ptr, data, flags,
1454 debugstr_wn(data->port, data->port_len), data->port_len, data->port_value);
1458 /* Attempts to parse a IPv4 address from the URI.
1461 * Window's normalizes IPv4 addresses, This means there's three
1462 * possibilities for the URI to contain an IPv4 address.
1463 * 1) A well formed address (ex. 192.2.2.2).
1464 * 2) A partially formed address. For example "192.0" would
1465 * normalize to "192.0.0.0" during canonicalization.
1466 * 3) An implicit IPv4 address. For example "256" would
1467 * normalize to "0.0.1.0" during canonicalization. Also
1468 * note that the maximum value for an implicit IP address
1469 * is UINT_MAX, if the value in the URI exceeds this then
1470 * it is not considered an IPv4 address.
1472 static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data, DWORD flags) {
1473 const BOOL is_unknown = data->scheme_type == URL_SCHEME_UNKNOWN;
1476 if(!check_ipv4address(ptr, FALSE)) {
1477 if(!check_implicit_ipv4(ptr, &data->implicit_ipv4)) {
1478 TRACE("(%p %p %x): URI didn't contain anything looking like an IPv4 address.\n",
1484 data->has_implicit_ip = TRUE;
1487 /* Check if what we found is the only part of the host name (if it isn't
1488 * we don't have an IPv4 address).
1492 if(!parse_port(ptr, data, flags)) {
1497 } else if(!is_auth_delim(**ptr, !is_unknown)) {
1498 /* Found more data which belongs the host, so this isn't an IPv4. */
1501 data->has_implicit_ip = FALSE;
1505 data->host_len = *ptr - data->host;
1506 data->host_type = Uri_HOST_IPV4;
1508 TRACE("(%p %p %x): IPv4 address found. host=%s host_len=%d host_type=%d\n",
1509 ptr, data, flags, debugstr_wn(data->host, data->host_len),
1510 data->host_len, data->host_type);
1514 /* Attempts to parse the reg-name from the URI.
1516 * Because of the way Windows handles ':' this function also
1517 * handles parsing the port.
1519 * reg-name = *( unreserved / pct-encoded / sub-delims )
1522 * Windows allows everything, but, the characters in "auth_delims" and ':'
1523 * to appear in a reg-name, unless it's an unknown scheme type then ':' is
1524 * allowed to appear (even if a valid port isn't after it).
1526 * Windows doesn't like host names which start with '[' and end with ']'
1527 * and don't contain a valid IP literal address in between them.
1529 * On Windows if an '[' is encountered in the host name the ':' no longer
1530 * counts as a delimiter until you reach the next ']' or an "authority delimeter".
1532 * A reg-name CAN be empty.
1534 static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) {
1535 const BOOL has_start_bracket = **ptr == '[';
1536 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
1537 BOOL inside_brackets = has_start_bracket;
1538 BOOL ignore_col = extras & IGNORE_PORT_DELIMITER;
1540 /* We have to be careful with file schemes. */
1541 if(data->scheme_type == URL_SCHEME_FILE) {
1542 /* This is because an implicit file scheme could be "C:\\test" and it
1543 * would trick this function into thinking the host is "C", when after
1544 * canonicalization the host would end up being an empty string. A drive
1545 * path can also have a '|' instead of a ':' after the drive letter.
1547 if(is_drive_path(*ptr)) {
1548 /* Regular old drive paths don't have a host type (or host name). */
1549 data->host_type = Uri_HOST_UNKNOWN;
1553 } else if(is_unc_path(*ptr))
1554 /* Skip past the "\\" of a UNC path. */
1560 while(!is_auth_delim(**ptr, known_scheme)) {
1561 if(**ptr == ':' && !ignore_col) {
1562 /* We can ignore ':' if were inside brackets.*/
1563 if(!inside_brackets) {
1564 const WCHAR *tmp = (*ptr)++;
1566 /* Attempt to parse the port. */
1567 if(!parse_port(ptr, data, flags)) {
1568 /* Windows expects there to be a valid port for known scheme types. */
1569 if(data->scheme_type != URL_SCHEME_UNKNOWN) {
1572 TRACE("(%p %p %x %x): Expected valid port\n", ptr, data, flags, extras);
1575 /* Windows gives up on trying to parse a port when it
1576 * encounters 1 invalid port.
1580 data->host_len = tmp - data->host;
1584 } else if(**ptr == '%' && known_scheme) {
1585 /* Has to be a legit % encoded value. */
1586 if(!check_pct_encoded(ptr)) {
1592 } else if(**ptr == ']')
1593 inside_brackets = FALSE;
1594 else if(**ptr == '[')
1595 inside_brackets = TRUE;
1600 if(has_start_bracket) {
1601 /* Make sure the last character of the host wasn't a ']'. */
1602 if(*(*ptr-1) == ']') {
1603 TRACE("(%p %p %x %x): Expected an IP literal inside of the host\n",
1604 ptr, data, flags, extras);
1611 /* Don't overwrite our length if we found a port earlier. */
1613 data->host_len = *ptr - data->host;
1615 /* If the host is empty, then it's an unknown host type. */
1616 if(data->host_len == 0)
1617 data->host_type = Uri_HOST_UNKNOWN;
1619 data->host_type = Uri_HOST_DNS;
1621 TRACE("(%p %p %x %x): Parsed reg-name. host=%s len=%d\n", ptr, data, flags, extras,
1622 debugstr_wn(data->host, data->host_len), data->host_len);
1626 /* Attempts to parse an IPv6 address out of the URI.
1628 * IPv6address = 6( h16 ":" ) ls32
1629 * / "::" 5( h16 ":" ) ls32
1630 * / [ h16 ] "::" 4( h16 ":" ) ls32
1631 * / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
1632 * / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
1633 * / [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32
1634 * / [ *4( h16 ":" ) h16 ] "::" ls32
1635 * / [ *5( h16 ":" ) h16 ] "::" h16
1636 * / [ *6( h16 ":" ) h16 ] "::"
1638 * ls32 = ( h16 ":" h16 ) / IPv4address
1639 * ; least-significant 32 bits of address.
1642 * ; 16 bits of address represented in hexadecimal.
1644 * Modeled after google-url's 'DoParseIPv6' function.
1646 static BOOL parse_ipv6address(const WCHAR **ptr, parse_data *data, DWORD flags) {
1647 const WCHAR *start, *cur_start;
1650 start = cur_start = *ptr;
1651 memset(&ip, 0, sizeof(ipv6_address));
1654 /* Check if we're on the last character of the host. */
1655 BOOL is_end = (is_auth_delim(**ptr, data->scheme_type != URL_SCHEME_UNKNOWN)
1658 BOOL is_split = (**ptr == ':');
1659 BOOL is_elision = (is_split && !is_end && *(*ptr+1) == ':');
1661 /* Check if we're at the end of a component, or
1662 * if we're at the end of the IPv6 address.
1664 if(is_split || is_end) {
1667 cur_len = *ptr - cur_start;
1669 /* h16 can't have a length > 4. */
1673 TRACE("(%p %p %x): h16 component to long.\n",
1679 /* An h16 component can't have the length of 0 unless
1680 * the elision is at the beginning of the address, or
1681 * at the end of the address.
1683 if(!((*ptr == start && is_elision) ||
1684 (is_end && (*ptr-2) == ip.elision))) {
1686 TRACE("(%p %p %x): IPv6 component cannot have a length of 0.\n",
1693 /* An IPv6 address can have no more than 8 h16 components. */
1694 if(ip.h16_count >= 8) {
1696 TRACE("(%p %p %x): Not a IPv6 address, to many h16 components.\n",
1701 ip.components[ip.h16_count].str = cur_start;
1702 ip.components[ip.h16_count].len = cur_len;
1704 TRACE("(%p %p %x): Found h16 component %s, len=%d, h16_count=%d\n",
1705 ptr, data, flags, debugstr_wn(cur_start, cur_len), cur_len,
1715 /* A IPv6 address can only have 1 elision ('::'). */
1719 TRACE("(%p %p %x): IPv6 address cannot have 2 elisions.\n",
1731 if(!check_ipv4address(ptr, TRUE)) {
1732 if(!is_hexdigit(**ptr)) {
1733 /* Not a valid character for an IPv6 address. */
1738 /* Found an IPv4 address. */
1739 ip.ipv4 = cur_start;
1740 ip.ipv4_len = *ptr - cur_start;
1742 TRACE("(%p %p %x): Found an attached IPv4 address %s len=%d.\n",
1743 ptr, data, flags, debugstr_wn(ip.ipv4, ip.ipv4_len),
1746 /* IPv4 addresses can only appear at the end of a IPv6. */
1752 compute_ipv6_comps_size(&ip);
1754 /* Make sure the IPv6 address adds up to 16 bytes. */
1755 if(ip.components_size + ip.elision_size != 16) {
1757 TRACE("(%p %p %x): Invalid IPv6 address, did not add up to 16 bytes.\n",
1762 if(ip.elision_size == 2) {
1763 /* For some reason on Windows if an elision that represents
1764 * only 1 h16 component is encountered at the very begin or
1765 * end of an IPv6 address, Windows does not consider it a
1766 * valid IPv6 address.
1768 * Ex: [::2:3:4:5:6:7] is not valid, even though the sum
1769 * of all the components == 128bits.
1771 if(ip.elision < ip.components[0].str ||
1772 ip.elision > ip.components[ip.h16_count-1].str) {
1774 TRACE("(%p %p %x): Invalid IPv6 address. Detected elision of 2 bytes at the beginning or end of the address.\n",
1780 data->host_type = Uri_HOST_IPV6;
1781 data->has_ipv6 = TRUE;
1782 data->ipv6_address = ip;
1784 TRACE("(%p %p %x): Found valid IPv6 literal %s len=%d\n",
1785 ptr, data, flags, debugstr_wn(start, *ptr-start),
1790 /* IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" ) */
1791 static BOOL parse_ipvfuture(const WCHAR **ptr, parse_data *data, DWORD flags) {
1792 const WCHAR *start = *ptr;
1794 /* IPvFuture has to start with a 'v' or 'V'. */
1795 if(**ptr != 'v' && **ptr != 'V')
1798 /* Following the v there must be at least 1 hex digit. */
1800 if(!is_hexdigit(**ptr)) {
1806 while(is_hexdigit(**ptr))
1809 /* End of the hexdigit sequence must be a '.' */
1816 if(!is_unreserved(**ptr) && !is_subdelim(**ptr) && **ptr != ':') {
1822 while(is_unreserved(**ptr) || is_subdelim(**ptr) || **ptr == ':')
1825 data->host_type = Uri_HOST_UNKNOWN;
1827 TRACE("(%p %p %x): Parsed IPvFuture address %s len=%d\n", ptr, data, flags,
1828 debugstr_wn(start, *ptr-start), *ptr-start);
1833 /* IP-literal = "[" ( IPv6address / IPvFuture ) "]" */
1834 static BOOL parse_ip_literal(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) {
1837 if(**ptr != '[' && !(extras & ALLOW_BRACKETLESS_IP_LITERAL)) {
1840 } else if(**ptr == '[')
1843 if(!parse_ipv6address(ptr, data, flags)) {
1844 if(extras & SKIP_IP_FUTURE_CHECK || !parse_ipvfuture(ptr, data, flags)) {
1851 if(**ptr != ']' && !(extras & ALLOW_BRACKETLESS_IP_LITERAL)) {
1855 } else if(!**ptr && extras & ALLOW_BRACKETLESS_IP_LITERAL) {
1856 /* The IP literal didn't contain brackets and was followed by
1857 * a NULL terminator, so no reason to even check the port.
1859 data->host_len = *ptr - data->host;
1866 /* If a valid port is not found, then let it trickle down to
1869 if(!parse_port(ptr, data, flags)) {
1875 data->host_len = *ptr - data->host;
1880 /* Parses the host information from the URI.
1882 * host = IP-literal / IPv4address / reg-name
1884 static BOOL parse_host(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras) {
1885 if(!parse_ip_literal(ptr, data, flags, extras)) {
1886 if(!parse_ipv4address(ptr, data, flags)) {
1887 if(!parse_reg_name(ptr, data, flags, extras)) {
1888 TRACE("(%p %p %x %x): Malformed URI, Unknown host type.\n",
1889 ptr, data, flags, extras);
1898 /* Parses the authority information from the URI.
1900 * authority = [ userinfo "@" ] host [ ":" port ]
1902 static BOOL parse_authority(const WCHAR **ptr, parse_data *data, DWORD flags) {
1903 parse_userinfo(ptr, data, flags);
1905 /* Parsing the port will happen during one of the host parsing
1906 * routines (if the URI has a port).
1908 if(!parse_host(ptr, data, flags, 0))
1914 /* Attempts to parse the path information of a hierarchical URI. */
1915 static BOOL parse_path_hierarchical(const WCHAR **ptr, parse_data *data, DWORD flags) {
1916 const WCHAR *start = *ptr;
1917 static const WCHAR slash[] = {'/',0};
1918 const BOOL is_file = data->scheme_type == URL_SCHEME_FILE;
1920 if(is_path_delim(**ptr)) {
1921 if(data->scheme_type == URL_SCHEME_WILDCARD) {
1922 /* Wildcard schemes don't get a '/' attached if their path is
1927 } else if(!(flags & Uri_CREATE_NO_CANONICALIZE)) {
1928 /* If the path component is empty, then a '/' is added. */
1933 while(!is_path_delim(**ptr)) {
1934 if(**ptr == '%' && data->scheme_type != URL_SCHEME_UNKNOWN && !is_file) {
1935 if(!check_pct_encoded(ptr)) {
1940 } else if(is_forbidden_dos_path_char(**ptr) && is_file &&
1941 (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
1942 /* File schemes with USE_DOS_PATH set aren't allowed to have
1943 * a '<' or '>' or '\"' appear in them.
1947 } else if(**ptr == '\\') {
1948 /* Not allowed to have a backslash if NO_CANONICALIZE is set
1949 * and the scheme is known type (but not a file scheme).
1951 if(flags & Uri_CREATE_NO_CANONICALIZE) {
1952 if(data->scheme_type != URL_SCHEME_FILE &&
1953 data->scheme_type != URL_SCHEME_UNKNOWN) {
1963 /* The only time a URI doesn't have a path is when
1964 * the NO_CANONICALIZE flag is set and the raw URI
1965 * didn't contain one.
1972 data->path_len = *ptr - start;
1977 TRACE("(%p %p %x): Parsed path %s len=%d\n", ptr, data, flags,
1978 debugstr_wn(data->path, data->path_len), data->path_len);
1980 TRACE("(%p %p %x): The URI contained no path\n", ptr, data, flags);
1985 /* Parses the path of a opaque URI (much less strict then the parser
1986 * for a hierarchical URI).
1989 * Windows allows invalid % encoded data to appear in opaque URI paths
1990 * for unknown scheme types.
1992 * File schemes with USE_DOS_PATH set aren't allowed to have '<', '>', or '\"'
1995 static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags) {
1996 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
1997 const BOOL is_file = data->scheme_type == URL_SCHEME_FILE;
2001 while(!is_path_delim(**ptr)) {
2002 if(**ptr == '%' && known_scheme) {
2003 if(!check_pct_encoded(ptr)) {
2009 } else if(is_forbidden_dos_path_char(**ptr) && is_file &&
2010 (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
2019 data->path_len = *ptr - data->path;
2020 TRACE("(%p %p %x): Parsed opaque URI path %s len=%d\n", ptr, data, flags,
2021 debugstr_wn(data->path, data->path_len), data->path_len);
2025 /* Determines how the URI should be parsed after the scheme information.
2027 * If the scheme is followed, by "//" then, it is treated as an hierarchical URI
2028 * which then the authority and path information will be parsed out. Otherwise, the
2029 * URI will be treated as an opaque URI which the authority information is not parsed
2032 * RFC 3896 definition of hier-part:
2034 * hier-part = "//" authority path-abempty
2039 * MSDN opaque URI definition:
2040 * scheme ":" path [ "#" fragment ]
2043 * If the URI is of an unknown scheme type and has a "//" following the scheme then it
2044 * is treated as a hierarchical URI, but, if the CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is
2045 * set then it is considered an opaque URI reguardless of what follows the scheme information
2046 * (per MSDN documentation).
2048 static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags) {
2049 const WCHAR *start = *ptr;
2051 /* Checks if the authority information needs to be parsed. */
2052 if(is_hierarchical_uri(ptr, data)) {
2053 /* Only treat it as a hierarchical URI if the scheme_type is known or
2054 * the Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is not set.
2056 if(data->scheme_type != URL_SCHEME_UNKNOWN ||
2057 !(flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES)) {
2058 TRACE("(%p %p %x): Treating URI as an hierarchical URI.\n", ptr, data, flags);
2059 data->is_opaque = FALSE;
2061 /* TODO: Handle hierarchical URI's, parse authority then parse the path. */
2062 if(!parse_authority(ptr, data, flags))
2065 return parse_path_hierarchical(ptr, data, flags);
2067 /* Reset ptr to it's starting position so opaque path parsing
2068 * begins at the correct location.
2073 /* If it reaches here, then the URI will be treated as an opaque
2077 TRACE("(%p %p %x): Treating URI as an opaque URI.\n", ptr, data, flags);
2079 data->is_opaque = TRUE;
2080 if(!parse_path_opaque(ptr, data, flags))
2086 /* Attempts to parse the query string from the URI.
2089 * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
2090 * data is allowed appear in the query string. For unknown scheme types
2091 * invalid percent encoded data is allowed to appear reguardless.
2093 static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags) {
2094 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
2097 TRACE("(%p %p %x): URI didn't contain a query string.\n", ptr, data, flags);
2104 while(**ptr && **ptr != '#') {
2105 if(**ptr == '%' && known_scheme &&
2106 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
2107 if(!check_pct_encoded(ptr)) {
2118 data->query_len = *ptr - data->query;
2120 TRACE("(%p %p %x): Parsed query string %s len=%d\n", ptr, data, flags,
2121 debugstr_wn(data->query, data->query_len), data->query_len);
2125 /* Attempts to parse the fragment from the URI.
2128 * If NO_DECODE_EXTRA_INFO flag is set, then invalid percent encoded
2129 * data is allowed appear in the query string. For unknown scheme types
2130 * invalid percent encoded data is allowed to appear reguardless.
2132 static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags) {
2133 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
2136 TRACE("(%p %p %x): URI didn't contain a fragment.\n", ptr, data, flags);
2140 data->fragment = *ptr;
2144 if(**ptr == '%' && known_scheme &&
2145 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
2146 if(!check_pct_encoded(ptr)) {
2147 *ptr = data->fragment;
2148 data->fragment = NULL;
2157 data->fragment_len = *ptr - data->fragment;
2159 TRACE("(%p %p %x): Parsed fragment %s len=%d\n", ptr, data, flags,
2160 debugstr_wn(data->fragment, data->fragment_len), data->fragment_len);
2164 /* Parses and validates the components of the specified by data->uri
2165 * and stores the information it parses into 'data'.
2167 * Returns TRUE if it successfully parsed the URI. False otherwise.
2169 static BOOL parse_uri(parse_data *data, DWORD flags) {
2176 TRACE("(%p %x): BEGINNING TO PARSE URI %s.\n", data, flags, debugstr_w(data->uri));
2178 if(!parse_scheme(pptr, data, flags, 0))
2181 if(!parse_hierpart(pptr, data, flags))
2184 if(!parse_query(pptr, data, flags))
2187 if(!parse_fragment(pptr, data, flags))
2190 TRACE("(%p %x): FINISHED PARSING URI.\n", data, flags);
2194 static BOOL canonicalize_username(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2197 if(!data->username) {
2198 uri->userinfo_start = -1;
2202 uri->userinfo_start = uri->canon_len;
2203 for(ptr = data->username; ptr < data->username+data->username_len; ++ptr) {
2205 /* Only decode % encoded values for known scheme types. */
2206 if(data->scheme_type != URL_SCHEME_UNKNOWN) {
2207 /* See if the value really needs decoded. */
2208 WCHAR val = decode_pct_val(ptr);
2209 if(is_unreserved(val)) {
2211 uri->canon_uri[uri->canon_len] = val;
2215 /* Move pass the hex characters. */
2220 } else if(!is_reserved(*ptr) && !is_unreserved(*ptr) && *ptr != '\\') {
2221 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2224 if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
2226 pct_encode_val(*ptr, uri->canon_uri + uri->canon_len);
2228 uri->canon_len += 3;
2234 /* Nothing special, so just copy the character over. */
2235 uri->canon_uri[uri->canon_len] = *ptr;
2242 static BOOL canonicalize_password(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2245 if(!data->password) {
2246 uri->userinfo_split = -1;
2250 if(uri->userinfo_start == -1)
2251 /* Has a password, but, doesn't have a username. */
2252 uri->userinfo_start = uri->canon_len;
2254 uri->userinfo_split = uri->canon_len - uri->userinfo_start;
2256 /* Add the ':' to the userinfo component. */
2258 uri->canon_uri[uri->canon_len] = ':';
2261 for(ptr = data->password; ptr < data->password+data->password_len; ++ptr) {
2263 /* Only decode % encoded values for known scheme types. */
2264 if(data->scheme_type != URL_SCHEME_UNKNOWN) {
2265 /* See if the value really needs decoded. */
2266 WCHAR val = decode_pct_val(ptr);
2267 if(is_unreserved(val)) {
2269 uri->canon_uri[uri->canon_len] = val;
2273 /* Move pass the hex characters. */
2278 } else if(!is_reserved(*ptr) && !is_unreserved(*ptr) && *ptr != '\\') {
2279 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2282 if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
2284 pct_encode_val(*ptr, uri->canon_uri + uri->canon_len);
2286 uri->canon_len += 3;
2292 /* Nothing special, so just copy the character over. */
2293 uri->canon_uri[uri->canon_len] = *ptr;
2300 /* Canonicalizes the userinfo of the URI represented by the parse_data.
2302 * Canonicalization of the userinfo is a simple process. If there are any percent
2303 * encoded characters that fall in the "unreserved" character set, they are decoded
2304 * to their actual value. If a character is not in the "unreserved" or "reserved" sets
2305 * then it is percent encoded. Other than that the characters are copied over without
2308 static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2309 uri->userinfo_start = uri->userinfo_split = -1;
2310 uri->userinfo_len = 0;
2312 if(!data->username && !data->password)
2313 /* URI doesn't have userinfo, so nothing to do here. */
2316 if(!canonicalize_username(data, uri, flags, computeOnly))
2319 if(!canonicalize_password(data, uri, flags, computeOnly))
2322 uri->userinfo_len = uri->canon_len - uri->userinfo_start;
2324 TRACE("(%p %p %x %d): Canonicalized userinfo, userinfo_start=%d, userinfo=%s, userinfo_split=%d userinfo_len=%d.\n",
2325 data, uri, flags, computeOnly, uri->userinfo_start, debugstr_wn(uri->canon_uri + uri->userinfo_start, uri->userinfo_len),
2326 uri->userinfo_split, uri->userinfo_len);
2328 /* Now insert the '@' after the userinfo. */
2330 uri->canon_uri[uri->canon_len] = '@';
2336 /* Attempts to canonicalize a reg_name.
2338 * Things that happen:
2339 * 1) If Uri_CREATE_NO_CANONICALIZE flag is not set, then the reg_name is
2340 * lower cased. Unless it's an unknown scheme type, which case it's
2341 * no lower cased reguardless.
2343 * 2) Unreserved % encoded characters are decoded for known
2346 * 3) Forbidden characters are % encoded as long as
2347 * Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS flag is not set and
2348 * it isn't an unknown scheme type.
2350 * 4) If it's a file scheme and the host is "localhost" it's removed.
2352 static BOOL canonicalize_reg_name(const parse_data *data, Uri *uri,
2353 DWORD flags, BOOL computeOnly) {
2354 static const WCHAR localhostW[] =
2355 {'l','o','c','a','l','h','o','s','t',0};
2357 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
2359 uri->host_start = uri->canon_len;
2361 if(data->scheme_type == URL_SCHEME_FILE &&
2362 data->host_len == lstrlenW(localhostW)) {
2363 if(!StrCmpNIW(data->host, localhostW, data->host_len)) {
2364 uri->host_start = -1;
2366 uri->host_type = Uri_HOST_UNKNOWN;
2371 for(ptr = data->host; ptr < data->host+data->host_len; ++ptr) {
2372 if(*ptr == '%' && known_scheme) {
2373 WCHAR val = decode_pct_val(ptr);
2374 if(is_unreserved(val)) {
2375 /* If NO_CANONICALZE is not set, then windows lower cases the
2378 if(!(flags & Uri_CREATE_NO_CANONICALIZE) && isupperW(val)) {
2380 uri->canon_uri[uri->canon_len] = tolowerW(val);
2383 uri->canon_uri[uri->canon_len] = val;
2387 /* Skip past the % encoded character. */
2391 /* Just copy the % over. */
2393 uri->canon_uri[uri->canon_len] = *ptr;
2396 } else if(*ptr == '\\') {
2397 /* Only unknown scheme types could have made it here with a '\\' in the host name. */
2399 uri->canon_uri[uri->canon_len] = *ptr;
2401 } else if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) &&
2402 !is_unreserved(*ptr) && !is_reserved(*ptr) && known_scheme) {
2404 pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
2406 /* The percent encoded value gets lower cased also. */
2407 if(!(flags & Uri_CREATE_NO_CANONICALIZE)) {
2408 uri->canon_uri[uri->canon_len+1] = tolowerW(uri->canon_uri[uri->canon_len+1]);
2409 uri->canon_uri[uri->canon_len+2] = tolowerW(uri->canon_uri[uri->canon_len+2]);
2413 uri->canon_len += 3;
2416 if(!(flags & Uri_CREATE_NO_CANONICALIZE) && known_scheme)
2417 uri->canon_uri[uri->canon_len] = tolowerW(*ptr);
2419 uri->canon_uri[uri->canon_len] = *ptr;
2426 uri->host_len = uri->canon_len - uri->host_start;
2429 TRACE("(%p %p %x %d): Canonicalize reg_name=%s len=%d\n", data, uri, flags,
2430 computeOnly, debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
2434 find_domain_name(uri->canon_uri+uri->host_start, uri->host_len,
2435 &(uri->domain_offset));
2440 /* Attempts to canonicalize an implicit IPv4 address. */
2441 static BOOL canonicalize_implicit_ipv4address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2442 uri->host_start = uri->canon_len;
2444 TRACE("%u\n", data->implicit_ipv4);
2445 /* For unknown scheme types Window's doesn't convert
2446 * the value into an IP address, but, it still considers
2447 * it an IPv4 address.
2449 if(data->scheme_type == URL_SCHEME_UNKNOWN) {
2451 memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
2452 uri->canon_len += data->host_len;
2455 uri->canon_len += ui2ipv4(uri->canon_uri+uri->canon_len, data->implicit_ipv4);
2457 uri->canon_len += ui2ipv4(NULL, data->implicit_ipv4);
2460 uri->host_len = uri->canon_len - uri->host_start;
2461 uri->host_type = Uri_HOST_IPV4;
2464 TRACE("%p %p %x %d): Canonicalized implicit IP address=%s len=%d\n",
2465 data, uri, flags, computeOnly,
2466 debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
2472 /* Attempts to canonicalize an IPv4 address.
2474 * If the parse_data represents a URI that has an implicit IPv4 address
2475 * (ex. http://256/, this function will convert 256 into 0.0.1.0). If
2476 * the implicit IP address exceeds the value of UINT_MAX (maximum value
2477 * for an IPv4 address) it's canonicalized as if were a reg-name.
2479 * If the parse_data contains a partial or full IPv4 address it normalizes it.
2480 * A partial IPv4 address is something like "192.0" and would be normalized to
2481 * "192.0.0.0". With a full (or partial) IPv4 address like "192.002.01.003" would
2482 * be normalized to "192.2.1.3".
2485 * Window's ONLY normalizes IPv4 address for known scheme types (one that isn't
2486 * URL_SCHEME_UNKNOWN). For unknown scheme types, it simply copies the data from
2487 * the original URI into the canonicalized URI, but, it still recognizes URI's
2488 * host type as HOST_IPV4.
2490 static BOOL canonicalize_ipv4address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2491 if(data->has_implicit_ip)
2492 return canonicalize_implicit_ipv4address(data, uri, flags, computeOnly);
2494 uri->host_start = uri->canon_len;
2496 /* Windows only normalizes for known scheme types. */
2497 if(data->scheme_type != URL_SCHEME_UNKNOWN) {
2498 /* parse_data contains a partial or full IPv4 address, so normalize it. */
2499 DWORD i, octetDigitCount = 0, octetCount = 0;
2500 BOOL octetHasDigit = FALSE;
2502 for(i = 0; i < data->host_len; ++i) {
2503 if(data->host[i] == '0' && !octetHasDigit) {
2504 /* Can ignore leading zeros if:
2505 * 1) It isn't the last digit of the octet.
2506 * 2) i+1 != data->host_len
2509 if(octetDigitCount == 2 ||
2510 i+1 == data->host_len ||
2511 data->host[i+1] == '.') {
2513 uri->canon_uri[uri->canon_len] = data->host[i];
2515 TRACE("Adding zero\n");
2517 } else if(data->host[i] == '.') {
2519 uri->canon_uri[uri->canon_len] = data->host[i];
2522 octetDigitCount = 0;
2523 octetHasDigit = FALSE;
2527 uri->canon_uri[uri->canon_len] = data->host[i];
2531 octetHasDigit = TRUE;
2535 /* Make sure the canonicalized IP address has 4 dec-octets.
2536 * If doesn't add "0" ones until there is 4;
2538 for( ; octetCount < 3; ++octetCount) {
2540 uri->canon_uri[uri->canon_len] = '.';
2541 uri->canon_uri[uri->canon_len+1] = '0';
2544 uri->canon_len += 2;
2547 /* Windows doesn't normalize addresses in unknown schemes. */
2549 memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
2550 uri->canon_len += data->host_len;
2553 uri->host_len = uri->canon_len - uri->host_start;
2555 TRACE("(%p %p %x %d): Canonicalized IPv4 address, ip=%s len=%d\n",
2556 data, uri, flags, computeOnly,
2557 debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
2564 /* Attempts to canonicalize the IPv6 address of the URI.
2566 * Multiple things happen during the canonicalization of an IPv6 address:
2567 * 1) Any leading zero's in an h16 component are removed.
2568 * Ex: [0001:0022::] -> [1:22::]
2570 * 2) The longest sequence of zero h16 components are compressed
2571 * into a "::" (elision). If there's a tie, the first is choosen.
2573 * Ex: [0:0:0:0:1:6:7:8] -> [::1:6:7:8]
2574 * [0:0:0:0:1:2::] -> [::1:2:0:0]
2575 * [0:0:1:2:0:0:7:8] -> [::1:2:0:0:7:8]
2577 * 3) If an IPv4 address is attached to the IPv6 address, it's
2579 * Ex: [::001.002.022.000] -> [::1.2.22.0]
2581 * 4) If an elision is present, but, only represents 1 h16 component
2584 * Ex: [1::2:3:4:5:6:7] -> [1:0:2:3:4:5:6:7]
2586 * 5) If the IPv6 address contains an IPv4 address and there exists
2587 * at least 1 non-zero h16 component the IPv4 address is converted
2588 * into two h16 components, otherwise it's normalized and kept as is.
2590 * Ex: [::192.200.003.4] -> [::192.200.3.4]
2591 * [ffff::192.200.003.4] -> [ffff::c0c8:3041]
2594 * For unknown scheme types Windows simply copies the address over without any
2597 * IPv4 address can be included in an elision if all its components are 0's.
2599 static BOOL canonicalize_ipv6address(const parse_data *data, Uri *uri,
2600 DWORD flags, BOOL computeOnly) {
2601 uri->host_start = uri->canon_len;
2603 if(data->scheme_type == URL_SCHEME_UNKNOWN) {
2605 memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
2606 uri->canon_len += data->host_len;
2610 DWORD i, elision_len;
2612 if(!ipv6_to_number(&(data->ipv6_address), values)) {
2613 TRACE("(%p %p %x %d): Failed to compute numerical value for IPv6 address.\n",
2614 data, uri, flags, computeOnly);
2619 uri->canon_uri[uri->canon_len] = '[';
2622 /* Find where the elision should occur (if any). */
2623 compute_elision_location(&(data->ipv6_address), values, &elision_start, &elision_len);
2625 TRACE("%p %p %x %d): Elision starts at %d, len=%u\n", data, uri, flags,
2626 computeOnly, elision_start, elision_len);
2628 for(i = 0; i < 8; ++i) {
2629 BOOL in_elision = (elision_start > -1 && i >= elision_start &&
2630 i < elision_start+elision_len);
2631 BOOL do_ipv4 = (i == 6 && data->ipv6_address.ipv4 && !in_elision &&
2632 data->ipv6_address.h16_count == 0);
2634 if(i == elision_start) {
2636 uri->canon_uri[uri->canon_len] = ':';
2637 uri->canon_uri[uri->canon_len+1] = ':';
2639 uri->canon_len += 2;
2642 /* We can ignore the current component if we're in the elision. */
2646 /* We only add a ':' if we're not at i == 0, or when we're at
2647 * the very end of elision range since the ':' colon was handled
2648 * earlier. Otherwise we would end up with ":::" after elision.
2650 if(i != 0 && !(elision_start > -1 && i == elision_start+elision_len)) {
2652 uri->canon_uri[uri->canon_len] = ':';
2660 /* Combine the two parts of the IPv4 address values. */
2666 len = ui2ipv4(uri->canon_uri+uri->canon_len, val);
2668 len = ui2ipv4(NULL, val);
2670 uri->canon_len += len;
2673 /* Write a regular h16 component to the URI. */
2675 /* Short circuit for the trivial case. */
2676 if(values[i] == 0) {
2678 uri->canon_uri[uri->canon_len] = '0';
2681 static const WCHAR formatW[] = {'%','x',0};
2684 uri->canon_len += sprintfW(uri->canon_uri+uri->canon_len,
2685 formatW, values[i]);
2688 uri->canon_len += sprintfW(tmp, formatW, values[i]);
2694 /* Add the closing ']'. */
2696 uri->canon_uri[uri->canon_len] = ']';
2700 uri->host_len = uri->canon_len - uri->host_start;
2703 TRACE("(%p %p %x %d): Canonicalized IPv6 address %s, len=%d\n", data, uri, flags,
2704 computeOnly, debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
2710 /* Attempts to canonicalize the host of the URI (if any). */
2711 static BOOL canonicalize_host(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2712 uri->host_start = -1;
2714 uri->domain_offset = -1;
2717 switch(data->host_type) {
2719 uri->host_type = Uri_HOST_DNS;
2720 if(!canonicalize_reg_name(data, uri, flags, computeOnly))
2725 uri->host_type = Uri_HOST_IPV4;
2726 if(!canonicalize_ipv4address(data, uri, flags, computeOnly))
2731 if(!canonicalize_ipv6address(data, uri, flags, computeOnly))
2734 uri->host_type = Uri_HOST_IPV6;
2736 case Uri_HOST_UNKNOWN:
2737 if(data->host_len > 0 || data->scheme_type != URL_SCHEME_FILE) {
2738 uri->host_start = uri->canon_len;
2740 /* Nothing happens to unknown host types. */
2742 memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
2743 uri->canon_len += data->host_len;
2744 uri->host_len = data->host_len;
2747 uri->host_type = Uri_HOST_UNKNOWN;
2750 FIXME("(%p %p %x %d): Canonicalization for host type %d not supported.\n", data,
2751 uri, flags, computeOnly, data->host_type);
2759 static BOOL canonicalize_port(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2760 BOOL has_default_port = FALSE;
2761 USHORT default_port = 0;
2764 /* Check if the scheme has a default port. */
2765 for(i = 0; i < sizeof(default_ports)/sizeof(default_ports[0]); ++i) {
2766 if(default_ports[i].scheme == data->scheme_type) {
2767 has_default_port = TRUE;
2768 default_port = default_ports[i].port;
2773 uri->has_port = data->has_port || has_default_port;
2776 * 1) Has a port which is the default port.
2777 * 2) Has a port (not the default).
2778 * 3) Doesn't have a port, but, scheme has a default port.
2781 if(has_default_port && data->has_port && data->port_value == default_port) {
2782 /* If it's the default port and this flag isn't set, don't do anything. */
2783 if(flags & Uri_CREATE_NO_CANONICALIZE) {
2785 uri->canon_uri[uri->canon_len] = ':';
2789 /* Copy the original port over. */
2791 memcpy(uri->canon_uri+uri->canon_len, data->port, data->port_len*sizeof(WCHAR));
2792 uri->canon_len += data->port_len;
2795 uri->canon_len += ui2str(uri->canon_uri+uri->canon_len, data->port_value);
2797 uri->canon_len += ui2str(NULL, data->port_value);
2801 uri->port = default_port;
2802 } else if(data->has_port) {
2804 uri->canon_uri[uri->canon_len] = ':';
2807 if(flags & Uri_CREATE_NO_CANONICALIZE && data->port) {
2808 /* Copy the original over without changes. */
2810 memcpy(uri->canon_uri+uri->canon_len, data->port, data->port_len*sizeof(WCHAR));
2811 uri->canon_len += data->port_len;
2814 uri->canon_len += ui2str(uri->canon_uri+uri->canon_len, data->port_value);
2816 uri->canon_len += ui2str(NULL, data->port_value);
2819 uri->port = data->port_value;
2820 } else if(has_default_port)
2821 uri->port = default_port;
2826 /* Canonicalizes the authority of the URI represented by the parse_data. */
2827 static BOOL canonicalize_authority(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
2828 uri->authority_start = uri->canon_len;
2829 uri->authority_len = 0;
2831 if(!canonicalize_userinfo(data, uri, flags, computeOnly))
2834 if(!canonicalize_host(data, uri, flags, computeOnly))
2837 if(!canonicalize_port(data, uri, flags, computeOnly))
2840 if(uri->host_start != -1 || (data->is_relative && (data->password || data->username)))
2841 uri->authority_len = uri->canon_len - uri->authority_start;
2843 uri->authority_start = -1;
2848 /* Attempts to canonicalize the path of a hierarchical URI.
2850 * Things that happen:
2851 * 1). Forbidden characters are percent encoded, unless the NO_ENCODE_FORBIDDEN
2852 * flag is set or it's a file URI. Forbidden characters are always encoded
2853 * for file schemes reguardless and forbidden characters are never encoded
2854 * for unknown scheme types.
2856 * 2). For known scheme types '\\' are changed to '/'.
2858 * 3). Percent encoded, unreserved characters are decoded to their actual values.
2859 * Unless the scheme type is unknown. For file schemes any percent encoded
2860 * character in the unreserved or reserved set is decoded.
2862 * 4). For File schemes if the path is starts with a drive letter and doesn't
2863 * start with a '/' then one is appended.
2864 * Ex: file://c:/test.mp3 -> file:///c:/test.mp3
2866 * 5). Dot segments are removed from the path for all scheme types
2867 * unless NO_CANONICALIZE flag is set. Dot segments aren't removed
2868 * for wildcard scheme types.
2871 * file://c:/test%20test -> file:///c:/test%2520test
2872 * file://c:/test%3Etest -> file:///c:/test%253Etest
2873 * file:///c:/test%20test -> file:///c:/test%20test
2874 * file:///c:/test%test -> file:///c:/test%25test
2876 static BOOL canonicalize_path_hierarchical(const parse_data *data, Uri *uri,
2877 DWORD flags, BOOL computeOnly) {
2879 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
2880 const BOOL is_file = data->scheme_type == URL_SCHEME_FILE;
2882 BOOL escape_pct = FALSE;
2885 uri->path_start = -1;
2890 uri->path_start = uri->canon_len;
2893 if(is_file && uri->host_start == -1) {
2894 /* Check if a '/' needs to be appended for the file scheme. */
2895 if(data->path_len > 1 && is_drive_path(ptr) && !(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
2897 uri->canon_uri[uri->canon_len] = '/';
2900 } else if(*ptr == '/') {
2901 if(!(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
2902 /* Copy the extra '/' over. */
2904 uri->canon_uri[uri->canon_len] = '/';
2910 if(is_drive_path(ptr)) {
2912 uri->canon_uri[uri->canon_len] = *ptr;
2913 /* If theres a '|' after the drive letter, convert it to a ':'. */
2914 uri->canon_uri[uri->canon_len+1] = ':';
2917 uri->canon_len += 2;
2921 if(!is_file && *(data->path) && *(data->path) != '/') {
2922 /* Prepend a '/' to the path if it doesn't have one. */
2924 uri->canon_uri[uri->canon_len] = '/';
2928 for(; ptr < data->path+data->path_len; ++ptr) {
2930 const WCHAR *tmp = ptr;
2933 /* Check if the % represents a valid encoded char, or if it needs encoded. */
2934 BOOL force_encode = !check_pct_encoded(&tmp) && is_file;
2935 val = decode_pct_val(ptr);
2937 if(force_encode || escape_pct) {
2938 /* Escape the percent sign in the file URI. */
2940 pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
2941 uri->canon_len += 3;
2942 } else if((is_unreserved(val) && known_scheme) ||
2943 (is_file && (is_unreserved(val) || is_reserved(val)))) {
2945 uri->canon_uri[uri->canon_len] = val;
2952 uri->canon_uri[uri->canon_len] = *ptr;
2955 } else if(*ptr == '/' && is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
2956 /* Convert the '/' back to a '\\'. */
2958 uri->canon_uri[uri->canon_len] = '\\';
2960 } else if(*ptr == '\\' && known_scheme) {
2961 if(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
2962 /* Don't convert the '\\' to a '/'. */
2964 uri->canon_uri[uri->canon_len] = *ptr;
2968 uri->canon_uri[uri->canon_len] = '/';
2971 } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr) &&
2972 (!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) || is_file)) {
2973 if(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
2974 /* Don't escape the character. */
2976 uri->canon_uri[uri->canon_len] = *ptr;
2979 /* Escape the forbidden character. */
2981 pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
2982 uri->canon_len += 3;
2986 uri->canon_uri[uri->canon_len] = *ptr;
2991 uri->path_len = uri->canon_len - uri->path_start;
2993 /* Removing the dot segments only happens when it's not in
2994 * computeOnly mode and it's not a wildcard scheme. File schemes
2995 * with USE_DOS_PATH set don't get dot segments removed.
2997 if(!(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) &&
2998 data->scheme_type != URL_SCHEME_WILDCARD) {
2999 if(!(flags & Uri_CREATE_NO_CANONICALIZE) && !computeOnly) {
3000 /* Remove the dot segments (if any) and reset everything to the new
3003 DWORD new_len = remove_dot_segments(uri->canon_uri+uri->path_start, uri->path_len);
3004 uri->canon_len -= uri->path_len-new_len;
3005 uri->path_len = new_len;
3010 TRACE("Canonicalized path %s len=%d\n",
3011 debugstr_wn(uri->canon_uri+uri->path_start, uri->path_len),
3017 /* Attempts to canonicalize the path for an opaque URI.
3019 * For known scheme types:
3020 * 1) forbidden characters are percent encoded if
3021 * NO_ENCODE_FORBIDDEN_CHARACTERS isn't set.
3023 * 2) Percent encoded, unreserved characters are decoded
3024 * to their actual values, for known scheme types.
3026 * 3) '\\' are changed to '/' for known scheme types
3027 * except for mailto schemes.
3029 * 4) For file schemes, if USE_DOS_PATH is set all '/'
3030 * are converted to backslashes.
3032 * 5) For file schemes, if USE_DOS_PATH isn't set all '\'
3033 * are converted to forward slashes.
3035 static BOOL canonicalize_path_opaque(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
3037 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
3038 const BOOL is_file = data->scheme_type == URL_SCHEME_FILE;
3041 uri->path_start = -1;
3046 uri->path_start = uri->canon_len;
3048 /* Windows doesn't allow a "//" to appear after the scheme
3049 * of a URI, if it's an opaque URI.
3051 if(data->scheme && *(data->path) == '/' && *(data->path+1) == '/') {
3052 /* So it inserts a "/." before the "//" if it exists. */
3054 uri->canon_uri[uri->canon_len] = '/';
3055 uri->canon_uri[uri->canon_len+1] = '.';
3058 uri->canon_len += 2;
3061 for(ptr = data->path; ptr < data->path+data->path_len; ++ptr) {
3062 if(*ptr == '%' && known_scheme) {
3063 WCHAR val = decode_pct_val(ptr);
3065 if(is_unreserved(val)) {
3067 uri->canon_uri[uri->canon_len] = val;
3074 uri->canon_uri[uri->canon_len] = *ptr;
3077 } else if(*ptr == '/' && is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
3079 uri->canon_uri[uri->canon_len] = '\\';
3081 } else if(*ptr == '\\' && is_file) {
3082 if(!(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
3083 /* Convert to a '/'. */
3085 uri->canon_uri[uri->canon_len] = '/';
3088 /* Just copy it over. */
3090 uri->canon_uri[uri->canon_len] = *ptr;
3093 } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr) &&
3094 !(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
3095 if(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
3096 /* Forbidden characters aren't percent encoded for file schemes
3097 * with USE_DOS_PATH set.
3100 uri->canon_uri[uri->canon_len] = *ptr;
3102 } else if(data->scheme_type == URL_SCHEME_MK && *ptr == '\\') {
3103 /* MK URIs don't get '\\' percent encoded. */
3105 uri->canon_uri[uri->canon_len] = *ptr;
3109 pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
3110 uri->canon_len += 3;
3114 uri->canon_uri[uri->canon_len] = *ptr;
3119 uri->path_len = uri->canon_len - uri->path_start;
3121 TRACE("(%p %p %x %d): Canonicalized opaque URI path %s len=%d\n", data, uri, flags, computeOnly,
3122 debugstr_wn(uri->canon_uri+uri->path_start, uri->path_len), uri->path_len);
3126 /* Determines how the URI represented by the parse_data should be canonicalized.
3128 * Essentially, if the parse_data represents an hierarchical URI then it calls
3129 * canonicalize_authority and the canonicalization functions for the path. If the
3130 * URI is opaque it canonicalizes the path of the URI.
3132 static BOOL canonicalize_hierpart(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
3133 uri->display_absolute = TRUE;
3135 if(!data->is_opaque || (data->is_relative && (data->password || data->username))) {
3136 /* "//" is only added for non-wildcard scheme types.
3138 * A "//" is only added to a relative URI if it has a
3139 * host or port component (this only happens if a IUriBuilder
3140 * is generating an IUri).
3142 if((data->is_relative && (data->host || data->has_port)) ||
3143 (!data->is_relative && data->scheme_type != URL_SCHEME_WILDCARD)) {
3145 INT pos = uri->canon_len;
3147 uri->canon_uri[pos] = '/';
3148 uri->canon_uri[pos+1] = '/';
3150 uri->canon_len += 2;
3153 if(!canonicalize_authority(data, uri, flags, computeOnly))
3156 if(data->is_relative && (data->password || data->username)) {
3157 if(!canonicalize_path_opaque(data, uri, flags, computeOnly))
3160 if(!canonicalize_path_hierarchical(data, uri, flags, computeOnly))
3164 /* Opaque URI's don't have an authority. */
3165 uri->userinfo_start = uri->userinfo_split = -1;
3166 uri->userinfo_len = 0;
3167 uri->host_start = -1;
3169 uri->host_type = Uri_HOST_UNKNOWN;
3170 uri->has_port = FALSE;
3171 uri->authority_start = -1;
3172 uri->authority_len = 0;
3173 uri->domain_offset = -1;
3175 if(is_hierarchical_scheme(data->scheme_type)) {
3178 /* Absolute URIs aren't displayed for known scheme types
3179 * which should be hierarchical URIs.
3181 uri->display_absolute = FALSE;
3183 /* Windows also sets the port for these (if they have one). */
3184 for(i = 0; i < sizeof(default_ports)/sizeof(default_ports[0]); ++i) {
3185 if(data->scheme_type == default_ports[i].scheme) {
3186 uri->has_port = TRUE;
3187 uri->port = default_ports[i].port;
3193 if(!canonicalize_path_opaque(data, uri, flags, computeOnly))
3197 if(uri->path_start > -1 && !computeOnly)
3198 /* Finding file extensions happens for both types of URIs. */
3199 uri->extension_offset = find_file_extension(uri->canon_uri+uri->path_start, uri->path_len);
3201 uri->extension_offset = -1;
3206 /* Attempts to canonicalize the query string of the URI.
3208 * Things that happen:
3209 * 1) For known scheme types forbidden characters
3210 * are percent encoded, unless the NO_DECODE_EXTRA_INFO flag is set
3211 * or NO_ENCODE_FORBIDDEN_CHARACTERS is set.
3213 * 2) For known scheme types, percent encoded, unreserved characters
3214 * are decoded as long as the NO_DECODE_EXTRA_INFO flag isn't set.
3216 static BOOL canonicalize_query(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
3217 const WCHAR *ptr, *end;
3218 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
3221 uri->query_start = -1;
3226 uri->query_start = uri->canon_len;
3228 end = data->query+data->query_len;
3229 for(ptr = data->query; ptr < end; ++ptr) {
3231 if(known_scheme && !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
3232 WCHAR val = decode_pct_val(ptr);
3233 if(is_unreserved(val)) {
3235 uri->canon_uri[uri->canon_len] = val;
3242 } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr)) {
3243 if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) &&
3244 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
3246 pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
3247 uri->canon_len += 3;
3253 uri->canon_uri[uri->canon_len] = *ptr;
3257 uri->query_len = uri->canon_len - uri->query_start;
3260 TRACE("(%p %p %x %d): Canonicalized query string %s len=%d\n", data, uri, flags,
3261 computeOnly, debugstr_wn(uri->canon_uri+uri->query_start, uri->query_len),
3266 static BOOL canonicalize_fragment(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
3267 const WCHAR *ptr, *end;
3268 const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
3270 if(!data->fragment) {
3271 uri->fragment_start = -1;
3272 uri->fragment_len = 0;
3276 uri->fragment_start = uri->canon_len;
3278 end = data->fragment + data->fragment_len;
3279 for(ptr = data->fragment; ptr < end; ++ptr) {
3281 if(known_scheme && !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
3282 WCHAR val = decode_pct_val(ptr);
3283 if(is_unreserved(val)) {
3285 uri->canon_uri[uri->canon_len] = val;
3292 } else if(known_scheme && !is_unreserved(*ptr) && !is_reserved(*ptr)) {
3293 if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) &&
3294 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
3296 pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
3297 uri->canon_len += 3;
3303 uri->canon_uri[uri->canon_len] = *ptr;
3307 uri->fragment_len = uri->canon_len - uri->fragment_start;
3310 TRACE("(%p %p %x %d): Canonicalized fragment %s len=%d\n", data, uri, flags,
3311 computeOnly, debugstr_wn(uri->canon_uri+uri->fragment_start, uri->fragment_len),
3316 /* Canonicalizes the scheme information specified in the parse_data using the specified flags. */
3317 static BOOL canonicalize_scheme(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly) {
3318 uri->scheme_start = -1;
3319 uri->scheme_len = 0;
3322 /* The only type of URI that doesn't have to have a scheme is a relative
3325 if(!data->is_relative) {
3326 FIXME("(%p %p %x): Unable to determine the scheme type of %s.\n", data,
3327 uri, flags, debugstr_w(data->uri));
3333 INT pos = uri->canon_len;
3335 for(i = 0; i < data->scheme_len; ++i) {
3336 /* Scheme name must be lower case after canonicalization. */
3337 uri->canon_uri[i + pos] = tolowerW(data->scheme[i]);
3340 uri->canon_uri[i + pos] = ':';
3341 uri->scheme_start = pos;
3343 TRACE("(%p %p %x): Canonicalized scheme=%s, len=%d.\n", data, uri, flags,
3344 debugstr_wn(uri->canon_uri, uri->scheme_len), data->scheme_len);
3347 /* This happens in both computation modes. */
3348 uri->canon_len += data->scheme_len + 1;
3349 uri->scheme_len = data->scheme_len;
3354 /* Compute's what the length of the URI specified by the parse_data will be
3355 * after canonicalization occurs using the specified flags.
3357 * This function will return a non-zero value indicating the length of the canonicalized
3358 * URI, or -1 on error.
3360 static int compute_canonicalized_length(const parse_data *data, DWORD flags) {
3363 memset(&uri, 0, sizeof(Uri));
3365 TRACE("(%p %x): Beginning to compute canonicalized length for URI %s\n", data, flags,
3366 debugstr_w(data->uri));
3368 if(!canonicalize_scheme(data, &uri, flags, TRUE)) {
3369 ERR("(%p %x): Failed to compute URI scheme length.\n", data, flags);
3373 if(!canonicalize_hierpart(data, &uri, flags, TRUE)) {
3374 ERR("(%p %x): Failed to compute URI hierpart length.\n", data, flags);
3378 if(!canonicalize_query(data, &uri, flags, TRUE)) {
3379 ERR("(%p %x): Failed to compute query string length.\n", data, flags);
3383 if(!canonicalize_fragment(data, &uri, flags, TRUE)) {
3384 ERR("(%p %x): Failed to compute fragment length.\n", data, flags);
3388 TRACE("(%p %x): Finished computing canonicalized URI length. length=%d\n", data, flags, uri.canon_len);
3390 return uri.canon_len;
3393 /* Canonicalizes the URI data specified in the parse_data, using the given flags. If the
3394 * canonicalization succeededs it will store all the canonicalization information
3395 * in the pointer to the Uri.
3397 * To canonicalize a URI this function first computes what the length of the URI
3398 * specified by the parse_data will be. Once this is done it will then perfom the actual
3399 * canonicalization of the URI.
3401 static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags) {
3404 uri->canon_uri = NULL;
3405 len = uri->canon_size = uri->canon_len = 0;
3407 TRACE("(%p %p %x): beginning to canonicalize URI %s.\n", data, uri, flags, debugstr_w(data->uri));
3409 /* First try to compute the length of the URI. */
3410 len = compute_canonicalized_length(data, flags);
3412 ERR("(%p %p %x): Could not compute the canonicalized length of %s.\n", data, uri, flags,
3413 debugstr_w(data->uri));
3414 return E_INVALIDARG;
3417 uri->canon_uri = heap_alloc((len+1)*sizeof(WCHAR));
3419 return E_OUTOFMEMORY;
3421 uri->canon_size = len;
3422 if(!canonicalize_scheme(data, uri, flags, FALSE)) {
3423 ERR("(%p %p %x): Unable to canonicalize the scheme of the URI.\n", data, uri, flags);
3424 return E_INVALIDARG;
3426 uri->scheme_type = data->scheme_type;
3428 if(!canonicalize_hierpart(data, uri, flags, FALSE)) {
3429 ERR("(%p %p %x): Unable to canonicalize the heirpart of the URI\n", data, uri, flags);
3430 return E_INVALIDARG;
3433 if(!canonicalize_query(data, uri, flags, FALSE)) {
3434 ERR("(%p %p %x): Unable to canonicalize query string of the URI.\n",
3436 return E_INVALIDARG;
3439 if(!canonicalize_fragment(data, uri, flags, FALSE)) {
3440 ERR("(%p %p %x): Unable to canonicalize fragment of the URI.\n",
3442 return E_INVALIDARG;
3445 /* There's a possibility we didn't use all the space we allocated
3448 if(uri->canon_len < uri->canon_size) {
3449 /* This happens if the URI is hierarchical and dot
3450 * segments were removed from it's path.
3452 WCHAR *tmp = heap_realloc(uri->canon_uri, (uri->canon_len+1)*sizeof(WCHAR));
3454 return E_OUTOFMEMORY;
3456 uri->canon_uri = tmp;
3457 uri->canon_size = uri->canon_len;
3460 uri->canon_uri[uri->canon_len] = '\0';
3461 TRACE("(%p %p %x): finished canonicalizing the URI. uri=%s\n", data, uri, flags, debugstr_w(uri->canon_uri));
3466 static HRESULT get_builder_component(LPWSTR *component, DWORD *component_len,
3467 LPCWSTR source, DWORD source_len,
3468 LPCWSTR *output, DWORD *output_len)
3481 if(!(*component) && source) {
3482 /* Allocate 'component', and copy the contents from 'source'
3483 * into the new allocation.
3485 *component = heap_alloc((source_len+1)*sizeof(WCHAR));
3487 return E_OUTOFMEMORY;
3489 memcpy(*component, source, source_len*sizeof(WCHAR));
3490 (*component)[source_len] = '\0';
3491 *component_len = source_len;
3494 *output = *component;
3495 *output_len = *component_len;
3496 return *output ? S_OK : S_FALSE;
3499 /* Allocates 'component' and copies the string from 'new_value' into 'component'.
3500 * If 'prefix' is set and 'new_value' isn't NULL, then it checks if 'new_value'
3501 * starts with 'prefix'. If it doesn't then 'prefix' is prepended to 'component'.
3503 * If everything is successful, then will set 'success_flag' in 'flags'.
3505 static HRESULT set_builder_component(LPWSTR *component, DWORD *component_len, LPCWSTR new_value,
3506 WCHAR prefix, DWORD *flags, DWORD success_flag)
3508 heap_free(*component);
3514 BOOL add_prefix = FALSE;
3515 DWORD len = lstrlenW(new_value);
3518 if(prefix && *new_value != prefix) {
3520 *component = heap_alloc((len+2)*sizeof(WCHAR));
3522 *component = heap_alloc((len+1)*sizeof(WCHAR));
3525 return E_OUTOFMEMORY;
3528 (*component)[pos++] = prefix;
3530 memcpy(*component+pos, new_value, (len+1)*sizeof(WCHAR));
3531 *component_len = len+pos;
3534 *flags |= success_flag;
3538 #define URI(x) ((IUri*) &(x)->lpIUriVtbl)
3539 #define URIBUILDER(x) ((IUriBuilder*) &(x)->lpIUriBuilderVtbl)
3541 static void reset_builder(UriBuilder *builder) {
3543 IUri_Release(URI(builder->uri));
3544 builder->uri = NULL;
3546 heap_free(builder->fragment);
3547 builder->fragment = NULL;
3548 builder->fragment_len = 0;
3550 heap_free(builder->host);
3551 builder->host = NULL;
3552 builder->host_len = 0;
3554 heap_free(builder->password);
3555 builder->password = NULL;
3556 builder->password_len = 0;
3558 heap_free(builder->path);
3559 builder->path = NULL;
3560 builder->path_len = 0;
3562 heap_free(builder->query);
3563 builder->query = NULL;
3564 builder->query_len = 0;
3566 heap_free(builder->scheme);
3567 builder->scheme = NULL;
3568 builder->scheme_len = 0;
3570 heap_free(builder->username);
3571 builder->username = NULL;
3572 builder->username_len = 0;
3574 builder->has_port = FALSE;
3576 builder->modified_props = 0;
3579 static HRESULT validate_scheme_name(const UriBuilder *builder, parse_data *data, DWORD flags) {
3580 const WCHAR *component;
3585 if(builder->scheme) {
3586 ptr = builder->scheme;
3587 expected_len = builder->scheme_len;
3588 } else if(builder->uri && builder->uri->scheme_start > -1) {
3589 ptr = builder->uri->canon_uri+builder->uri->scheme_start;
3590 expected_len = builder->uri->scheme_len;
3592 static const WCHAR nullW[] = {0};
3599 if(parse_scheme(pptr, data, flags, ALLOW_NULL_TERM_SCHEME) &&
3600 data->scheme_len == expected_len) {
3602 TRACE("(%p %p %x): Found valid scheme component %s len=%d.\n", builder, data, flags,
3603 debugstr_wn(data->scheme, data->scheme_len), data->scheme_len);
3605 TRACE("(%p %p %x): Invalid scheme component found %s.\n", builder, data, flags,
3606 debugstr_wn(component, expected_len));
3607 return INET_E_INVALID_URL;
3613 static HRESULT validate_username(const UriBuilder *builder, parse_data *data, DWORD flags) {
3618 if(builder->username) {
3619 ptr = builder->username;
3620 expected_len = builder->username_len;
3621 } else if(!(builder->modified_props & Uri_HAS_USER_NAME) && builder->uri &&
3622 builder->uri->userinfo_start > -1 && builder->uri->userinfo_split != 0) {
3623 /* Just use the username from the base Uri. */
3624 data->username = builder->uri->canon_uri+builder->uri->userinfo_start;
3625 data->username_len = (builder->uri->userinfo_split > -1) ?
3626 builder->uri->userinfo_split : builder->uri->userinfo_len;
3634 const WCHAR *component = ptr;
3636 if(parse_username(pptr, data, flags, ALLOW_NULL_TERM_USER_NAME) &&
3637 data->username_len == expected_len)
3638 TRACE("(%p %p %x): Found valid username component %s len=%d.\n", builder, data, flags,
3639 debugstr_wn(data->username, data->username_len), data->username_len);
3641 TRACE("(%p %p %x): Invalid username component found %s.\n", builder, data, flags,
3642 debugstr_wn(component, expected_len));
3643 return INET_E_INVALID_URL;
3650 static HRESULT validate_password(const UriBuilder *builder, parse_data *data, DWORD flags) {
3655 if(builder->password) {
3656 ptr = builder->password;
3657 expected_len = builder->password_len;
3658 } else if(!(builder->modified_props & Uri_HAS_PASSWORD) && builder->uri &&
3659 builder->uri->userinfo_split > -1) {
3660 data->password = builder->uri->canon_uri+builder->uri->userinfo_start+builder->uri->userinfo_split+1;
3661 data->password_len = builder->uri->userinfo_len-builder->uri->userinfo_split-1;
3669 const WCHAR *component = ptr;
3671 if(parse_password(pptr, data, flags, ALLOW_NULL_TERM_PASSWORD) &&
3672 data->password_len == expected_len)
3673 TRACE("(%p %p %x): Found valid password component %s len=%d.\n", builder, data, flags,
3674 debugstr_wn(data->password, data->password_len), data->password_len);
3676 TRACE("(%p %p %x): Invalid password component found %s.\n", builder, data, flags,
3677 debugstr_wn(component, expected_len));
3678 return INET_E_INVALID_URL;
3685 static HRESULT validate_userinfo(const UriBuilder *builder, parse_data *data, DWORD flags) {
3688 hr = validate_username(builder, data, flags);
3692 hr = validate_password(builder, data, flags);
3699 static HRESULT validate_host(const UriBuilder *builder, parse_data *data, DWORD flags) {
3705 ptr = builder->host;
3706 expected_len = builder->host_len;
3707 } else if(!(builder->modified_props & Uri_HAS_HOST) && builder->uri && builder->uri->host_start > -1) {
3708 ptr = builder->uri->canon_uri + builder->uri->host_start;
3709 expected_len = builder->uri->host_len;
3714 const WCHAR *component = ptr;
3715 DWORD extras = ALLOW_BRACKETLESS_IP_LITERAL|IGNORE_PORT_DELIMITER|SKIP_IP_FUTURE_CHECK;
3718 if(parse_host(pptr, data, flags, extras) && data->host_len == expected_len)
3719 TRACE("(%p %p %x): Found valid host name %s len=%d type=%d.\n", builder, data, flags,
3720 debugstr_wn(data->host, data->host_len), data->host_len, data->host_type);
3722 TRACE("(%p %p %x): Invalid host name found %s.\n", builder, data, flags,
3723 debugstr_wn(component, expected_len));
3724 return INET_E_INVALID_URL;
3731 static void setup_port(const UriBuilder *builder, parse_data *data, DWORD flags) {
3732 if(builder->modified_props & Uri_HAS_PORT) {
3733 if(builder->has_port) {
3734 data->has_port = TRUE;
3735 data->port_value = builder->port;
3737 } else if(builder->uri && builder->uri->has_port) {
3738 data->has_port = TRUE;
3739 data->port_value = builder->uri->port;
3743 TRACE("(%p %p %x): Using %u as port for IUri.\n", builder, data, flags, data->port_value);
3746 static HRESULT validate_path(const UriBuilder *builder, parse_data *data, DWORD flags) {
3747 const WCHAR *ptr = NULL;
3748 const WCHAR *component;
3751 BOOL check_len = TRUE;
3755 ptr = builder->path;
3756 expected_len = builder->path_len;
3757 } else if(!(builder->modified_props & Uri_HAS_PATH) &&
3758 builder->uri && builder->uri->path_start > -1) {
3759 ptr = builder->uri->canon_uri+builder->uri->path_start;
3760 expected_len = builder->uri->path_len;
3762 static const WCHAR nullW[] = {0};
3770 /* How the path is validated depends on what type of
3773 valid = data->is_opaque ?
3774 parse_path_opaque(pptr, data, flags) : parse_path_hierarchical(pptr, data, flags);
3776 if(!valid || (check_len && expected_len != data->path_len)) {
3777 TRACE("(%p %p %x): Invalid path componet %s.\n", builder, data, flags,
3778 debugstr_wn(component, expected_len));
3779 return INET_E_INVALID_URL;
3782 TRACE("(%p %p %x): Valid path component %s len=%d.\n", builder, data, flags,
3783 debugstr_wn(data->path, data->path_len), data->path_len);
3788 static HRESULT validate_query(const UriBuilder *builder, parse_data *data, DWORD flags) {
3789 const WCHAR *ptr = NULL;
3793 if(builder->query) {
3794 ptr = builder->query;
3795 expected_len = builder->query_len;
3796 } else if(!(builder->modified_props & Uri_HAS_QUERY) && builder->uri &&
3797 builder->uri->query_start > -1) {
3798 ptr = builder->uri->canon_uri+builder->uri->query_start;
3799 expected_len = builder->uri->query_len;
3803 const WCHAR *component = ptr;
3806 if(parse_query(pptr, data, flags) && expected_len == data->query_len)
3807 TRACE("(%p %p %x): Valid query component %s len=%d.\n", builder, data, flags,
3808 debugstr_wn(data->query, data->query_len), data->query_len);
3810 TRACE("(%p %p %x): Invalid query component %s.\n", builder, data, flags,
3811 debugstr_wn(component, expected_len));
3812 return INET_E_INVALID_URL;
3819 static HRESULT validate_fragment(const UriBuilder *builder, parse_data *data, DWORD flags) {
3820 const WCHAR *ptr = NULL;
3824 if(builder->fragment) {
3825 ptr = builder->fragment;
3826 expected_len = builder->fragment_len;
3827 } else if(!(builder->modified_props & Uri_HAS_FRAGMENT) && builder->uri &&
3828 builder->uri->fragment_start > -1) {
3829 ptr = builder->uri->canon_uri+builder->uri->fragment_start;
3830 expected_len = builder->uri->fragment_len;
3834 const WCHAR *component = ptr;
3837 if(parse_fragment(pptr, data, flags) && expected_len == data->fragment_len)
3838 TRACE("(%p %p %x): Valid fragment component %s len=%d.\n", builder, data, flags,
3839 debugstr_wn(data->fragment, data->fragment_len), data->fragment_len);
3841 TRACE("(%p %p %x): Invalid fragment component %s.\n", builder, data, flags,
3842 debugstr_wn(component, expected_len));
3843 return INET_E_INVALID_URL;
3850 static HRESULT validate_components(const UriBuilder *builder, parse_data *data, DWORD flags) {
3853 memset(data, 0, sizeof(parse_data));
3855 TRACE("(%p %p %x): Beginning to validate builder components.\n", builder, data, flags);
3857 hr = validate_scheme_name(builder, data, flags);
3861 /* Extra validation for file schemes. */
3862 if(data->scheme_type == URL_SCHEME_FILE) {
3863 if((builder->password || (builder->uri && builder->uri->userinfo_split > -1)) ||
3864 (builder->username || (builder->uri && builder->uri->userinfo_start > -1))) {
3865 TRACE("(%p %p %x): File schemes can't contain a username or password.\n",
3866 builder, data, flags);
3867 return INET_E_INVALID_URL;
3871 hr = validate_userinfo(builder, data, flags);
3875 hr = validate_host(builder, data, flags);
3879 setup_port(builder, data, flags);
3881 /* The URI is opaque if it doesn't have an authority component. */
3882 if(!data->is_relative)
3883 data->is_opaque = !data->username && !data->password && !data->host && !data->has_port;
3885 data->is_opaque = !data->host && !data->has_port;
3887 hr = validate_path(builder, data, flags);
3891 hr = validate_query(builder, data, flags);
3895 hr = validate_fragment(builder, data, flags);
3899 TRACE("(%p %p %x): Finished validating builder components.\n", builder, data, flags);
3904 /* Generates a raw uri string using the parse_data. */
3905 static DWORD generate_raw_uri(const parse_data *data, BSTR uri) {
3910 memcpy(uri, data->scheme, data->scheme_len*sizeof(WCHAR));
3911 uri[data->scheme_len] = ':';
3913 length += data->scheme_len+1;
3916 if(!data->is_opaque) {
3917 /* For the "//" which appears before the authority component. */
3920 uri[length+1] = '/';
3925 if(data->username) {
3927 memcpy(uri+length, data->username, data->username_len*sizeof(WCHAR));
3928 length += data->username_len;
3931 if(data->password) {
3934 memcpy(uri+length+1, data->password, data->password_len*sizeof(WCHAR));
3936 length += data->password_len+1;
3939 if(data->password || data->username) {
3946 /* IPv6 addresses get the brackets added around them if they don't already
3949 const BOOL add_brackets = data->host_type == Uri_HOST_IPV6 && *(data->host) != '[';
3957 memcpy(uri+length, data->host, data->host_len*sizeof(WCHAR));
3958 length += data->host_len;
3967 if(data->has_port) {
3968 /* The port isn't included in the raw uri if it's the default
3969 * port for the scheme type.
3972 BOOL is_default = FALSE;
3974 for(i = 0; i < sizeof(default_ports)/sizeof(default_ports[0]); ++i) {
3975 if(data->scheme_type == default_ports[i].scheme &&
3976 data->port_value == default_ports[i].port)
3986 length += ui2str(uri+length, data->port_value);
3988 length += ui2str(NULL, data->port_value);
3992 /* Check if a '/' should be added before the path for hierarchical URIs. */
3993 if(!data->is_opaque && data->path && *(data->path) != '/') {
4001 memcpy(uri+length, data->path, data->path_len*sizeof(WCHAR));
4002 length += data->path_len;
4007 memcpy(uri+length, data->query, data->query_len*sizeof(WCHAR));
4008 length += data->query_len;
4011 if(data->fragment) {
4013 memcpy(uri+length, data->fragment, data->fragment_len*sizeof(WCHAR));
4014 length += data->fragment_len;
4018 TRACE("(%p %p): Generated raw uri=%s len=%d\n", data, uri, debugstr_wn(uri, length), length);
4020 TRACE("(%p %p): Computed raw uri len=%d\n", data, uri, length);
4025 static HRESULT generate_uri(const UriBuilder *builder, const parse_data *data, Uri *uri, DWORD flags) {
4027 DWORD length = generate_raw_uri(data, NULL);
4028 uri->raw_uri = SysAllocStringLen(NULL, length);
4030 return E_OUTOFMEMORY;
4032 generate_raw_uri(data, uri->raw_uri);
4034 hr = canonicalize_uri(data, uri, flags);
4036 if(hr == E_INVALIDARG)
4037 return INET_E_INVALID_URL;
4041 uri->create_flags = flags;
4045 #define URI_THIS(iface) DEFINE_THIS(Uri, IUri, iface)
4047 static HRESULT WINAPI Uri_QueryInterface(IUri *iface, REFIID riid, void **ppv)
4049 Uri *This = URI_THIS(iface);
4051 if(IsEqualGUID(&IID_IUnknown, riid)) {
4052 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
4054 }else if(IsEqualGUID(&IID_IUri, riid)) {
4055 TRACE("(%p)->(IID_IUri %p)\n", This, ppv);
4057 }else if(IsEqualGUID(&IID_IUriObj, riid)) {
4058 TRACE("(%p)->(IID_IUriObj %p)\n", This, ppv);
4062 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
4064 return E_NOINTERFACE;
4067 IUnknown_AddRef((IUnknown*)*ppv);
4071 static ULONG WINAPI Uri_AddRef(IUri *iface)
4073 Uri *This = URI_THIS(iface);
4074 LONG ref = InterlockedIncrement(&This->ref);
4076 TRACE("(%p) ref=%d\n", This, ref);
4081 static ULONG WINAPI Uri_Release(IUri *iface)
4083 Uri *This = URI_THIS(iface);
4084 LONG ref = InterlockedDecrement(&This->ref);
4086 TRACE("(%p) ref=%d\n", This, ref);
4089 SysFreeString(This->raw_uri);
4090 heap_free(This->canon_uri);
4097 static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BSTR *pbstrProperty, DWORD dwFlags)
4099 Uri *This = URI_THIS(iface);
4101 TRACE("(%p)->(%d %p %x)\n", This, uriProp, pbstrProperty, dwFlags);
4106 if(uriProp > Uri_PROPERTY_STRING_LAST) {
4107 /* Windows allocates an empty BSTR for invalid Uri_PROPERTY's. */
4108 *pbstrProperty = SysAllocStringLen(NULL, 0);
4109 if(!(*pbstrProperty))
4110 return E_OUTOFMEMORY;
4112 /* It only returns S_FALSE for the ZONE property... */
4113 if(uriProp == Uri_PROPERTY_ZONE)
4119 /* Don't have support for flags yet. */
4121 FIXME("(%p)->(%d %p %x)\n", This, uriProp, pbstrProperty, dwFlags);
4126 case Uri_PROPERTY_ABSOLUTE_URI:
4127 if(!This->display_absolute) {
4128 *pbstrProperty = SysAllocStringLen(NULL, 0);
4131 if(This->scheme_type != URL_SCHEME_UNKNOWN && This->userinfo_start > -1) {
4132 if(This->userinfo_len == 0) {
4133 /* Don't include the '@' after the userinfo component. */
4134 *pbstrProperty = SysAllocStringLen(NULL, This->canon_len-1);
4136 if(*pbstrProperty) {
4137 /* Copy everything before it. */
4138 memcpy(*pbstrProperty, This->canon_uri, This->userinfo_start*sizeof(WCHAR));
4140 /* And everything after it. */
4141 memcpy(*pbstrProperty+This->userinfo_start, This->canon_uri+This->userinfo_start+1,
4142 (This->canon_len-This->userinfo_start-1)*sizeof(WCHAR));
4144 } else if(This->userinfo_split == 0 && This->userinfo_len == 1) {
4145 /* Don't include the ":@" */
4146 *pbstrProperty = SysAllocStringLen(NULL, This->canon_len-2);
4148 if(*pbstrProperty) {
4149 memcpy(*pbstrProperty, This->canon_uri, This->userinfo_start*sizeof(WCHAR));
4150 memcpy(*pbstrProperty+This->userinfo_start, This->canon_uri+This->userinfo_start+2,
4151 (This->canon_len-This->userinfo_start-2)*sizeof(WCHAR));
4154 *pbstrProperty = SysAllocString(This->canon_uri);
4158 *pbstrProperty = SysAllocString(This->canon_uri);
4163 if(!(*pbstrProperty))
4164 hres = E_OUTOFMEMORY;
4167 case Uri_PROPERTY_AUTHORITY:
4168 if(This->authority_start > -1) {
4169 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->authority_start, This->authority_len);
4172 *pbstrProperty = SysAllocStringLen(NULL, 0);
4176 if(!(*pbstrProperty))
4177 hres = E_OUTOFMEMORY;
4180 case Uri_PROPERTY_DISPLAY_URI:
4181 /* The Display URI contains everything except for the userinfo for known
4184 if(This->scheme_type != URL_SCHEME_UNKNOWN && This->userinfo_start > -1) {
4185 *pbstrProperty = SysAllocStringLen(NULL, This->canon_len-This->userinfo_len);
4187 if(*pbstrProperty) {
4188 /* Copy everything before the userinfo over. */
4189 memcpy(*pbstrProperty, This->canon_uri, This->userinfo_start*sizeof(WCHAR));
4190 /* Copy everything after the userinfo over. */
4191 memcpy(*pbstrProperty+This->userinfo_start,
4192 This->canon_uri+This->userinfo_start+This->userinfo_len+1,
4193 (This->canon_len-(This->userinfo_start+This->userinfo_len+1))*sizeof(WCHAR));
4196 *pbstrProperty = SysAllocString(This->canon_uri);
4198 if(!(*pbstrProperty))
4199 hres = E_OUTOFMEMORY;
4204 case Uri_PROPERTY_DOMAIN:
4205 if(This->domain_offset > -1) {
4206 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start+This->domain_offset,
4207 This->host_len-This->domain_offset);
4210 *pbstrProperty = SysAllocStringLen(NULL, 0);
4214 if(!(*pbstrProperty))
4215 hres = E_OUTOFMEMORY;
4218 case Uri_PROPERTY_EXTENSION:
4219 if(This->extension_offset > -1) {
4220 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start+This->extension_offset,
4221 This->path_len-This->extension_offset);
4224 *pbstrProperty = SysAllocStringLen(NULL, 0);
4228 if(!(*pbstrProperty))
4229 hres = E_OUTOFMEMORY;
4232 case Uri_PROPERTY_FRAGMENT:
4233 if(This->fragment_start > -1) {
4234 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->fragment_start, This->fragment_len);
4237 *pbstrProperty = SysAllocStringLen(NULL, 0);
4241 if(!(*pbstrProperty))
4242 hres = E_OUTOFMEMORY;
4245 case Uri_PROPERTY_HOST:
4246 if(This->host_start > -1) {
4247 /* The '[' and ']' aren't included for IPv6 addresses. */
4248 if(This->host_type == Uri_HOST_IPV6)
4249 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start+1, This->host_len-2);
4251 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->host_start, This->host_len);
4255 *pbstrProperty = SysAllocStringLen(NULL, 0);
4259 if(!(*pbstrProperty))
4260 hres = E_OUTOFMEMORY;
4263 case Uri_PROPERTY_PASSWORD:
4264 if(This->userinfo_split > -1) {
4265 *pbstrProperty = SysAllocStringLen(
4266 This->canon_uri+This->userinfo_start+This->userinfo_split+1,
4267 This->userinfo_len-This->userinfo_split-1);
4270 *pbstrProperty = SysAllocStringLen(NULL, 0);
4274 if(!(*pbstrProperty))
4275 return E_OUTOFMEMORY;
4278 case Uri_PROPERTY_PATH:
4279 if(This->path_start > -1) {
4280 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start, This->path_len);
4283 *pbstrProperty = SysAllocStringLen(NULL, 0);
4287 if(!(*pbstrProperty))
4288 hres = E_OUTOFMEMORY;
4291 case Uri_PROPERTY_PATH_AND_QUERY:
4292 if(This->path_start > -1) {
4293 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start, This->path_len+This->query_len);
4295 } else if(This->query_start > -1) {
4296 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->query_start, This->query_len);
4299 *pbstrProperty = SysAllocStringLen(NULL, 0);
4303 if(!(*pbstrProperty))
4304 hres = E_OUTOFMEMORY;
4307 case Uri_PROPERTY_QUERY:
4308 if(This->query_start > -1) {
4309 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->query_start, This->query_len);
4312 *pbstrProperty = SysAllocStringLen(NULL, 0);
4316 if(!(*pbstrProperty))
4317 hres = E_OUTOFMEMORY;
4320 case Uri_PROPERTY_RAW_URI:
4321 *pbstrProperty = SysAllocString(This->raw_uri);
4322 if(!(*pbstrProperty))
4323 hres = E_OUTOFMEMORY;
4327 case Uri_PROPERTY_SCHEME_NAME:
4328 if(This->scheme_start > -1) {
4329 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->scheme_start, This->scheme_len);
4332 *pbstrProperty = SysAllocStringLen(NULL, 0);
4336 if(!(*pbstrProperty))
4337 hres = E_OUTOFMEMORY;
4340 case Uri_PROPERTY_USER_INFO:
4341 if(This->userinfo_start > -1) {
4342 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->userinfo_start, This->userinfo_len);
4345 *pbstrProperty = SysAllocStringLen(NULL, 0);
4349 if(!(*pbstrProperty))
4350 hres = E_OUTOFMEMORY;
4353 case Uri_PROPERTY_USER_NAME:
4354 if(This->userinfo_start > -1 && This->userinfo_split != 0) {
4355 /* If userinfo_split is set, that means a password exists
4356 * so the username is only from userinfo_start to userinfo_split.
4358 if(This->userinfo_split > -1) {
4359 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->userinfo_start, This->userinfo_split);
4362 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->userinfo_start, This->userinfo_len);
4366 *pbstrProperty = SysAllocStringLen(NULL, 0);
4370 if(!(*pbstrProperty))
4371 return E_OUTOFMEMORY;
4375 FIXME("(%p)->(%d %p %x)\n", This, uriProp, pbstrProperty, dwFlags);
4382 static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
4384 Uri *This = URI_THIS(iface);
4386 TRACE("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
4389 return E_INVALIDARG;
4391 /* Can only return a length for a property if it's a string. */
4392 if(uriProp > Uri_PROPERTY_STRING_LAST)
4393 return E_INVALIDARG;
4395 /* Don't have support for flags yet. */
4397 FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
4402 case Uri_PROPERTY_ABSOLUTE_URI:
4403 if(!This->display_absolute) {
4407 if(This->scheme_type != URL_SCHEME_UNKNOWN) {
4408 if(This->userinfo_start > -1 && This->userinfo_len == 0)
4409 /* Don't include the '@' in the length. */
4410 *pcchProperty = This->canon_len-1;
4411 else if(This->userinfo_start > -1 && This->userinfo_len == 1 &&
4412 This->userinfo_split == 0)
4413 /* Don't include the ":@" in the length. */
4414 *pcchProperty = This->canon_len-2;
4416 *pcchProperty = This->canon_len;
4418 *pcchProperty = This->canon_len;
4424 case Uri_PROPERTY_AUTHORITY:
4425 *pcchProperty = This->authority_len;
4426 hres = (This->authority_start > -1) ? S_OK : S_FALSE;
4428 case Uri_PROPERTY_DISPLAY_URI:
4429 if(This->scheme_type != URL_SCHEME_UNKNOWN && This->userinfo_start > -1)
4430 *pcchProperty = This->canon_len-This->userinfo_len-1;
4432 *pcchProperty = This->canon_len;
4436 case Uri_PROPERTY_DOMAIN:
4437 if(This->domain_offset > -1)
4438 *pcchProperty = This->host_len - This->domain_offset;
4442 hres = (This->domain_offset > -1) ? S_OK : S_FALSE;
4444 case Uri_PROPERTY_EXTENSION:
4445 if(This->extension_offset > -1) {
4446 *pcchProperty = This->path_len - This->extension_offset;
4454 case Uri_PROPERTY_FRAGMENT:
4455 *pcchProperty = This->fragment_len;
4456 hres = (This->fragment_start > -1) ? S_OK : S_FALSE;
4458 case Uri_PROPERTY_HOST:
4459 *pcchProperty = This->host_len;
4461 /* '[' and ']' aren't included in the length. */
4462 if(This->host_type == Uri_HOST_IPV6)
4465 hres = (This->host_start > -1) ? S_OK : S_FALSE;
4467 case Uri_PROPERTY_PASSWORD:
4468 *pcchProperty = (This->userinfo_split > -1) ? This->userinfo_len-This->userinfo_split-1 : 0;
4469 hres = (This->userinfo_split > -1) ? S_OK : S_FALSE;
4471 case Uri_PROPERTY_PATH:
4472 *pcchProperty = This->path_len;
4473 hres = (This->path_start > -1) ? S_OK : S_FALSE;
4475 case Uri_PROPERTY_PATH_AND_QUERY:
4476 *pcchProperty = This->path_len+This->query_len;
4477 hres = (This->path_start > -1 || This->query_start > -1) ? S_OK : S_FALSE;
4479 case Uri_PROPERTY_QUERY:
4480 *pcchProperty = This->query_len;
4481 hres = (This->query_start > -1) ? S_OK : S_FALSE;
4483 case Uri_PROPERTY_RAW_URI:
4484 *pcchProperty = SysStringLen(This->raw_uri);
4487 case Uri_PROPERTY_SCHEME_NAME:
4488 *pcchProperty = This->scheme_len;
4489 hres = (This->scheme_start > -1) ? S_OK : S_FALSE;
4491 case Uri_PROPERTY_USER_INFO:
4492 *pcchProperty = This->userinfo_len;
4493 hres = (This->userinfo_start > -1) ? S_OK : S_FALSE;
4495 case Uri_PROPERTY_USER_NAME:
4496 *pcchProperty = (This->userinfo_split > -1) ? This->userinfo_split : This->userinfo_len;
4497 if(This->userinfo_split == 0)
4500 hres = (This->userinfo_start > -1) ? S_OK : S_FALSE;
4503 FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
4510 static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
4512 Uri *This = URI_THIS(iface);
4515 TRACE("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
4518 return E_INVALIDARG;
4520 /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
4521 * From what I can tell, instead of checking which URLZONE the URI belongs to it
4522 * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies to the GetZone
4525 if(uriProp == Uri_PROPERTY_ZONE) {
4526 *pcchProperty = URLZONE_INVALID;
4530 if(uriProp < Uri_PROPERTY_DWORD_START) {
4532 return E_INVALIDARG;
4536 case Uri_PROPERTY_HOST_TYPE:
4537 *pcchProperty = This->host_type;
4540 case Uri_PROPERTY_PORT:
4541 if(!This->has_port) {
4545 *pcchProperty = This->port;
4550 case Uri_PROPERTY_SCHEME:
4551 *pcchProperty = This->scheme_type;
4555 FIXME("(%p)->(%d %p %x)\n", This, uriProp, pcchProperty, dwFlags);
4562 static HRESULT WINAPI Uri_HasProperty(IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty)
4564 Uri *This = URI_THIS(iface);
4565 TRACE("(%p)->(%d %p)\n", This, uriProp, pfHasProperty);
4568 return E_INVALIDARG;
4571 case Uri_PROPERTY_ABSOLUTE_URI:
4572 *pfHasProperty = This->display_absolute;
4574 case Uri_PROPERTY_AUTHORITY:
4575 *pfHasProperty = This->authority_start > -1;
4577 case Uri_PROPERTY_DISPLAY_URI:
4578 *pfHasProperty = TRUE;
4580 case Uri_PROPERTY_DOMAIN:
4581 *pfHasProperty = This->domain_offset > -1;
4583 case Uri_PROPERTY_EXTENSION:
4584 *pfHasProperty = This->extension_offset > -1;
4586 case Uri_PROPERTY_FRAGMENT:
4587 *pfHasProperty = This->fragment_start > -1;
4589 case Uri_PROPERTY_HOST:
4590 *pfHasProperty = This->host_start > -1;
4592 case Uri_PROPERTY_PASSWORD:
4593 *pfHasProperty = This->userinfo_split > -1;
4595 case Uri_PROPERTY_PATH:
4596 *pfHasProperty = This->path_start > -1;
4598 case Uri_PROPERTY_PATH_AND_QUERY:
4599 *pfHasProperty = (This->path_start > -1 || This->query_start > -1);
4601 case Uri_PROPERTY_QUERY:
4602 *pfHasProperty = This->query_start > -1;
4604 case Uri_PROPERTY_RAW_URI:
4605 *pfHasProperty = TRUE;
4607 case Uri_PROPERTY_SCHEME_NAME:
4608 *pfHasProperty = This->scheme_start > -1;
4610 case Uri_PROPERTY_USER_INFO:
4611 *pfHasProperty = This->userinfo_start > -1;
4613 case Uri_PROPERTY_USER_NAME:
4614 if(This->userinfo_split == 0)
4615 *pfHasProperty = FALSE;
4617 *pfHasProperty = This->userinfo_start > -1;
4619 case Uri_PROPERTY_HOST_TYPE:
4620 *pfHasProperty = TRUE;
4622 case Uri_PROPERTY_PORT:
4623 *pfHasProperty = This->has_port;
4625 case Uri_PROPERTY_SCHEME:
4626 *pfHasProperty = TRUE;
4628 case Uri_PROPERTY_ZONE:
4629 *pfHasProperty = FALSE;
4632 FIXME("(%p)->(%d %p): Unsupported property type.\n", This, uriProp, pfHasProperty);
4639 static HRESULT WINAPI Uri_GetAbsoluteUri(IUri *iface, BSTR *pstrAbsoluteUri)
4641 TRACE("(%p)->(%p)\n", iface, pstrAbsoluteUri);
4642 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_ABSOLUTE_URI, pstrAbsoluteUri, 0);
4645 static HRESULT WINAPI Uri_GetAuthority(IUri *iface, BSTR *pstrAuthority)
4647 TRACE("(%p)->(%p)\n", iface, pstrAuthority);
4648 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_AUTHORITY, pstrAuthority, 0);
4651 static HRESULT WINAPI Uri_GetDisplayUri(IUri *iface, BSTR *pstrDisplayUri)
4653 TRACE("(%p)->(%p)\n", iface, pstrDisplayUri);
4654 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_DISPLAY_URI, pstrDisplayUri, 0);
4657 static HRESULT WINAPI Uri_GetDomain(IUri *iface, BSTR *pstrDomain)
4659 TRACE("(%p)->(%p)\n", iface, pstrDomain);
4660 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_DOMAIN, pstrDomain, 0);
4663 static HRESULT WINAPI Uri_GetExtension(IUri *iface, BSTR *pstrExtension)
4665 TRACE("(%p)->(%p)\n", iface, pstrExtension);
4666 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_EXTENSION, pstrExtension, 0);
4669 static HRESULT WINAPI Uri_GetFragment(IUri *iface, BSTR *pstrFragment)
4671 TRACE("(%p)->(%p)\n", iface, pstrFragment);
4672 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_FRAGMENT, pstrFragment, 0);
4675 static HRESULT WINAPI Uri_GetHost(IUri *iface, BSTR *pstrHost)
4677 TRACE("(%p)->(%p)\n", iface, pstrHost);
4678 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_HOST, pstrHost, 0);
4681 static HRESULT WINAPI Uri_GetPassword(IUri *iface, BSTR *pstrPassword)
4683 TRACE("(%p)->(%p)\n", iface, pstrPassword);
4684 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_PASSWORD, pstrPassword, 0);
4687 static HRESULT WINAPI Uri_GetPath(IUri *iface, BSTR *pstrPath)
4689 TRACE("(%p)->(%p)\n", iface, pstrPath);
4690 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_PATH, pstrPath, 0);
4693 static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery)
4695 TRACE("(%p)->(%p)\n", iface, pstrPathAndQuery);
4696 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_PATH_AND_QUERY, pstrPathAndQuery, 0);
4699 static HRESULT WINAPI Uri_GetQuery(IUri *iface, BSTR *pstrQuery)
4701 TRACE("(%p)->(%p)\n", iface, pstrQuery);
4702 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_QUERY, pstrQuery, 0);
4705 static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri)
4707 TRACE("(%p)->(%p)\n", iface, pstrRawUri);
4708 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_RAW_URI, pstrRawUri, 0);
4711 static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName)
4713 TRACE("(%p)->(%p)\n", iface, pstrSchemeName);
4714 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_SCHEME_NAME, pstrSchemeName, 0);
4717 static HRESULT WINAPI Uri_GetUserInfo(IUri *iface, BSTR *pstrUserInfo)
4719 TRACE("(%p)->(%p)\n", iface, pstrUserInfo);
4720 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_USER_INFO, pstrUserInfo, 0);
4723 static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName)
4725 TRACE("(%p)->(%p)\n", iface, pstrUserName);
4726 return Uri_GetPropertyBSTR(iface, Uri_PROPERTY_USER_NAME, pstrUserName, 0);
4729 static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType)
4731 TRACE("(%p)->(%p)\n", iface, pdwHostType);
4732 return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_HOST_TYPE, pdwHostType, 0);
4735 static HRESULT WINAPI Uri_GetPort(IUri *iface, DWORD *pdwPort)
4737 TRACE("(%p)->(%p)\n", iface, pdwPort);
4738 return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_PORT, pdwPort, 0);
4741 static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme)
4743 Uri *This = URI_THIS(iface);
4744 TRACE("(%p)->(%p)\n", This, pdwScheme);
4745 return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_SCHEME, pdwScheme, 0);
4748 static HRESULT WINAPI Uri_GetZone(IUri *iface, DWORD *pdwZone)
4750 TRACE("(%p)->(%p)\n", iface, pdwZone);
4751 return Uri_GetPropertyDWORD(iface, Uri_PROPERTY_ZONE,pdwZone, 0);
4754 static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties)
4756 Uri *This = URI_THIS(iface);
4757 TRACE("(%p)->(%p)\n", This, pdwProperties);
4760 return E_INVALIDARG;
4762 /* All URIs have these. */
4763 *pdwProperties = Uri_HAS_DISPLAY_URI|Uri_HAS_RAW_URI|Uri_HAS_SCHEME|Uri_HAS_HOST_TYPE;
4765 if(This->display_absolute)
4766 *pdwProperties |= Uri_HAS_ABSOLUTE_URI;
4768 if(This->scheme_start > -1)
4769 *pdwProperties |= Uri_HAS_SCHEME_NAME;
4771 if(This->authority_start > -1) {
4772 *pdwProperties |= Uri_HAS_AUTHORITY;
4773 if(This->userinfo_start > -1) {
4774 *pdwProperties |= Uri_HAS_USER_INFO;
4775 if(This->userinfo_split != 0)
4776 *pdwProperties |= Uri_HAS_USER_NAME;
4778 if(This->userinfo_split > -1)
4779 *pdwProperties |= Uri_HAS_PASSWORD;
4780 if(This->host_start > -1)
4781 *pdwProperties |= Uri_HAS_HOST;
4782 if(This->domain_offset > -1)
4783 *pdwProperties |= Uri_HAS_DOMAIN;
4787 *pdwProperties |= Uri_HAS_PORT;
4788 if(This->path_start > -1)
4789 *pdwProperties |= Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY;
4790 if(This->query_start > -1)
4791 *pdwProperties |= Uri_HAS_QUERY|Uri_HAS_PATH_AND_QUERY;
4793 if(This->extension_offset > -1)
4794 *pdwProperties |= Uri_HAS_EXTENSION;
4796 if(This->fragment_start > -1)
4797 *pdwProperties |= Uri_HAS_FRAGMENT;
4802 static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual)
4804 Uri *This = URI_THIS(iface);
4807 TRACE("(%p)->(%p %p)\n", This, pUri, pfEqual);
4815 /* For some reason Windows returns S_OK here... */
4819 /* Try to convert it to a Uri (allows for a more simple comparison). */
4820 if((other = get_uri_obj(pUri)))
4821 *pfEqual = are_equal_simple(This, other);
4823 /* Do it the hard way. */
4824 FIXME("(%p)->(%p %p) No support for unknown IUri's yet.\n", iface, pUri, pfEqual);
4833 static const IUriVtbl UriVtbl = {
4837 Uri_GetPropertyBSTR,
4838 Uri_GetPropertyLength,
4839 Uri_GetPropertyDWORD,
4850 Uri_GetPathAndQuery,
4864 static Uri* create_uri_obj(void) {
4865 Uri *ret = heap_alloc_zero(sizeof(Uri));
4867 ret->lpIUriVtbl = &UriVtbl;
4874 /***********************************************************************
4875 * CreateUri (urlmon.@)
4877 * Creates a new IUri object using the URI represented by pwzURI. This function
4878 * parses and validates the components of pwzURI and then canonicalizes the
4879 * parsed components.
4882 * pwzURI [I] The URI to parse, validate, and canonicalize.
4883 * dwFlags [I] Flags which can affect how the parsing/canonicalization is performed.
4884 * dwReserved [I] Reserved (not used).
4885 * ppURI [O] The resulting IUri after parsing/canonicalization occurs.
4888 * Success: Returns S_OK. ppURI contains the pointer to the newly allocated IUri.
4889 * Failure: E_INVALIDARG if there's invalid flag combinations in dwFlags, or an
4890 * invalid parameters, or pwzURI doesn't represnt a valid URI.
4891 * E_OUTOFMEMORY if any memory allocation fails.
4895 * Uri_CREATE_CANONICALIZE, Uri_CREATE_DECODE_EXTRA_INFO, Uri_CREATE_CRACK_UNKNOWN_SCHEMES,
4896 * Uri_CREATE_PRE_PROCESS_HTML_URI, Uri_CREATE_NO_IE_SETTINGS.
4898 HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
4900 const DWORD supported_flags = Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME|
4901 Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_NO_CANONICALIZE|Uri_CREATE_CANONICALIZE|
4902 Uri_CREATE_DECODE_EXTRA_INFO|Uri_CREATE_NO_DECODE_EXTRA_INFO|Uri_CREATE_CRACK_UNKNOWN_SCHEMES|
4903 Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES|Uri_CREATE_PRE_PROCESS_HTML_URI|Uri_CREATE_NO_PRE_PROCESS_HTML_URI|
4904 Uri_CREATE_NO_IE_SETTINGS|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS|Uri_CREATE_FILE_USE_DOS_PATH;
4909 TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI), dwFlags, (DWORD)dwReserved, ppURI);
4912 return E_INVALIDARG;
4914 if(!pwzURI || !*pwzURI) {
4916 return E_INVALIDARG;
4919 /* Check for invalid flags. */
4920 if(has_invalid_flag_combination(dwFlags)) {
4922 return E_INVALIDARG;
4925 /* Currently unsupported. */
4926 if(dwFlags & ~supported_flags)
4927 FIXME("Ignoring unsupported flag(s) %x\n", dwFlags & ~supported_flags);
4929 ret = create_uri_obj();
4932 return E_OUTOFMEMORY;
4935 /* Explicitly set the default flags if it doesn't cause a flag conflict. */
4936 apply_default_flags(&dwFlags);
4938 /* Pre process the URI, unless told otherwise. */
4939 if(!(dwFlags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI))
4940 ret->raw_uri = pre_process_uri(pwzURI);
4942 ret->raw_uri = SysAllocString(pwzURI);
4946 return E_OUTOFMEMORY;
4949 memset(&data, 0, sizeof(parse_data));
4950 data.uri = ret->raw_uri;
4952 /* Validate and parse the URI into it's components. */
4953 if(!parse_uri(&data, dwFlags)) {
4954 /* Encountered an unsupported or invalid URI */
4955 IUri_Release(URI(ret));
4957 return E_INVALIDARG;
4960 /* Canonicalize the URI. */
4961 hr = canonicalize_uri(&data, ret, dwFlags);
4963 IUri_Release(URI(ret));
4968 ret->create_flags = dwFlags;
4974 /***********************************************************************
4975 * CreateUriWithFragment (urlmon.@)
4977 * Creates a new IUri object. This is almost the same as CreateUri, expect that
4978 * it allows you to explicitly specify a fragment (pwzFragment) for pwzURI.
4981 * pwzURI [I] The URI to parse and perform canonicalization on.
4982 * pwzFragment [I] The explict fragment string which should be added to pwzURI.
4983 * dwFlags [I] The flags which will be passed to CreateUri.
4984 * dwReserved [I] Reserved (not used).
4985 * ppURI [O] The resulting IUri after parsing/canonicalization.
4988 * Success: S_OK. ppURI contains the pointer to the newly allocated IUri.
4989 * Failure: E_INVALIDARG if pwzURI already contains a fragment and pwzFragment
4990 * isn't NULL. Will also return E_INVALIDARG for the same reasons as
4991 * CreateUri will. E_OUTOFMEMORY if any allocations fail.
4993 HRESULT WINAPI CreateUriWithFragment(LPCWSTR pwzURI, LPCWSTR pwzFragment, DWORD dwFlags,
4994 DWORD_PTR dwReserved, IUri **ppURI)
4997 TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI), debugstr_w(pwzFragment), dwFlags, (DWORD)dwReserved, ppURI);
5000 return E_INVALIDARG;
5004 return E_INVALIDARG;
5007 /* Check if a fragment should be appended to the URI string. */
5010 DWORD uri_len, frag_len;
5013 /* Check if the original URI already has a fragment component. */
5014 if(StrChrW(pwzURI, '#')) {
5016 return E_INVALIDARG;
5019 uri_len = lstrlenW(pwzURI);
5020 frag_len = lstrlenW(pwzFragment);
5022 /* If the fragment doesn't start with a '#', one will be added. */
5023 add_pound = *pwzFragment != '#';
5026 uriW = heap_alloc((uri_len+frag_len+2)*sizeof(WCHAR));
5028 uriW = heap_alloc((uri_len+frag_len+1)*sizeof(WCHAR));
5031 return E_OUTOFMEMORY;
5033 memcpy(uriW, pwzURI, uri_len*sizeof(WCHAR));
5035 uriW[uri_len++] = '#';
5036 memcpy(uriW+uri_len, pwzFragment, (frag_len+1)*sizeof(WCHAR));
5038 hres = CreateUri(uriW, dwFlags, 0, ppURI);
5042 /* A fragment string wasn't specified, so just forward the call. */
5043 hres = CreateUri(pwzURI, dwFlags, 0, ppURI);
5048 static HRESULT build_uri(const UriBuilder *builder, IUri **uri, DWORD create_flags,
5049 DWORD use_orig_flags, DWORD encoding_mask)
5058 if(encoding_mask && (!builder->uri || builder->modified_props)) {
5063 /* Decide what flags should be used when creating the Uri. */
5064 if((use_orig_flags & UriBuilder_USE_ORIGINAL_FLAGS) && builder->uri)
5065 create_flags = builder->uri->create_flags;
5067 if(has_invalid_flag_combination(create_flags)) {
5069 return E_INVALIDARG;
5072 /* Set the default flags if they don't cause a conflict. */
5073 apply_default_flags(&create_flags);
5076 /* Return the base IUri if no changes have been made and the create_flags match. */
5077 if(builder->uri && !builder->modified_props && builder->uri->create_flags == create_flags) {
5078 *uri = URI(builder->uri);
5083 hr = validate_components(builder, &data, create_flags);
5089 ret = create_uri_obj();
5092 return E_OUTOFMEMORY;
5095 hr = generate_uri(builder, &data, ret, create_flags);
5097 IUri_Release(URI(ret));
5106 #define URIBUILDER_THIS(iface) DEFINE_THIS(UriBuilder, IUriBuilder, iface)
5108 static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv)
5110 UriBuilder *This = URIBUILDER_THIS(iface);
5112 if(IsEqualGUID(&IID_IUnknown, riid)) {
5113 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
5114 *ppv = URIBUILDER(This);
5115 }else if(IsEqualGUID(&IID_IUriBuilder, riid)) {
5116 TRACE("(%p)->(IID_IUri %p)\n", This, ppv);
5117 *ppv = URIBUILDER(This);
5119 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
5121 return E_NOINTERFACE;
5124 IUnknown_AddRef((IUnknown*)*ppv);
5128 static ULONG WINAPI UriBuilder_AddRef(IUriBuilder *iface)
5130 UriBuilder *This = URIBUILDER_THIS(iface);
5131 LONG ref = InterlockedIncrement(&This->ref);
5133 TRACE("(%p) ref=%d\n", This, ref);
5138 static ULONG WINAPI UriBuilder_Release(IUriBuilder *iface)
5140 UriBuilder *This = URIBUILDER_THIS(iface);
5141 LONG ref = InterlockedDecrement(&This->ref);
5143 TRACE("(%p) ref=%d\n", This, ref);
5146 if(This->uri) IUri_Release(URI(This->uri));
5147 heap_free(This->fragment);
5148 heap_free(This->host);
5149 heap_free(This->password);
5150 heap_free(This->path);
5151 heap_free(This->query);
5152 heap_free(This->scheme);
5153 heap_free(This->username);
5160 static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface,
5161 DWORD dwAllowEncodingPropertyMask,
5162 DWORD_PTR dwReserved,
5165 UriBuilder *This = URIBUILDER_THIS(iface);
5167 TRACE("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5169 hr = build_uri(This, ppIUri, 0, UriBuilder_USE_ORIGINAL_FLAGS, dwAllowEncodingPropertyMask);
5171 FIXME("(%p)->(%d %d %p)\n", This, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5175 static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface,
5176 DWORD dwCreateFlags,
5177 DWORD dwAllowEncodingPropertyMask,
5178 DWORD_PTR dwReserved,
5181 UriBuilder *This = URIBUILDER_THIS(iface);
5183 TRACE("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5185 if(dwCreateFlags == -1)
5186 hr = build_uri(This, ppIUri, 0, UriBuilder_USE_ORIGINAL_FLAGS, dwAllowEncodingPropertyMask);
5188 hr = build_uri(This, ppIUri, dwCreateFlags, 0, dwAllowEncodingPropertyMask);
5191 FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5195 static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface,
5196 DWORD dwCreateFlags,
5197 DWORD dwUriBuilderFlags,
5198 DWORD dwAllowEncodingPropertyMask,
5199 DWORD_PTR dwReserved,
5202 UriBuilder *This = URIBUILDER_THIS(iface);
5204 TRACE("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags,
5205 dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5207 hr = build_uri(This, ppIUri, dwCreateFlags, dwUriBuilderFlags, dwAllowEncodingPropertyMask);
5209 FIXME("(%p)->(0x%08x 0x%08x %d %d %p)\n", This, dwCreateFlags, dwUriBuilderFlags,
5210 dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5214 static HRESULT WINAPI UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri)
5216 UriBuilder *This = URIBUILDER_THIS(iface);
5217 TRACE("(%p)->(%p)\n", This, ppIUri);
5223 IUri *uri = URI(This->uri);
5232 static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri)
5234 UriBuilder *This = URIBUILDER_THIS(iface);
5235 TRACE("(%p)->(%p)\n", This, pIUri);
5240 if((uri = get_uri_obj(pIUri))) {
5241 /* Only reset the builder if it's Uri isn't the same as
5242 * the Uri passed to the function.
5244 if(This->uri != uri) {
5245 reset_builder(This);
5249 This->port = uri->port;
5254 FIXME("(%p)->(%p) Unknown IUri types not supported yet.\n", This, pIUri);
5257 } else if(This->uri)
5258 /* Only reset the builder if it's Uri isn't NULL. */
5259 reset_builder(This);
5264 static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
5266 UriBuilder *This = URIBUILDER_THIS(iface);
5267 TRACE("(%p)->(%p %p)\n", This, pcchFragment, ppwzFragment);
5269 if(!This->uri || This->uri->fragment_start == -1 || This->modified_props & Uri_HAS_FRAGMENT)
5270 return get_builder_component(&This->fragment, &This->fragment_len, NULL, 0, ppwzFragment, pcchFragment);
5272 return get_builder_component(&This->fragment, &This->fragment_len, This->uri->canon_uri+This->uri->fragment_start,
5273 This->uri->fragment_len, ppwzFragment, pcchFragment);
5276 static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
5278 UriBuilder *This = URIBUILDER_THIS(iface);
5279 TRACE("(%p)->(%p %p)\n", This, pcchHost, ppwzHost);
5281 if(!This->uri || This->uri->host_start == -1 || This->modified_props & Uri_HAS_HOST)
5282 return get_builder_component(&This->host, &This->host_len, NULL, 0, ppwzHost, pcchHost);
5284 if(This->uri->host_type == Uri_HOST_IPV6)
5285 /* Don't include the '[' and ']' around the address. */
5286 return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start+1,
5287 This->uri->host_len-2, ppwzHost, pcchHost);
5289 return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start,
5290 This->uri->host_len, ppwzHost, pcchHost);
5294 static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
5296 UriBuilder *This = URIBUILDER_THIS(iface);
5297 TRACE("(%p)->(%p %p)\n", This, pcchPassword, ppwzPassword);
5299 if(!This->uri || This->uri->userinfo_split == -1 || This->modified_props & Uri_HAS_PASSWORD)
5300 return get_builder_component(&This->password, &This->password_len, NULL, 0, ppwzPassword, pcchPassword);
5302 const WCHAR *start = This->uri->canon_uri+This->uri->userinfo_start+This->uri->userinfo_split+1;
5303 DWORD len = This->uri->userinfo_len-This->uri->userinfo_split-1;
5304 return get_builder_component(&This->password, &This->password_len, start, len, ppwzPassword, pcchPassword);
5308 static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
5310 UriBuilder *This = URIBUILDER_THIS(iface);
5311 TRACE("(%p)->(%p %p)\n", This, pcchPath, ppwzPath);
5313 if(!This->uri || This->uri->path_start == -1 || This->modified_props & Uri_HAS_PATH)
5314 return get_builder_component(&This->path, &This->path_len, NULL, 0, ppwzPath, pcchPath);
5316 return get_builder_component(&This->path, &This->path_len, This->uri->canon_uri+This->uri->path_start,
5317 This->uri->path_len, ppwzPath, pcchPath);
5320 static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
5322 UriBuilder *This = URIBUILDER_THIS(iface);
5323 TRACE("(%p)->(%p %p)\n", This, pfHasPort, pdwPort);
5336 *pfHasPort = This->has_port;
5337 *pdwPort = This->port;
5341 static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
5343 UriBuilder *This = URIBUILDER_THIS(iface);
5344 TRACE("(%p)->(%p %p)\n", This, pcchQuery, ppwzQuery);
5346 if(!This->uri || This->uri->query_start == -1 || This->modified_props & Uri_HAS_QUERY)
5347 return get_builder_component(&This->query, &This->query_len, NULL, 0, ppwzQuery, pcchQuery);
5349 return get_builder_component(&This->query, &This->query_len, This->uri->canon_uri+This->uri->query_start,
5350 This->uri->query_len, ppwzQuery, pcchQuery);
5353 static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
5355 UriBuilder *This = URIBUILDER_THIS(iface);
5356 TRACE("(%p)->(%p %p)\n", This, pcchSchemeName, ppwzSchemeName);
5358 if(!This->uri || This->uri->scheme_start == -1 || This->modified_props & Uri_HAS_SCHEME_NAME)
5359 return get_builder_component(&This->scheme, &This->scheme_len, NULL, 0, ppwzSchemeName, pcchSchemeName);
5361 return get_builder_component(&This->scheme, &This->scheme_len, This->uri->canon_uri+This->uri->scheme_start,
5362 This->uri->scheme_len, ppwzSchemeName, pcchSchemeName);
5365 static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
5367 UriBuilder *This = URIBUILDER_THIS(iface);
5368 TRACE("(%p)->(%p %p)\n", This, pcchUserName, ppwzUserName);
5370 if(!This->uri || This->uri->userinfo_start == -1 || This->uri->userinfo_split == 0 ||
5371 This->modified_props & Uri_HAS_USER_NAME)
5372 return get_builder_component(&This->username, &This->username_len, NULL, 0, ppwzUserName, pcchUserName);
5374 const WCHAR *start = This->uri->canon_uri+This->uri->userinfo_start;
5376 /* Check if there's a password in the userinfo section. */
5377 if(This->uri->userinfo_split > -1)
5378 /* Don't include the password. */
5379 return get_builder_component(&This->username, &This->username_len, start,
5380 This->uri->userinfo_split, ppwzUserName, pcchUserName);
5382 return get_builder_component(&This->username, &This->username_len, start,
5383 This->uri->userinfo_len, ppwzUserName, pcchUserName);
5387 static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue)
5389 UriBuilder *This = URIBUILDER_THIS(iface);
5390 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5391 return set_builder_component(&This->fragment, &This->fragment_len, pwzNewValue, '#',
5392 &This->modified_props, Uri_HAS_FRAGMENT);
5395 static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue)
5397 UriBuilder *This = URIBUILDER_THIS(iface);
5398 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5400 /* Host name can't be set to NULL. */
5402 return E_INVALIDARG;
5404 return set_builder_component(&This->host, &This->host_len, pwzNewValue, 0,
5405 &This->modified_props, Uri_HAS_HOST);
5408 static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue)
5410 UriBuilder *This = URIBUILDER_THIS(iface);
5411 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5412 return set_builder_component(&This->password, &This->password_len, pwzNewValue, 0,
5413 &This->modified_props, Uri_HAS_PASSWORD);
5416 static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue)
5418 UriBuilder *This = URIBUILDER_THIS(iface);
5419 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5420 return set_builder_component(&This->path, &This->path_len, pwzNewValue, 0,
5421 &This->modified_props, Uri_HAS_PATH);
5424 static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
5426 UriBuilder *This = URIBUILDER_THIS(iface);
5427 TRACE("(%p)->(%d %d)\n", This, fHasPort, dwNewValue);
5429 This->has_port = fHasPort;
5430 This->port = dwNewValue;
5431 This->modified_props |= Uri_HAS_PORT;
5435 static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue)
5437 UriBuilder *This = URIBUILDER_THIS(iface);
5438 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5439 return set_builder_component(&This->query, &This->query_len, pwzNewValue, '?',
5440 &This->modified_props, Uri_HAS_QUERY);
5443 static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue)
5445 UriBuilder *This = URIBUILDER_THIS(iface);
5446 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5448 /* Only set the scheme name if it's not NULL or empty. */
5449 if(!pwzNewValue || !*pwzNewValue)
5450 return E_INVALIDARG;
5452 return set_builder_component(&This->scheme, &This->scheme_len, pwzNewValue, 0,
5453 &This->modified_props, Uri_HAS_SCHEME_NAME);
5456 static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue)
5458 UriBuilder *This = URIBUILDER_THIS(iface);
5459 TRACE("(%p)->(%s)\n", This, debugstr_w(pwzNewValue));
5460 return set_builder_component(&This->username, &This->username_len, pwzNewValue, 0,
5461 &This->modified_props, Uri_HAS_USER_NAME);
5464 static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask)
5466 const DWORD accepted_flags = Uri_HAS_AUTHORITY|Uri_HAS_DOMAIN|Uri_HAS_EXTENSION|Uri_HAS_FRAGMENT|Uri_HAS_HOST|
5467 Uri_HAS_PASSWORD|Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY|Uri_HAS_QUERY|
5468 Uri_HAS_USER_INFO|Uri_HAS_USER_NAME;
5470 UriBuilder *This = URIBUILDER_THIS(iface);
5471 TRACE("(%p)->(0x%08x)\n", This, dwPropertyMask);
5473 if(dwPropertyMask & ~accepted_flags)
5474 return E_INVALIDARG;
5476 if(dwPropertyMask & Uri_HAS_FRAGMENT)
5477 UriBuilder_SetFragment(iface, NULL);
5479 /* Even though you can't set the host name to NULL or an
5480 * empty string, you can still remove it... for some reason.
5482 if(dwPropertyMask & Uri_HAS_HOST)
5483 set_builder_component(&This->host, &This->host_len, NULL, 0,
5484 &This->modified_props, Uri_HAS_HOST);
5486 if(dwPropertyMask & Uri_HAS_PASSWORD)
5487 UriBuilder_SetPassword(iface, NULL);
5489 if(dwPropertyMask & Uri_HAS_PATH)
5490 UriBuilder_SetPath(iface, NULL);
5492 if(dwPropertyMask & Uri_HAS_PORT)
5493 UriBuilder_SetPort(iface, FALSE, 0);
5495 if(dwPropertyMask & Uri_HAS_QUERY)
5496 UriBuilder_SetQuery(iface, NULL);
5498 if(dwPropertyMask & Uri_HAS_USER_NAME)
5499 UriBuilder_SetUserName(iface, NULL);
5504 static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified)
5506 UriBuilder *This = URIBUILDER_THIS(iface);
5507 TRACE("(%p)->(%p)\n", This, pfModified);
5512 *pfModified = This->modified_props > 0;
5516 #undef URIBUILDER_THIS
5518 static const IUriBuilderVtbl UriBuilderVtbl = {
5519 UriBuilder_QueryInterface,
5522 UriBuilder_CreateUriSimple,
5523 UriBuilder_CreateUri,
5524 UriBuilder_CreateUriWithFlags,
5527 UriBuilder_GetFragment,
5529 UriBuilder_GetPassword,
5532 UriBuilder_GetQuery,
5533 UriBuilder_GetSchemeName,
5534 UriBuilder_GetUserName,
5535 UriBuilder_SetFragment,
5537 UriBuilder_SetPassword,
5540 UriBuilder_SetQuery,
5541 UriBuilder_SetSchemeName,
5542 UriBuilder_SetUserName,
5543 UriBuilder_RemoveProperties,
5544 UriBuilder_HasBeenModified,
5547 /***********************************************************************
5548 * CreateIUriBuilder (urlmon.@)
5550 HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
5554 TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder);
5559 ret = heap_alloc_zero(sizeof(UriBuilder));
5561 return E_OUTOFMEMORY;
5563 ret->lpIUriBuilderVtbl = &UriBuilderVtbl;
5569 if((uri = get_uri_obj(pIUri))) {
5574 /* Windows doesn't set 'has_port' to TRUE in this case. */
5575 ret->port = uri->port;
5579 *ppIUriBuilder = NULL;
5580 FIXME("(%p %x %x %p): Unknown IUri types not supported yet.\n", pIUri, dwFlags,
5581 (DWORD)dwReserved, ppIUriBuilder);
5586 *ppIUriBuilder = URIBUILDER(ret);