#include <limits.h>#include <wchar.h>#include "urlmon_main.h"#include "wine/debug.h"#include "shlwapi.h"#include "strsafe.h"#include "winternl.h"#include "inaddr.h"#include "in6addr.h"#include "ip2string.h"
Include dependency graph for uri.c:
Go to the source code of this file.
Classes | |
| struct | Uri |
| struct | UriBuilder |
| struct | parse_data |
| struct | persist_uri |
| struct | inproc_marshal_uri |
Macros | |
| #define | NO_SHLWAPI_REG |
| #define | URI_DISPLAY_NO_ABSOLUTE_URI 0x1 |
| #define | URI_DISPLAY_NO_DEFAULT_PORT_AUTH 0x2 |
| #define | ALLOW_NULL_TERM_SCHEME 0x01 |
| #define | ALLOW_NULL_TERM_USER_NAME 0x02 |
| #define | ALLOW_NULL_TERM_PASSWORD 0x04 |
| #define | ALLOW_BRACKETLESS_IP_LITERAL 0x08 |
| #define | SKIP_IP_FUTURE_CHECK 0x10 |
| #define | IGNORE_PORT_DELIMITER 0x20 |
| #define | RAW_URI_FORCE_PORT_DISP 0x1 |
| #define | RAW_URI_CONVERT_TO_DOS_PATH 0x2 |
| #define | COMBINE_URI_FORCE_FLAG_USE 0x1 |
Variables | |
| static const IID | IID_IUriObj = {0x4b364760,0x9f51,0x11df,{0x98,0x1c,0x08,0x00,0x20,0x0c,0x9a,0x66}} |
| static const CHAR | hexDigits [] = "0123456789ABCDEF" |
| struct { | |
| URL_SCHEME scheme | |
| WCHAR scheme_name [16] | |
| } | recognized_schemes [] |
| struct { | |
| URL_SCHEME scheme | |
| USHORT port | |
| } | default_ports [] |
| struct { | |
| WCHAR tld_name [4] | |
| } | recognized_tlds [] |
| static const IUriVtbl | UriVtbl |
| static const IUriBuilderFactoryVtbl | UriBuilderFactoryVtbl |
| static const IPersistStreamVtbl | PersistStreamVtbl |
| static const IMarshalVtbl | MarshalVtbl |
| static const IUriBuilderVtbl | UriBuilderVtbl |
Macro Definition Documentation
◆ ALLOW_BRACKETLESS_IP_LITERAL
◆ ALLOW_NULL_TERM_PASSWORD
◆ ALLOW_NULL_TERM_SCHEME
◆ ALLOW_NULL_TERM_USER_NAME
◆ COMBINE_URI_FORCE_FLAG_USE
◆ IGNORE_PORT_DELIMITER
◆ NO_SHLWAPI_REG
◆ RAW_URI_CONVERT_TO_DOS_PATH
◆ RAW_URI_FORCE_PORT_DISP
◆ SKIP_IP_FUTURE_CHECK
◆ URI_DISPLAY_NO_ABSOLUTE_URI
◆ URI_DISPLAY_NO_DEFAULT_PORT_AUTH
Function Documentation
◆ apply_default_flags()
Definition at line 380 of file uri.c.
380 {
382 *flags |= Uri_CREATE_CANONICALIZE;
384 *flags |= Uri_CREATE_DECODE_EXTRA_INFO;
386 *flags |= Uri_CREATE_CRACK_UNKNOWN_SCHEMES;
388 *flags |= Uri_CREATE_PRE_PROCESS_HTML_URI;
390 *flags |= Uri_CREATE_NO_IE_SETTINGS;
391}
Referenced by build_uri(), combine_uri(), and CreateUri().
◆ build_uri()
|
static |
Definition at line 5532 of file uri.c.
5534{
5538
5541
5545 }
5546
5547 /* Decide what flags should be used when creating the Uri. */
5550 else {
5554 }
5555
5556 /* Set the default flags if they don't cause a conflict. */
5558 }
5559
5560 /* Return the base IUri if no changes have been made and the create_flags match. */
5563 IUri_AddRef(*uri);
5565 }
5566
5571 }
5572
5577 }
5578
5581 IUri_Release(&ret->IUri_iface);
5584 }
5585
5588}
static BOOL has_invalid_flag_combination(DWORD flags)
Definition: uri.c:369
static HRESULT generate_uri(const UriBuilder *builder, const parse_data *data, Uri *uri, DWORD flags)
Definition: uri.c:3789
static HRESULT validate_components(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3423
Definition: metahost.idl:58
Definition: uri.c:135
Referenced by UriBuilder_CreateUri(), UriBuilder_CreateUriSimple(), and UriBuilder_CreateUriWithFlags().
◆ canonicalize_authority()
|
static |
Definition at line 2399 of file uri.c.
2399 {
2401 uri->authority_len = 0;
2402
2405
2408
2411
2414 else
2415 uri->authority_start = -1;
2416
2418}
static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:1937
static BOOL canonicalize_host(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2272
static BOOL canonicalize_port(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2327
Referenced by canonicalize_hierpart().
◆ canonicalize_fragment()
|
static |
Definition at line 2843 of file uri.c.
2843 {
2846
2848 uri->fragment_start = -1;
2849 uri->fragment_len = 0;
2851 }
2852
2854
2861 if(!computeOnly)
2863 ++uri->canon_len;
2864
2865 ptr += 2;
2866 continue;
2867 }
2868 }
2871 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
2872 if(!computeOnly)
2874 uri->canon_len += 3;
2875 continue;
2876 }
2877 }
2878
2879 if(!computeOnly)
2881 ++uri->canon_len;
2882 }
2883
2885
2886 if(!computeOnly)
2889 uri->fragment_len);
2891}
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_hierpart()
|
static |
Definition at line 2702 of file uri.c.
2702 {
2704 /* "//" is only added for non-wildcard scheme types.
2705 *
2706 * A "//" is only added to a relative URI if it has a
2707 * host or port component (this only happens if a IUriBuilder
2708 * is generating an IUri).
2709 */
2714
2715 if(!computeOnly) {
2717
2720 }
2721 uri->canon_len += 2;
2722 }
2723
2726
2730 } else {
2731 if(!computeOnly)
2733 uri->path_len = canonicalize_path_hierarchical(data->path, data->path_len, data->scheme_type, data->host_len != 0,
2737 uri->path_start = -1;
2738 }
2739 } else {
2740 /* Opaque URI's don't have an authority. */
2742 uri->userinfo_len = 0;
2743 uri->host_start = -1;
2744 uri->host_len = 0;
2745 uri->host_type = Uri_HOST_UNKNOWN;
2747 uri->authority_start = -1;
2748 uri->authority_len = 0;
2749 uri->domain_offset = -1;
2750 uri->port_offset = -1;
2751
2754
2755 /* Absolute URIs aren't displayed for known scheme types
2756 * which should be hierarchical URIs.
2757 */
2759
2760 /* Windows also sets the port for these (if they have one). */
2765 break;
2766 }
2767 }
2768 }
2769
2772 }
2773
2775 /* Finding file extensions happens for both types of URIs. */
2777 else
2778 uri->extension_offset = -1;
2779
2781}
static BOOL canonicalize_authority(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2399
static DWORD canonicalize_path_hierarchical(const WCHAR *path, DWORD path_len, URL_SCHEME scheme_type, BOOL has_host, DWORD flags, BOOL is_implicit_scheme, WCHAR *ret_path)
Definition: uri.c:2449
static const struct @613 default_ports[]
static BOOL canonicalize_path_opaque(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2594
static INT find_file_extension(const WCHAR *path, DWORD path_len)
Definition: uri.c:651
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_host()
|
static |
Definition at line 2272 of file uri.c.
2272 {
2273 uri->host_start = -1;
2274 uri->host_len = 0;
2275 uri->domain_offset = -1;
2276
2279 case Uri_HOST_DNS:
2280 uri->host_type = Uri_HOST_DNS;
2283
2284 break;
2285 case Uri_HOST_IPV4:
2286 uri->host_type = Uri_HOST_IPV4;
2289
2290 break;
2291 case Uri_HOST_IPV6:
2294
2295 uri->host_type = Uri_HOST_IPV6;
2296 break;
2297
2298 case Uri_HOST_IDN:
2299 uri->host_type = Uri_HOST_IDN;
2302
2303 break;
2304 case Uri_HOST_UNKNOWN:
2307
2308 /* Nothing happens to unknown host types. */
2309 if(!computeOnly)
2313 }
2314
2315 uri->host_type = Uri_HOST_UNKNOWN;
2316 break;
2317 default:
2321 }
2322 }
2323
2325}
static BOOL canonicalize_ipv4address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2129
static BOOL canonicalize_reg_name(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:1984
static BOOL canonicalize_ipv6address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2238
Referenced by canonicalize_authority().
◆ canonicalize_implicit_ipv4address()
|
static |
Definition at line 2080 of file uri.c.
2080 {
2082
2084 /* For unknown scheme types Windows doesn't convert
2085 * the value into an IP address, but it still considers
2086 * it an IPv4 address.
2087 */
2089 if(!computeOnly)
2092 } else {
2093 if(!computeOnly)
2095 else
2097 }
2098
2100 uri->host_type = Uri_HOST_IPV4;
2101
2102 if(!computeOnly)
2106 uri->host_len);
2107
2109}
Referenced by canonicalize_ipv4address().
◆ canonicalize_ipv4address()
|
static |
Definition at line 2129 of file uri.c.
2129 {
2132 else {
2134
2135 /* Windows only normalizes for known scheme types. */
2137 /* parse_data contains a partial or full IPv4 address, so normalize it. */
2140
2143 /* Can ignore leading zeros if:
2144 * 1) It isn't the last digit of the octet.
2145 * 2) i+1 != data->host_len
2146 * 3) i+1 != '.'
2147 */
2148 if(octetDigitCount == 2 ||
2151 if(!computeOnly)
2153 ++uri->canon_len;
2155 }
2157 if(!computeOnly)
2159 ++uri->canon_len;
2160
2161 octetDigitCount = 0;
2162 octetHasDigit = FALSE;
2163 ++octetCount;
2164 } else {
2165 if(!computeOnly)
2167 ++uri->canon_len;
2168
2169 ++octetDigitCount;
2170 octetHasDigit = TRUE;
2171 }
2172 }
2173
2174 /* Make sure the canonicalized IP address has 4 dec-octets.
2175 * If doesn't add "0" ones until there is 4;
2176 */
2177 for( ; octetCount < 3; ++octetCount) {
2178 if(!computeOnly) {
2181 }
2182
2183 uri->canon_len += 2;
2184 }
2185 } else {
2186 /* Windows doesn't normalize addresses in unknown schemes. */
2187 if(!computeOnly)
2190 }
2191
2193 if(!computeOnly)
2197 uri->host_len);
2198 }
2199
2201}
static BOOL canonicalize_implicit_ipv4address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2080
Referenced by canonicalize_host().
◆ canonicalize_ipv6address()
|
static |
Definition at line 2238 of file uri.c.
2239 {
2241
2243 if(!computeOnly)
2246 } else {
2249
2250 if(computeOnly) {
2253 } else {
2258 }
2259 }
2260
2262
2263 if(!computeOnly)
2266 uri->host_len);
2267
2269}
NTSYSAPI NTSTATUS NTAPI RtlIpv6AddressToStringExW(_In_ const struct in6_addr *Address, _In_ ULONG ScopeId, _In_ USHORT Port, _Out_writes_to_(*AddressStringLength, *AddressStringLength) PWCHAR AddressString, _Inout_ PULONG AddressStringLength)
Definition: network.c:649
Referenced by canonicalize_host().
◆ canonicalize_password()
|
static |
Definition at line 1871 of file uri.c.
1871 {
1873
1875 uri->userinfo_split = -1;
1877 }
1878
1880 /* Has a password, but, doesn't have a username. */
1882
1884
1885 /* Add the ':' to the userinfo component. */
1886 if(!computeOnly)
1888 ++uri->canon_len;
1889
1892 /* Only decode % encoded values for known scheme types. */
1894 /* See if the value really needs decoding. */
1897 if(!computeOnly)
1899
1900 ++uri->canon_len;
1901
1902 /* Move pass the hex characters. */
1903 ptr += 2;
1904 continue;
1905 }
1906 }
1908 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
1909 * is NOT set.
1910 */
1912 if(!computeOnly)
1914
1915 uri->canon_len += 3;
1916 continue;
1917 }
1918 }
1919
1920 if(!computeOnly)
1921 /* Nothing special, so just copy the character over. */
1923 ++uri->canon_len;
1924 }
1925
1927}
Referenced by canonicalize_userinfo().
◆ canonicalize_path_hierarchical()
|
static |
Definition at line 2449 of file uri.c.
2450 {
2457
2459 return 0;
2460
2462
2463 if(is_file && !has_host) {
2464 /* Check if a '/' needs to be appended for the file scheme. */
2466 if(ret_path)
2468 len++;
2469 escape_pct = TRUE;
2472 /* Copy the extra '/' over. */
2473 if(ret_path)
2475 len++;
2476 }
2477 ++ptr;
2478 }
2479
2481 if(ret_path) {
2483 /* If there's a '|' after the drive letter, convert it to a ':'. */
2485 }
2486 ptr += 2;
2487 len += 2;
2488 }
2489 }
2490
2492 /* Prepend a '/' to the path if it doesn't have one. */
2493 if(ret_path)
2495 len++;
2496 }
2497
2500
2504
2505 /* Check if the % represents a valid encoded char, or if it needs encoding. */
2506 BOOL force_encode = !check_pct_encoded(&tmp) && is_file && !(flags&Uri_CREATE_FILE_USE_DOS_PATH);
2508
2509 if(force_encode || escape_pct) {
2510 /* Escape the percent sign in the file URI. */
2511 if(ret_path)
2513 len += 3;
2514 do_default_action = FALSE;
2518 if(ret_path)
2520 len++;
2521
2522 ptr += 2;
2523 continue;
2524 }
2526 /* Convert the '/' back to a '\\'. */
2527 if(ret_path)
2529 len++;
2530 do_default_action = FALSE;
2533 /* Convert '\\' into a '/'. */
2534 if(ret_path)
2536 len++;
2537 do_default_action = FALSE;
2538 }
2539 } else if(known_scheme && !is_res && is_ascii(*ptr) && !is_unreserved(*ptr) && !is_reserved(*ptr) &&
2540 (!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) || is_file)) {
2542 /* Escape the forbidden character. */
2543 if(ret_path)
2545 len += 3;
2546 do_default_action = FALSE;
2547 }
2548 }
2549
2550 if(do_default_action) {
2551 if(ret_path)
2553 len++;
2554 }
2555 }
2556
2557 /* Removing the dot segments only happens when it's not in
2558 * computeOnly mode and it's not a wildcard scheme. File schemes
2559 * with USE_DOS_PATH set don't get dot segments removed.
2560 */
2562 scheme_type != URL_SCHEME_WILDCARD) {
2564 /* Remove the dot segments (if any) and reset everything to the new
2565 * correct length.
2566 */
2568 }
2569 }
2570
2571 if(ret_path)
2574}
static DWORD remove_dot_segments(WCHAR *path, DWORD path_len)
Definition: uri.c:595
Definition: wbemprox_private.h:188
Referenced by canonicalize_hierpart(), and compare_file_paths().
◆ canonicalize_path_opaque()
|
static |
Definition at line 2594 of file uri.c.
2594 {
2599
2601 uri->path_start = -1;
2602 uri->path_len = 0;
2604 }
2605
2607
2608 if(is_mk){
2609 /* hijack this flag for SCHEME_MK to tell the function when to start
2610 * converting slashes */
2611 flags |= Uri_CREATE_FILE_USE_DOS_PATH;
2612 }
2613
2614 /* For javascript: URIs, simply copy path part without any canonicalization */
2616 if(!computeOnly)
2621 }
2622
2623 /* Windows doesn't allow a "//" to appear after the scheme
2624 * of a URI, if it's an opaque URI.
2625 */
2627 /* So it inserts a "/." before the "//" if it exists. */
2628 if(!computeOnly) {
2631 }
2632
2633 uri->canon_len += 2;
2634 }
2635
2638
2641
2643 if(!computeOnly)
2645 ++uri->canon_len;
2646
2647 ptr += 2;
2648 continue;
2649 }
2651 if(!computeOnly)
2653 ++uri->canon_len;
2654 do_default_action = FALSE;
2657 /* Convert to a '/'. */
2658 if(!computeOnly)
2660 ++uri->canon_len;
2661 do_default_action = FALSE;
2662 }
2663 } else if(is_mk && *ptr == ':' && ptr + 1 < data->path + data->path_len && *(ptr + 1) == ':') {
2664 flags &= ~Uri_CREATE_FILE_USE_DOS_PATH;
2666 !(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
2668 if(!computeOnly)
2670 uri->canon_len += 3;
2671 do_default_action = FALSE;
2672 }
2673 }
2674
2675 if(do_default_action) {
2676 if(!computeOnly)
2678 ++uri->canon_len;
2679 }
2680 }
2681
2686 }
2687
2689
2690 if(!computeOnly)
2691 TRACE("(%p %p %lx %d): Canonicalized opaque URI path %s len=%ld\n", data, uri, flags, computeOnly,
2694}
Referenced by canonicalize_hierpart().
◆ canonicalize_port()
|
static |
Definition at line 2327 of file uri.c.
2327 {
2329 USHORT default_port = 0;
2331
2332 uri->port_offset = -1;
2333
2334 /* Check if the scheme has a default port. */
2337 has_default_port = TRUE;
2339 break;
2340 }
2341 }
2342
2344
2345 /* Possible cases:
2346 * 1) Has a port which is the default port.
2347 * 2) Has a port (not the default).
2348 * 3) Doesn't have a port, but, scheme has a default port.
2349 * 4) No port.
2350 */
2352 /* If it's the default port and this flag isn't set, don't do anything. */
2355 if(!computeOnly)
2357 ++uri->canon_len;
2358
2360 /* Copy the original port over. */
2361 if(!computeOnly)
2364 } else {
2365 if(!computeOnly)
2367 else
2369 }
2370 }
2371
2372 uri->port = default_port;
2375 if(!computeOnly)
2377 ++uri->canon_len;
2378
2380 /* Copy the original over without changes. */
2381 if(!computeOnly)
2384 } else {
2385 if(!computeOnly)
2387 else
2389 }
2390
2392 } else if(has_default_port)
2393 uri->port = default_port;
2394
2396}
Referenced by canonicalize_authority().
◆ canonicalize_query()
|
static |
Definition at line 2793 of file uri.c.
2793 {
2796
2798 uri->query_start = -1;
2799 uri->query_len = 0;
2801 }
2802
2804
2811 if(!computeOnly)
2813 ++uri->canon_len;
2814
2815 ptr += 2;
2816 continue;
2817 }
2818 }
2821 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
2822 if(!computeOnly)
2824 uri->canon_len += 3;
2825 continue;
2826 }
2827 }
2828
2829 if(!computeOnly)
2831 ++uri->canon_len;
2832 }
2833
2835
2836 if(!computeOnly)
2839 uri->query_len);
2841}
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_reg_name()
|
static |
Definition at line 1984 of file uri.c.
1985 {
1988
1992 uri->host_start = -1;
1993 uri->host_len = 0;
1994 uri->host_type = Uri_HOST_UNKNOWN;
1996 }
1997 }
1998
2000 if(!computeOnly) {
2003 }
2004 uri->canon_len += 2;
2006 }
2007
2009
2014 /* If NO_CANONICALIZE is not set, then windows lower cases the
2015 * decoded value.
2016 */
2018 if(!computeOnly)
2020 } else {
2021 if(!computeOnly)
2023 }
2024 ++uri->canon_len;
2025
2026 /* Skip past the % encoded character. */
2027 ptr += 2;
2028 continue;
2029 } else {
2030 /* Just copy the % over. */
2031 if(!computeOnly)
2033 ++uri->canon_len;
2034 }
2036 /* Only unknown scheme types could have made it here with a '\\' in the host name. */
2037 if(!computeOnly)
2039 ++uri->canon_len;
2042 if(!computeOnly) {
2044
2045 /* The percent encoded value gets lower cased also. */
2049 }
2050 }
2051
2052 uri->canon_len += 3;
2053 } else {
2054 if(!computeOnly) {
2057 else
2059 }
2060
2061 ++uri->canon_len;
2062 }
2063 }
2064
2066
2067 if(!computeOnly)
2070 uri->host_len);
2071
2072 if(!computeOnly)
2074 &(uri->domain_offset));
2075
2077}
void find_domain_name(const WCHAR *host, DWORD host_len, INT *domain_start)
Definition: uri.c:477
Definition: txthost.c:37
Referenced by canonicalize_host().
◆ canonicalize_scheme()
|
static |
Definition at line 2894 of file uri.c.
2894 {
2895 uri->scheme_start = -1;
2896 uri->scheme_len = 0;
2897
2899 /* The only type of URI that doesn't have to have a scheme is a relative
2900 * URI.
2901 */
2906 }
2907 } else {
2908 if(!computeOnly) {
2911
2913 /* Scheme name must be lower case after canonicalization. */
2915 }
2916
2919
2922 }
2923
2924 /* This happens in both computation modes. */
2927 }
2929}
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_uri()
|
static |
Definition at line 2978 of file uri.c.
2978 {
2980
2983
2984 TRACE("(%p %p %lx): beginning to canonicalize URI %s.\n", data, uri, flags, debugstr_w(data->uri));
2985
2986 /* First try to compute the length of the URI. */
2992 }
2993
2997
3002 }
3004
3008 }
3009
3014 }
3015
3020 }
3021
3022 /* There's a possibility we didn't use all the space we allocated
3023 * earlier.
3024 */
3026 /* This happens if the URI is hierarchical and dot
3027 * segments were removed from its path.
3028 */
3030 if(!tmp)
3032
3033 uri->canon_uri = tmp;
3035 }
3036
3038 TRACE("(%p %p %lx): finished canonicalizing the URI. uri=%s\n", data, uri, flags, debugstr_w(uri->canon_uri));
3039
3041}
static int compute_canonicalized_length(const parse_data *data, DWORD flags)
Definition: uri.c:2937
static BOOL canonicalize_fragment(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2843
static BOOL canonicalize_scheme(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2894
static BOOL canonicalize_query(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2793
static BOOL canonicalize_hierpart(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2702
Referenced by combine_uri(), CreateUri(), generate_uri(), Marshal_UnmarshalInterface(), and PersistStream_Load().
◆ canonicalize_userinfo()
|
static |
Definition at line 1937 of file uri.c.
1937 {
1939 uri->userinfo_len = 0;
1940
1942 /* URI doesn't have userinfo, so nothing to do here. */
1944
1947
1950
1952 if(!computeOnly)
1953 TRACE("(%p %p %lx %d): Canonicalized userinfo, userinfo_start=%d, userinfo=%s, userinfo_split=%d userinfo_len=%ld.\n",
1954 data, uri, flags, computeOnly, uri->userinfo_start, debugstr_wn(uri->canon_uri + uri->userinfo_start, uri->userinfo_len),
1956
1957 /* Now insert the '@' after the userinfo. */
1958 if(!computeOnly)
1960 ++uri->canon_len;
1961
1963}
static BOOL canonicalize_username(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:1823
static BOOL canonicalize_password(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:1871
Referenced by canonicalize_authority().
◆ canonicalize_username()
|
static |
Definition at line 1823 of file uri.c.
1823 {
1825
1827 uri->userinfo_start = -1;
1829 }
1830
1834 /* Only decode % encoded values for known scheme types. */
1836 /* See if the value really needs decoding. */
1839 if(!computeOnly)
1841
1842 ++uri->canon_len;
1843
1844 /* Move pass the hex characters. */
1845 ptr += 2;
1846 continue;
1847 }
1848 }
1850 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
1851 * is NOT set.
1852 */
1854 if(!computeOnly)
1856
1857 uri->canon_len += 3;
1858 continue;
1859 }
1860 }
1861
1862 if(!computeOnly)
1863 /* Nothing special, so just copy the character over. */
1865 ++uri->canon_len;
1866 }
1867
1869}
Referenced by canonicalize_userinfo().
◆ check_dec_octet()
Definition at line 772 of file uri.c.
772 {
774
775 c1 = *ptr;
776 /* A dec-octet must be at least 1 digit long. */
777 if(*c1 < '0' || *c1 > '9')
779
780 ++(*ptr);
781
782 c2 = *ptr;
783 /* Since the 1-digit requirement was met, it doesn't
784 * matter if this is a DIGIT value, it's considered a
785 * dec-octet.
786 */
787 if(*c2 < '0' || *c2 > '9')
789
790 ++(*ptr);
791
792 c3 = *ptr;
793 /* Same explanation as above. */
794 if(*c3 < '0' || *c3 > '9')
796
797 /* Anything > 255 isn't a valid IP dec-octet. */
798 if(*c1 >= '2' && *c2 >= '5' && *c3 >= '5') {
799 *ptr = c1;
801 }
802
803 ++(*ptr);
805}
Referenced by check_ipv4address().
◆ check_hierarchical()
Definition at line 275 of file uri.c.
275 {
277
280
281 ++(*ptr);
285 }
286
287 ++(*ptr);
289}
Referenced by is_hierarchical_uri(), and parse_canonicalize().
◆ check_implicit_ipv4()
Definition at line 813 of file uri.c.
Referenced by parse_ipv4address().
◆ check_ipv4address()
Definition at line 845 of file uri.c.
845 {
847
851 }
852
856 }
857
858 ++(*ptr);
862 }
863
868 } else
870 }
871
872 ++(*ptr);
876 }
877
882 } else
884 }
885
886 ++(*ptr);
890 }
891
892 /* Found a four digit ip address. */
894}
Referenced by parse_ipv4address().
◆ check_pct_encoded()
Definition at line 744 of file uri.c.
744 {
746
749
750 ++(*ptr);
754 }
755
756 ++(*ptr);
760 }
761
762 ++(*ptr);
764}
Referenced by canonicalize_path_hierarchical(), parse_fragment(), parse_password(), parse_path_hierarchical(), parse_path_opaque(), parse_query(), parse_reg_name(), and parse_username().
◆ CoInternetCombineIUri()
| HRESULT WINAPI CoInternetCombineIUri | ( | IUri * | pBaseUri, |
| IUri * | pRelativeUri, | ||
| DWORD | dwCombineFlags, | ||
| IUri ** | ppCombinedUri, | ||
| DWORD_PTR | dwReserved | ||
| ) |
Definition at line 6396 of file uri.c.
6398{
6402 TRACE("(%p %p %lx %p %Ix)\n", pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, dwReserved);
6403
6404 if(!ppCombinedUri)
6406
6407 if(!pBaseUri || !pRelativeUri) {
6408 *ppCombinedUri = NULL;
6410 }
6411
6412 relative = get_uri_obj(pRelativeUri);
6415 *ppCombinedUri = NULL;
6417 pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, dwReserved);
6419 }
6420
6424 DWORD result_len = 0;
6425
6426 hr = IInternetProtocolInfo_CombineUrl(info, base->canon_uri, relative->canon_uri, dwCombineFlags,
6428 IInternetProtocolInfo_Release(info);
6433 }
6434 }
6435
6437}
HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
Definition: uri.c:5382
static HRESULT combine_uri(Uri *base, Uri *relative, DWORD flags, IUri **result, DWORD extras)
Definition: uri.c:6132
Definition: urlmon.idl:961
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
Definition: test_simple.idl:29
Definition: notification.c:70
Referenced by create_uri(), CreateURLMonikerEx2(), and xslt_doc_get_uri().
◆ CoInternetCombineUrlEx()
| HRESULT WINAPI CoInternetCombineUrlEx | ( | IUri * | pBaseUri, |
| LPCWSTR | pwzRelativeUrl, | ||
| DWORD | dwCombineFlags, | ||
| IUri ** | ppCombinedUri, | ||
| DWORD_PTR | dwReserved | ||
| ) |
Definition at line 6442 of file uri.c.
6444{
6445 IUri *relative;
6449
6451 ppCombinedUri, dwReserved);
6452
6453 if(!ppCombinedUri)
6455
6456 if(!pwzRelativeUrl) {
6457 *ppCombinedUri = NULL;
6459 }
6460
6461 if(!pBaseUri) {
6462 *ppCombinedUri = NULL;
6464 }
6465
6468 *ppCombinedUri = NULL;
6469 FIXME("(%p %s %lx %p %Ix) Unknown IUri's not supported yet.\n", pBaseUri, debugstr_w(pwzRelativeUrl),
6470 dwCombineFlags, ppCombinedUri, dwReserved);
6472 }
6473
6477 DWORD result_len = 0;
6478
6481 IInternetProtocolInfo_Release(info);
6486 }
6487 }
6488
6489 hr = CreateUri(pwzRelativeUrl, Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, &relative);
6491 *ppCombinedUri = NULL;
6493 }
6494
6495 hr = combine_uri(base, get_uri_obj(relative), dwCombineFlags, ppCombinedUri, COMBINE_URI_FORCE_FLAG_USE);
6496
6497 IUri_Release(relative);
6499}
Definition: urlmon.idl:1761
Referenced by check_codebase(), combine_url(), create_relative_uri(), CreateURLMonikerEx(), httprequest_open(), and navigate_url().
◆ CoInternetParseIUri()
| HRESULT WINAPI CoInternetParseIUri | ( | IUri * | pIUri, |
| PARSEACTION | ParseAction, | ||
| DWORD | dwFlags, | ||
| LPWSTR | pwzResult, | ||
| DWORD | cchResult, | ||
| DWORD * | pcchResult, | ||
| DWORD_PTR | dwReserved | ||
| ) |
Definition at line 6927 of file uri.c.
6930{
6934
6936 cchResult, pcchResult, dwReserved);
6937
6938 if(!pcchResult)
6940
6941 if(!pwzResult || !pIUri) {
6942 *pcchResult = 0;
6944 }
6945
6947 *pcchResult = 0;
6951 }
6952
6956 pwzResult, cchResult, pcchResult, 0);
6957 IInternetProtocolInfo_Release(info);
6959 }
6960
6961 switch(ParseAction) {
6962 case PARSE_CANONICALIZE:
6964 break;
6965 case PARSE_FRIENDLY:
6967 break;
6968 case PARSE_ROOTDOCUMENT:
6970 break;
6971 case PARSE_DOCUMENT:
6973 break;
6974 case PARSE_PATH_FROM_URL:
6976 break;
6977 case PARSE_URL_FROM_PATH:
6979 break;
6980 case PARSE_SCHEMA:
6982 break;
6983 case PARSE_SITE:
6985 break;
6986 case PARSE_DOMAIN:
6988 break;
6989 case PARSE_LOCATION:
6990 case PARSE_ANCHOR:
6992 break;
6993 case PARSE_SECURITY_URL:
6994 case PARSE_MIME:
6995 case PARSE_SERVER:
6996 case PARSE_SECURITY_DOMAIN:
6997 *pcchResult = 0;
6999 break;
7000 default:
7001 *pcchResult = 0;
7004 pwzResult, cchResult, pcchResult, dwReserved);
7005 }
7006
7008}
static HRESULT parse_site(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6840
static HRESULT parse_domain(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6868
static HRESULT parse_anchor(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6896
static HRESULT parse_path_from_url(const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6724
static HRESULT parse_rootdocument(const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6640
static HRESULT parse_canonicalize(const Uri *uri, DWORD flags, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6501
static HRESULT parse_document(const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6691
static HRESULT parse_url_from_path(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6782
static HRESULT parse_schema(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6811
static HRESULT parse_friendly(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6612
Referenced by FileProtocol_StartEx(), and nsFileURL_GetFile().
◆ combine_uri()
|
static |
Definition at line 6132 of file uri.c.
6132 {
6138
6140
6141 /* Base case is when the relative Uri has a scheme name,
6142 * if it does, then 'result' will contain the same data
6143 * as the relative Uri.
6144 */
6150 }
6151
6153
6158 }
6159
6162 create_flags |= Uri_CREATE_NO_CANONICALIZE;
6164 create_flags |= Uri_CREATE_NO_DECODE_EXTRA_INFO;
6165 }
6166
6170 IUri_Release(&ret->IUri_iface);
6173 }
6174
6177
6179 } else {
6181 DWORD raw_flags = 0;
6182
6187 } else {
6190 create_flags |= Uri_CREATE_ALLOW_RELATIVE;
6191 }
6192
6194 proc_uri = relative;
6195
6199 data.username_len = (proc_uri->userinfo_split > -1) ? proc_uri->userinfo_split : proc_uri->userinfo_len;
6200 }
6201
6205 }
6206
6210 }
6211
6215 }
6218
6224 /* Just set the path as a '/' if the base didn't have
6225 * one and if it's a hierarchical URI.
6226 */
6228 data.path_len = 1;
6229 }
6230
6232 proc_uri = relative;
6233
6237 }
6238 } else {
6241
6242 /* There's two possibilities on what will happen to the path component
6243 * of the result IUri. First, if the relative path begins with a '/'
6244 * then the resulting path will just be the relative path. Second, if
6245 * relative path doesn't begin with a '/' then the base path and relative
6246 * path are merged together.
6247 */
6248 if(relative->path_len && *(relative->canon_uri+relative->path_start) == '/' && data.scheme_type != URL_SCHEME_MK) {
6251
6252 /* If the relative IUri's path starts with a '/', then we
6253 * don't use the base IUri's path. Unless the base IUri
6254 * is a file URI, in which case it uses the drive path of
6255 * the base IUri (if it has any) in the new path.
6256 */
6260 path_len += 3;
6261 copy_drive_path = TRUE;
6262 }
6263 }
6264
6266
6271 }
6272
6273 tmp = path;
6274
6275 /* Copy the base paths, drive path over. */
6276 if(copy_drive_path) {
6278 tmp += 3;
6279 }
6280
6283 } else {
6284 /* Merge the base path with the relative path. */
6291 }
6292
6293 /* If the resulting IUri is a file URI, the drive path isn't
6294 * reduced out when the dot segments are removed.
6295 */
6298 path_offset = 2;
6300 path_offset = 1;
6301 }
6302 }
6303
6304 /* Check if the dot segments need to be removed from the path. */
6308
6311 if(!tmp) {
6315 }
6316
6318 path = tmp;
6320 }
6321 }
6322
6326 }
6327
6328 /* Make sure the path component is valid. */
6330 pptr = &ptr;
6336 }
6337 }
6338
6342 }
6343
6345 raw_flags |= RAW_URI_FORCE_PORT_DISP;
6347 raw_flags |= RAW_URI_CONVERT_TO_DOS_PATH;
6348
6355 }
6356
6358
6365 }
6366
6368 create_flags |= Uri_CREATE_NO_CANONICALIZE;
6370 create_flags |= Uri_CREATE_FILE_USE_DOS_PATH;
6371
6375 IUri_Release(&ret->IUri_iface);
6378 }
6379
6382
6386
6388 }
6389
6391}
static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1599
static BOOL parse_path_hierarchical(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1523
static BOOL parse_host(const WCHAR **ptr, parse_data *data, DWORD extras)
Definition: uri.c:1493
static HRESULT merge_paths(parse_data *data, const WCHAR *base, DWORD base_len, const WCHAR *relative, DWORD relative_len, WCHAR **result, DWORD *result_len, DWORD flags)
Definition: uri.c:6082
static DWORD generate_raw_uri(const parse_data *data, BSTR uri, DWORD flags)
Definition: uri.c:3645
static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags)
Definition: uri.c:2978
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:341
Referenced by CoInternetCombineIUri(), and CoInternetCombineUrlEx().
◆ compare_file_paths()
Definition at line 3478 of file uri.c.
3479{
3480 WCHAR *canon_path_a, *canon_path_b;
3481 DWORD len_a, len_b;
3482
3486 }
3487
3491 }
3492
3493 /* Fast path */
3494 if(a->path_len == b->path_len && !wcsnicmp(a->canon_uri+a->path_start, b->canon_uri+b->path_start, a->path_len)) {
3497 }
3498
3499 len_a = canonicalize_path_hierarchical(a->canon_uri+a->path_start, a->path_len, a->scheme_type, FALSE, 0, FALSE, NULL);
3500 len_b = canonicalize_path_hierarchical(b->canon_uri+b->path_start, b->path_len, b->scheme_type, FALSE, 0, FALSE, NULL);
3501
3503 if(!canon_path_a)
3506 if(!canon_path_b) {
3507 free(canon_path_a);
3509 }
3510
3511 len_a = canonicalize_path_hierarchical(a->canon_uri+a->path_start, a->path_len, a->scheme_type, FALSE, 0, FALSE, canon_path_a);
3512 len_b = canonicalize_path_hierarchical(b->canon_uri+b->path_start, b->path_len, b->scheme_type, FALSE, 0, FALSE, canon_path_b);
3513
3515
3516 free(canon_path_a);
3517 free(canon_path_b);
3519}
Referenced by compare_uris().
◆ compare_uris()
Definition at line 3526 of file uri.c.
3526 {
3530
3532
3535
3536 /* Only compare the scheme names (if any) if their unknown scheme types. */
3537 if(!known_scheme) {
3540 /* Make sure the schemes are the same. */
3544 /* One of the Uri's has a scheme name, while the other doesn't. */
3546 }
3547
3548 /* If they have a userinfo component, perform case sensitive compare. */
3554 /* One of the Uri's had a userinfo, while the other one doesn't. */
3556
3557 /* Check if they have a host name. */
3560 /* Perform a case insensitive compare if they are a known scheme type. */
3561 if(known_scheme) {
3567 /* One of the Uri's had a host, while the other one didn't. */
3569
3574 /* One had a port, while the other one didn't. */
3576
3577 /* Windows is weird with how it handles paths. For example
3578 * One URI could be "http://google.com" (after canonicalization)
3579 * and one could be "http://google.com/" and the IsEqual function
3580 * would still evaluate to TRUE, but, only if they are both hierarchical
3581 * URIs.
3582 */
3585
3601
3602 /* Compare the query strings of the two URIs. */
3609
3616
3617 /* If we get here, the two URIs are equivalent. */
3620}
static HRESULT compare_file_paths(const Uri *a, const Uri *b, BOOL *ret)
Definition: uri.c:3478
Referenced by Uri_IsEqual().
◆ compute_canonicalized_length()
|
static |
Definition at line 2937 of file uri.c.
2937 {
2939
2941
2944
2947 return -1;
2948 }
2949
2952 return -1;
2953 }
2954
2957 return -1;
2958 }
2959
2962 return -1;
2963 }
2964
2965 TRACE("(%p %lx): Finished computing canonicalized URI length. length=%ld\n", data, flags, uri.canon_len);
2966
2968}
Referenced by canonicalize_uri().
◆ convert_to_dos_path()
|
static |
Definition at line 3622 of file uri.c.
3624{
3626
3628 /* Skip over the leading / before the drive path. */
3629 ++ptr;
3630
3633 if(output)
3634 *output++ = '\\';
3635 (*output_len)++;
3636 } else {
3637 if(output)
3638 *output++ = *ptr;
3639 (*output_len)++;
3640 }
3641 }
3642}
Referenced by generate_raw_uri().
◆ CreateIUriBuilder()
| HRESULT WINAPI CreateIUriBuilder | ( | IUri * | pIUri, |
| DWORD | dwFlags, | ||
| DWORD_PTR | dwReserved, | ||
| IUriBuilder ** | ppIUriBuilder | ||
| ) |
Definition at line 6035 of file uri.c.
6036{
6038
6040
6041 if(!ppIUriBuilder)
6043
6047
6049 ret->ref = 1;
6050
6051 if(pIUri) {
6053
6058 }
6059 IUri_AddRef(pIUri);
6061
6063 /* Windows doesn't set 'has_port' to TRUE in this case. */
6065
6066 } else {
6068 *ppIUriBuilder = NULL;
6070 dwReserved, ppIUriBuilder);
6072 }
6073 }
6074
6075 *ppIUriBuilder = &ret->IUriBuilder_iface;
6077}
Definition: uri.c:103
Referenced by ensure_uri_builder(), get_uri_nofrag(), httprequest_open(), nsURI_GetPrePath(), UriBuilderFactory_CreateInitializedIUriBuilder(), and UriBuilderFactory_CreateIUriBuilder().
◆ CreateUri()
Definition at line 5382 of file uri.c.
5383{
5384 const DWORD supported_flags = Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME|
5385 Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_NO_CANONICALIZE|Uri_CREATE_CANONICALIZE|
5386 Uri_CREATE_DECODE_EXTRA_INFO|Uri_CREATE_NO_DECODE_EXTRA_INFO|Uri_CREATE_CRACK_UNKNOWN_SCHEMES|
5387 Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES|Uri_CREATE_PRE_PROCESS_HTML_URI|Uri_CREATE_NO_PRE_PROCESS_HTML_URI|
5388 Uri_CREATE_NO_IE_SETTINGS|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS|Uri_CREATE_FILE_USE_DOS_PATH;
5392
5394
5395 if(!ppURI)
5397
5398 if(!pwzURI) {
5399 *ppURI = NULL;
5401 }
5402
5403 /* Check for invalid flags. */
5405 *ppURI = NULL;
5407 }
5408
5409 /* Currently unsupported. */
5412
5415 *ppURI = NULL;
5417 }
5418
5419 /* Explicitly set the default flags if it doesn't cause a flag conflict. */
5421
5422 /* Pre process the URI, unless told otherwise. */
5425 else
5427
5431 }
5432
5435
5436 /* Validate and parse the URI into its components. */
5438 /* Encountered an unsupported or invalid URI */
5439 IUri_Release(&ret->IUri_iface);
5440 *ppURI = NULL;
5442 }
5443
5444 /* Canonicalize the URI. */
5447 IUri_Release(&ret->IUri_iface);
5448 *ppURI = NULL;
5450 }
5451
5453
5454 *ppURI = &ret->IUri_iface;
5456}
Referenced by AsyncInstallDistributionUnit(), BindProtocol_Start(), CoInternetCombineIUri(), CoInternetCombineUrlEx(), CoInternetGetSecurityUrlEx(), create_uri(), CreateUriWithFragment(), CreateURLMonikerEx(), FileProtocol_Start(), FtpProtocol_Start(), get_base_uri(), get_security_id_for_url(), GopherProtocol_Start(), HttpProtocol_Start(), httprequest_open(), map_url_to_zone(), MkProtocol_Start(), URLMoniker_Load(), and xslt_doc_get_uri().
◆ CreateUriWithFragment()
| HRESULT WINAPI CreateUriWithFragment | ( | LPCWSTR | pwzURI, |
| LPCWSTR | pwzFragment, | ||
| DWORD | dwFlags, | ||
| DWORD_PTR | dwReserved, | ||
| IUri ** | ppURI | ||
| ) |
Definition at line 5477 of file uri.c.
5479{
5481 TRACE("(%s %s %lx %Ix %p)\n", debugstr_w(pwzURI), debugstr_w(pwzFragment), dwFlags, dwReserved, ppURI);
5482
5483 if(!ppURI)
5485
5486 if(!pwzURI) {
5487 *ppURI = NULL;
5489 }
5490
5491 /* Check if a fragment should be appended to the URI string. */
5492 if(pwzFragment) {
5493 WCHAR *uriW;
5494 DWORD uri_len, frag_len;
5495 BOOL add_pound;
5496
5497 /* Check if the original URI already has a fragment component. */
5499 *ppURI = NULL;
5501 }
5502
5503 uri_len = lstrlenW(pwzURI);
5504 frag_len = lstrlenW(pwzFragment);
5505
5506 /* If the fragment doesn't start with a '#', one will be added. */
5507 add_pound = *pwzFragment != '#';
5508
5509 if(add_pound)
5511 else
5513
5514 if(!uriW)
5516
5518 if(add_pound)
5519 uriW[uri_len++] = '#';
5521
5523
5524 free(uriW);
5525 } else
5526 /* A fragment string wasn't specified, so just forward the call. */
5528
5530}
◆ decode_pct_val()
Definition at line 440 of file uri.c.
440 {
442
446
449 }
450
452}
Referenced by canonicalize_fragment(), canonicalize_password(), canonicalize_path_hierarchical(), canonicalize_path_opaque(), canonicalize_query(), canonicalize_reg_name(), canonicalize_username(), parse_canonicalize(), and parse_path_from_url().
◆ destroy_uri_obj()
Definition at line 3814 of file uri.c.
Referenced by Uri_Release().
◆ find_domain_name()
Definition at line 477 of file uri.c.
478 {
480
482
483 *domain_start = -1;
484
485 /* There has to be at least enough room for a '.' followed by a
486 * 3-character TLD for a domain to even exist in the host name.
487 */
488 if(host_len < 4)
489 return;
490
492 {
494 {
495 sec_last_tld = last_tld;
496 last_tld = p;
497 }
498 }
499 if(!last_tld)
500 /* http://hostname -> has no domain name. */
501 return;
502
503 if(!sec_last_tld) {
504 /* If the '.' is at the beginning of the host there
505 * has to be at least 3 characters in the TLD for it
506 * to be valid.
507 * Ex: .com -> .com as the domain name.
508 * .co -> has no domain name.
509 */
512 return;
515
516 /* If there are three characters in front of last_tld and
517 * they are on the list of recognized TLDs, then this
518 * host doesn't have a domain (since the host only contains
519 * a TLD name.
520 * Ex: edu.uk -> has no domain name.
521 * foo.uk -> foo.uk as the domain name.
522 */
525 return;
526 }
528 {
529 /* Anything less than 3 ASCII characters is considered part
530 * of the TLD name.
531 * Ex: ak.uk -> Has no domain name.
532 */
535 break;
536 }
537
539 return;
540 }
541
542 /* Otherwise the domain name is the whole host name. */
543 *domain_start = 0;
545 /* If the last_tld has more than 3 characters, then it's automatically
546 * considered the TLD of the domain name.
547 * Ex: www.winehq.org.uk.test -> uk.test as the domain name.
548 */
549 *domain_start = (sec_last_tld+1)-host;
550 } else if(last_tld - (sec_last_tld+1) < 4) {
552 /* If the sec_last_tld is 3 characters long it HAS to be on the list of
553 * recognized to still be considered part of the TLD name, otherwise
554 * it's considered the domain name.
555 * Ex: www.google.com.uk -> google.com.uk as the domain name.
556 * www.google.foo.uk -> foo.uk as the domain name.
557 */
558 if(last_tld - (sec_last_tld+1) == 3) {
565 return;
566 }
567 }
568
569 *domain_start = (sec_last_tld+1)-host;
570 } else {
571 /* Since the sec_last_tld is less than 3 characters it's considered
572 * part of the TLD.
573 * Ex: www.google.fo.uk -> google.fo.uk as the domain name.
574 */
577 }
578 } else {
579 /* The second to last TLD has more than 3 characters making it
580 * the domain name.
581 * Ex: www.google.test.us -> test.us as the domain name.
582 */
583 *domain_start = (sec_last_tld+1)-host;
584 }
585
588}
static const struct @614 recognized_tlds[]
Referenced by canonicalize_reg_name(), and search_domain_for_zone().
◆ find_file_extension()
◆ generate_raw_uri()
|
static |
Definition at line 3645 of file uri.c.
3645 {
3647
3652 }
3654 }
3655
3657 /* For the "//" which appears before the authority component. */
3661 }
3662 length += 2;
3663
3664 /* Check if we need to add the "\\" before the host name
3665 * of a UNC server name in a DOS path.
3666 */
3672 }
3673 length += 2;
3674 }
3675 }
3676
3681 }
3682
3687 }
3689 }
3690
3694 ++length;
3695 }
3696
3698 /* IPv6 addresses get the brackets added around them if they don't already
3699 * have them.
3700 */
3702 if(add_brackets) {
3705 ++length;
3706 }
3707
3711
3712 if(add_brackets) {
3715 length++;
3716 }
3717 }
3718
3720 /* The port isn't included in the raw uri if it's the default
3721 * port for the scheme type.
3722 */
3725
3729 is_default = TRUE;
3730 }
3731
3735 ++length;
3736
3739 else
3741 }
3742 }
3743
3744 /* Check if a '/' should be added before the path for hierarchical URIs. */
3748 ++length;
3749 }
3750
3755
3758 else
3760
3762 } else {
3766 }
3767 }
3768
3773 }
3774
3779 }
3780
3783 else
3785
3787}
static void convert_to_dos_path(const WCHAR *path, DWORD path_len, WCHAR *output, DWORD *output_len)
Definition: uri.c:3622
Referenced by combine_uri(), and generate_uri().
◆ generate_uri()
|
static |
Definition at line 3789 of file uri.c.
3789 {
3795
3797
3803 }
3804
3807}
Referenced by build_uri().
◆ get_builder_component()
|
static |
Definition at line 3043 of file uri.c.
3046{
3047 if(!output_len) {
3048 if(output)
3049 *output = NULL;
3051 }
3052
3053 if(!output) {
3054 *output_len = 0;
3056 }
3057
3059 /* Allocate 'component', and copy the contents from 'source'
3060 * into the new allocation.
3061 */
3063 if(!(*component))
3065
3067 (*component)[source_len] = '\0';
3068 *component_len = source_len;
3069 }
3070
3071 *output = *component;
3072 *output_len = *component_len;
3074}
Definition: pdh_main.c:174
Referenced by UriBuilder_GetFragment(), UriBuilder_GetHost(), UriBuilder_GetPassword(), UriBuilder_GetPath(), UriBuilder_GetQuery(), UriBuilder_GetSchemeName(), and UriBuilder_GetUserName().
◆ get_uri_obj()
Definition at line 236 of file uri.c.
237{
240
243}
Referenced by CoInternetCombineIUri(), CoInternetCombineUrlEx(), CoInternetParseIUri(), CreateIUriBuilder(), Uri_IsEqual(), and UriBuilder_SetIUri().
◆ has_invalid_flag_combination()
◆ hex_to_int()
◆ impl_from_IMarshal()
Definition at line 5102 of file uri.c.
5103{
5105}
Referenced by Marshal_AddRef(), Marshal_DisconnectObject(), Marshal_GetMarshalSizeMax(), Marshal_GetUnmarshalClass(), Marshal_MarshalInterface(), Marshal_QueryInterface(), Marshal_Release(), Marshal_ReleaseMarshalData(), and Marshal_UnmarshalInterface().
◆ impl_from_IPersistStream()
|
inlinestatic |
Definition at line 4809 of file uri.c.
Referenced by PersistStream_AddRef(), PersistStream_GetClassID(), PersistStream_GetSizeMax(), PersistStream_IsDirty(), PersistStream_Load(), PersistStream_QueryInterface(), PersistStream_Release(), and PersistStream_Save().
◆ impl_from_IUri()
Definition at line 3809 of file uri.c.
Referenced by custom_uri_AddRef(), custom_uri_GetAbsoluteUri(), custom_uri_GetAuthority(), custom_uri_GetDisplayUri(), custom_uri_GetDomain(), custom_uri_GetExtension(), custom_uri_GetFragment(), custom_uri_GetHost(), custom_uri_GetHostType(), custom_uri_GetPassword(), custom_uri_GetPath(), custom_uri_GetPathAndQuery(), custom_uri_GetPort(), custom_uri_GetProperties(), custom_uri_GetPropertyBSTR(), custom_uri_GetPropertyDWORD(), custom_uri_GetPropertyLength(), custom_uri_GetQuery(), custom_uri_GetRawUri(), custom_uri_GetScheme(), custom_uri_GetSchemeName(), custom_uri_GetUserInfo(), custom_uri_GetUserName(), custom_uri_GetZone(), custom_uri_HasProperty(), custom_uri_IsEqual(), custom_uri_Release(), Uri_AddRef(), Uri_GetProperties(), Uri_GetPropertyBSTR(), Uri_GetPropertyDWORD(), Uri_GetPropertyLength(), Uri_HasProperty(), Uri_IsEqual(), Uri_QueryInterface(), and Uri_Release().
◆ impl_from_IUriBuilder()
|
inlinestatic |
Definition at line 5590 of file uri.c.
Referenced by UriBuilder_AddRef(), UriBuilder_CreateUri(), UriBuilder_CreateUriSimple(), UriBuilder_CreateUriWithFlags(), UriBuilder_GetFragment(), UriBuilder_GetHost(), UriBuilder_GetIUri(), UriBuilder_GetPassword(), UriBuilder_GetPath(), UriBuilder_GetPort(), UriBuilder_GetQuery(), UriBuilder_GetSchemeName(), UriBuilder_GetUserName(), UriBuilder_HasBeenModified(), UriBuilder_QueryInterface(), UriBuilder_Release(), UriBuilder_RemoveProperties(), UriBuilder_SetFragment(), UriBuilder_SetHost(), UriBuilder_SetIUri(), UriBuilder_SetPassword(), UriBuilder_SetPath(), UriBuilder_SetPort(), UriBuilder_SetQuery(), UriBuilder_SetSchemeName(), and UriBuilder_SetUserName().
◆ impl_from_IUriBuilderFactory()
|
inlinestatic |
Definition at line 4740 of file uri.c.
Referenced by UriBuilderFactory_AddRef(), UriBuilderFactory_CreateInitializedIUriBuilder(), UriBuilderFactory_CreateIUriBuilder(), UriBuilderFactory_QueryInterface(), and UriBuilderFactory_Release().
◆ is_alpha()
◆ is_ascii()
Definition at line 343 of file uri.c.
Referenced by canonicalize_fragment(), canonicalize_password(), canonicalize_path_hierarchical(), canonicalize_path_opaque(), canonicalize_query(), canonicalize_reg_name(), canonicalize_username(), find_domain_name(), parse_canonicalize(), and parse_reg_name().
◆ is_auth_delim()
Definition at line 318 of file uri.c.
318 {
321}
Referenced by parse_ipv4address(), parse_ipv6address(), parse_password(), parse_port(), parse_reg_name(), and parse_username().
◆ is_default_port()
|
static |
Definition at line 348 of file uri.c.
348 {
350
354 }
355
357}
Referenced by Uri_GetPropertyBSTR(), and Uri_GetPropertyLength().
◆ is_drive_path()
Definition at line 253 of file uri.c.
253 {
255}
Referenced by canonicalize_path_hierarchical(), combine_uri(), convert_to_dos_path(), parse_path_from_url(), and parse_reg_name().
◆ is_forbidden_dos_path_char()
Definition at line 261 of file uri.c.
Referenced by canonicalize_path_hierarchical(), parse_path_hierarchical(), parse_path_opaque(), and parse_reg_name().
◆ is_gendelim()
◆ is_hexdigit()
Definition at line 328 of file uri.c.
328 {
332}
Referenced by check_pct_encoded(), decode_pct_val(), and parse_ipvfuture().
◆ is_hierarchical_scheme()
|
inlinestatic |
Definition at line 360 of file uri.c.
360 {
366}
Referenced by canonicalize_hierpart(), and is_hierarchical_uri().
◆ is_hierarchical_uri()
|
inlinestatic |
Definition at line 403 of file uri.c.
Referenced by parse_hierpart().
◆ is_implicit_file_path()
◆ is_num()
Definition at line 249 of file uri.c.
Referenced by check_implicit_ipv4(), hash_init(), is_unreserved(), parse_port(), and parse_scheme_name().
◆ is_path_delim()
|
inlinestatic |
Definition at line 334 of file uri.c.
Referenced by parse_path_hierarchical(), and parse_path_opaque().
◆ is_reserved()
Definition at line 324 of file uri.c.
324 {
326}
Referenced by canonicalize_fragment(), canonicalize_password(), canonicalize_path_hierarchical(), canonicalize_path_opaque(), canonicalize_query(), canonicalize_reg_name(), canonicalize_username(), and parse_canonicalize().
◆ is_slash()
Definition at line 338 of file uri.c.
Referenced by remove_dot_segments().
◆ is_subdelim()
◆ is_unc_path()
Definition at line 257 of file uri.c.
Referenced by is_implicit_file_path(), and parse_reg_name().
◆ is_unreserved()
Definition at line 292 of file uri.c.
292 {
295}
Referenced by canonicalize_fragment(), canonicalize_password(), canonicalize_path_hierarchical(), canonicalize_path_opaque(), canonicalize_query(), canonicalize_reg_name(), canonicalize_username(), parse_canonicalize(), and parse_ipvfuture().
◆ Marshal_AddRef()
◆ Marshal_DisconnectObject()
◆ Marshal_GetMarshalSizeMax()
|
static |
Definition at line 5147 of file uri.c.
5149{
5154 dwDestContext, pvDestContext, mshlflags, pSize);
5155
5156 if(!pSize || (dwDestContext!=MSHCTX_LOCAL && dwDestContext!=MSHCTX_NOSHAREDMEM
5157 && dwDestContext!=MSHCTX_INPROC))
5159
5160 if(dwDestContext == MSHCTX_INPROC) {
5163 }
5164
5174}
Definition: ms-dtyp.idl:184
Definition: uri.c:5140
◆ Marshal_GetUnmarshalClass()
|
static |
Definition at line 5125 of file uri.c.
5127{
5130 dwDestContext, pvDestContext, mshlflags, pCid);
5131
5132 if(!pCid || (dwDestContext!=MSHCTX_LOCAL && dwDestContext!=MSHCTX_NOSHAREDMEM
5133 && dwDestContext!=MSHCTX_INPROC))
5135
5136 *pCid = CLSID_CUri;
5138}
GUID const CLSID_CUri
◆ Marshal_MarshalInterface()
|
static |
Definition at line 5176 of file uri.c.
5178{
5183
5185 dwDestContext, pvDestContext, mshlflags);
5186
5187 if(!pStm || mshlflags!=MSHLFLAGS_NORMAL || (dwDestContext!=MSHCTX_LOCAL
5188 && dwDestContext!=MSHCTX_NOSHAREDMEM && dwDestContext!=MSHCTX_INPROC))
5190
5191 if(dwDestContext == MSHCTX_INPROC) {
5193
5195 data.mshlflags = MSHCTX_INPROC;
5196 data.unk[0] = 0;
5197 data.unk[1] = 0;
5198 data.unk[2] = 0;
5199 data.unk[3] = 0;
5201
5205
5206 IUri_AddRef(&This->IUri_iface);
5208 }
5209
5214
5218
5220 data[1] = dwDestContext;
5223
5227}
static void persist_stream_save(Uri *This, IStream *pStm, BOOL marshal, struct persist_uri *data)
Definition: uri.c:4938
Definition: uri.c:4851
◆ Marshal_QueryInterface()
◆ Marshal_Release()
◆ Marshal_ReleaseMarshalData()
Definition at line 5287 of file uri.c.
5288{
5290 LARGE_INTEGER off;
5293
5295
5296 if(!pStm)
5298
5302
5305
5309
5310 IUri_Release(&data.uri->IUri_iface);
5312 }
5313
5315 off.u.HighPart = 0;
5317}
Definition: winhttp_private.h:134
Definition: typedefs.h:103
struct _LARGE_INTEGER::@2527 u
◆ Marshal_UnmarshalInterface()
|
static |
◆ merge_paths()
|
static |
Definition at line 6082 of file uri.c.
6084{
6086 DWORD base_copy_len = 0;
6088
6089 if(base_len) {
6091 /* Find '::' segment */
6094 end++;
6095 break;
6096 }
6097 }
6098
6099 /* If not found, try finding the end of @xxx: */
6102 }else {
6103 /* Find the characters that will be copied over from the base path. */
6106 /* Try looking for a '\\'. */
6108 }
6109 }
6110
6113
6115 *result_len = 0;
6117 }
6118
6121 ptr += base_copy_len;
6122
6124 ptr += relative_len;
6126
6130}
Referenced by combine_uri().
◆ parse_anchor()
|
static |
Definition at line 6896 of file uri.c.
6897{
6901
6904 *result_len = 0;
6906 }
6907
6908 *result_len = len;
6911
6914 *result_len = 0;
6916 }
6917
6920
6922}
Referenced by CoInternetParseIUri().
◆ parse_authority()
|
static |
Definition at line 1510 of file uri.c.
1510 {
1512
1513 /* Parsing the port will happen during one of the host parsing
1514 * routines (if the URI has a port).
1515 */
1518
1520}
static void parse_userinfo(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1101
Referenced by parse_hierpart().
◆ parse_canonicalize()
|
static |
Definition at line 6501 of file uri.c.
6503{
6508 BOOL reduce_path;
6509
6510 /* URL_UNESCAPE only has effect if none of the URL_ESCAPE flags are set. */
6514
6515
6516 /* Check if the dot segments need to be removed from the
6517 * path component.
6518 */
6521 pptr = &ptr;
6522 }
6525
6528
6529 /* Keep track of the path if we need to remove dot segments from
6530 * it later.
6531 */
6534
6535 /* Check if it's time to reduce the path. */
6539
6540 /* Update the current length. */
6541 len -= (current_path_len-new_path_len);
6542 reduce_path = FALSE;
6543 }
6544
6547 if(decoded) {
6550 output[len] = decoded;
6551 len++;
6552 ptr += 2;
6553 do_default_action = FALSE;
6554 }
6555 }
6556
6557 /* See if %'s needed to encoded. */
6561 len += 3;
6562 do_default_action = FALSE;
6563 }
6569 len += 3;
6570 do_default_action = FALSE;
6571 }
6576 len += 3;
6577 do_default_action = FALSE;
6578 }
6579 }
6580
6581 if(do_default_action) {
6584 len++;
6585 }
6586 }
6587
6588 /* Sometimes the path is the very last component of the IUri, so
6589 * see if the dot segments need to be reduced now.
6590 */
6594
6595 /* Update the current length. */
6596 len -= (current_path_len-new_path_len);
6597 }
6598
6600 output[len] = 0;
6601 else
6602 output[output_len-1] = 0;
6603
6604 /* The null terminator isn't included in the length. */
6605 *result_len = len;
6608
6610}
Referenced by CoInternetParseIUri().
◆ parse_document()
|
static |
Definition at line 6691 of file uri.c.
6693{
6695
6696 /* It has to be a known scheme type, but, it can't be a file
6697 * scheme. It also has to hierarchical.
6698 */
6701 uri->authority_start == -1) {
6702 *result_len = 0;
6703 if(output_len < 1)
6705
6706 output[0] = 0;
6708 }
6709
6712 else
6714
6715 *result_len = len;
6718
6720 output[len] = 0;
6722}
Referenced by CoInternetParseIUri().
◆ parse_domain()
|
static |
Definition at line 6868 of file uri.c.
6869{
6873
6876 *result_len = 0;
6878 }
6879
6880 *result_len = len;
6883
6886 *result_len = 0;
6888 }
6889
6892
6894}
Referenced by CoInternetParseIUri().
◆ parse_fragment()
|
static |
Definition at line 1761 of file uri.c.
1761 {
1763
1767 }
1768
1770
1771 ++(*ptr);
1774 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
1779 } else
1780 continue;
1781 }
1782
1783 ++(*ptr);
1784 }
1785
1787
1791}
Referenced by parse_uri(), and validate_fragment().
◆ parse_friendly()
|
static |
Definition at line 6612 of file uri.c.
6614{
6616 DWORD display_len;
6618
6621 *result_len = 0;
6623 }
6624
6625 *result_len = display_len;
6626 if(display_len+1 > output_len)
6628
6631 *result_len = 0;
6633 }
6634
6638}
Referenced by CoInternetParseIUri().
◆ parse_hierpart()
|
static |
Definition at line 1659 of file uri.c.
1659 {
1661
1663
1664 /* For javascript: URIs, simply set everything as a path */
1671 }
1672
1673 /* Checks if the authority information needs to be parsed. */
1675 /* Only treat it as a hierarchical URI if the scheme_type is known or
1676 * the Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is not set.
1677 */
1679 !(flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES)) {
1682
1686 *ptr += 2;
1687 }
1688 }
1689
1690 /* TODO: Handle hierarchical URI's, parse authority then parse the path. */
1693
1695 } else
1696 /* Reset ptr to its starting position so opaque path parsing
1697 * begins at the correct location.
1698 */
1700 }
1701
1702 /* If it reaches here, then the URI will be treated as an opaque
1703 * URI.
1704 */
1705
1707
1711
1713}
static BOOL is_hierarchical_uri(const WCHAR **ptr, const parse_data *data)
Definition: uri.c:403
static BOOL parse_authority(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1510
Referenced by parse_uri().
◆ parse_host()
|
static |
Definition at line 1493 of file uri.c.
1493 {
1499 }
1500 }
1501 }
1502
1504}
static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data)
Definition: uri.c:1195
static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD extras)
Definition: uri.c:1256
static BOOL parse_ip_literal(const WCHAR **ptr, parse_data *data, DWORD extras)
Definition: uri.c:1443
Referenced by combine_uri(), parse_authority(), and validate_host().
◆ parse_ip_literal()
|
static |
Definition at line 1443 of file uri.c.
1443 {
1445
1450 ++(*ptr);
1451
1457 }
1458 }
1459
1465 /* The IP literal didn't contain brackets and was followed by
1466 * a NULL terminator, so no reason to even check the port.
1467 */
1470 }
1471
1472 ++(*ptr);
1474 ++(*ptr);
1475 /* If a valid port is not found, then let it trickle down to
1476 * parse_reg_name.
1477 */
1482 }
1483 } else
1485
1487}
static BOOL parse_ipvfuture(const WCHAR **ptr, parse_data *data)
Definition: uri.c:1400
static BOOL parse_ipv6address(const WCHAR **ptr, parse_data *data)
Definition: uri.c:1386
Referenced by parse_host().
◆ parse_ipv4address()
|
static |
Definition at line 1195 of file uri.c.
1195 {
1198
1205 } else
1207 }
1208
1210 data->host_type = Uri_HOST_IPV4;
1211
1212 /* Check if what we found is the only part of the host name (if it isn't
1213 * we don't have an IPv4 address).
1214 */
1216 ++(*ptr);
1221 }
1223 /* Found more data which belongs to the host, so this isn't an IPv4. */
1228 }
1229
1234}
static BOOL check_implicit_ipv4(const WCHAR **ptr, UINT *val)
Definition: uri.c:813
Referenced by parse_host().
◆ parse_ipv6address()
|
static |
Definition at line 1386 of file uri.c.
1386 {
1388
1393
1394 *ptr = terminator;
1395 data->host_type = Uri_HOST_IPV6;
1397}
NTSYSAPI NTSTATUS NTAPI RtlIpv6StringToAddressW(_In_ PCWSTR String, _Out_ PCWSTR *Terminator, _Out_ struct in6_addr *Addr)
Definition: network.c:1005
Referenced by parse_ip_literal().
◆ parse_ipvfuture()
|
static |
Definition at line 1400 of file uri.c.
1400 {
1402
1403 /* IPvFuture has to start with a 'v' or 'V'. */
1406
1407 /* Following the v there must be at least 1 hex digit. */
1408 ++(*ptr);
1412 }
1413
1414 ++(*ptr);
1416 ++(*ptr);
1417
1418 /* End of the hexdigit sequence must be a '.' */
1422 }
1423
1424 ++(*ptr);
1428 }
1429
1430 ++(*ptr);
1432 ++(*ptr);
1433
1434 data->host_type = Uri_HOST_UNKNOWN;
1435
1438
1440}
Referenced by parse_ip_literal().
◆ parse_password()
|
static |
Definition at line 1054 of file uri.c.
1054 {
1056
1064 }
1065 } else
1066 continue;
1068 break;
1073 }
1074
1075 ++(*ptr);
1076 }
1077
1080}
Referenced by parse_userinfo(), and validate_password().
◆ parse_path_from_url()
|
static |
Definition at line 6724 of file uri.c.
6726{
6730
6732 *result_len = 0;
6733 if(output_len > 0)
6734 output[0] = 0;
6736 }
6737
6741
6746 }
6747
6750 /* Skip past the '/' in front of the drive path. */
6751 ++path_ptr;
6752
6755
6756 if(*path_ptr == '%') {
6758 if(decoded) {
6759 *ptr = decoded;
6760 path_ptr += 2;
6761 do_default_action = FALSE;
6762 }
6763 } else if(*path_ptr == '/') {
6765 do_default_action = FALSE;
6766 }
6767
6768 if(do_default_action)
6769 *ptr = *path_ptr;
6770 }
6771
6772 *ptr = 0;
6773
6775 if(*result_len+1 > output_len)
6777
6780}
Referenced by CoInternetParseIUri().
◆ parse_path_hierarchical()
|
static |
Definition at line 1523 of file uri.c.
1523 {
1526
1530 data->path_len = 0;
1532 /* If the path component is empty, then a '/' is added. */
1534 data->path_len = 1;
1535 }
1536 } else {
1542 } else
1543 continue;
1545 (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
1546 /* File schemes with USE_DOS_PATH set aren't allowed to have
1547 * a '<' or '>' or '\"' appear in them.
1548 */
1552 /* Not allowed to have a backslash if NO_CANONICALIZE is set
1553 * and the scheme is known type (but not a file scheme).
1554 */
1560 }
1561 }
1562 }
1563
1564 ++(*ptr);
1565 }
1566
1567 /* The only time a URI doesn't have a path is when
1568 * the NO_CANONICALIZE flag is set and the raw URI
1569 * didn't contain one.
1570 */
1573 data->path_len = 0;
1574 } else {
1577 }
1578 }
1579
1583 else
1585
1587}
Referenced by combine_uri(), parse_hierpart(), and validate_path().
◆ parse_path_opaque()
|
static |
Definition at line 1599 of file uri.c.
1599 {
1603
1605 {
1608 }
1609 else
1611
1618 } else
1619 continue;
1621 (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
1625 }
1626
1627 ++(*ptr);
1628 }
1629
1634}
Referenced by combine_uri(), parse_hierpart(), and validate_path().
◆ parse_port()
|
static |
Definition at line 1150 of file uri.c.
1150 {
1153
1159 }
1160
1162
1167 }
1168
1169 ++(*ptr);
1170 }
1171
1175
1179}
Referenced by parse_ip_literal(), parse_ipv4address(), and parse_reg_name().
◆ parse_query()
|
static |
Definition at line 1722 of file uri.c.
1722 {
1724
1728 }
1729
1731
1732 ++(*ptr);
1735 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
1740 } else
1741 continue;
1742 }
1743
1744 ++(*ptr);
1745 }
1746
1748
1752}
Referenced by do_query(), exec_query(), get_diskdrivetodiskpartition_pairs(), get_logicaldisktopartition_pairs(), parse_uri(), validate_query(), and wbem_services_ExecMethod().
◆ parse_reg_name()
|
static |
Definition at line 1256 of file uri.c.
1256 {
1260 BOOL inside_brackets = has_start_bracket;
1261
1262 /* res URIs don't have ports. */
1264
1265 /* We have to be careful with file schemes. */
1267 /* This is because an implicit file scheme could be "C:\\test" and it
1268 * would trick this function into thinking the host is "C", when after
1269 * canonicalization the host would end up being an empty string. A drive
1270 * path can also have a '|' instead of a ':' after the drive letter.
1271 */
1273 /* Regular old drive paths have no host type (or host name). */
1274 data->host_type = Uri_HOST_UNKNOWN;
1276 data->host_len = 0;
1279 /* Skip past the "\\" of a UNC path. */
1280 *ptr += 2;
1281 }
1282
1284
1285 /* For res URIs, everything before the first '/' is
1286 * considered the host.
1287 */
1291 /* We can ignore ':' if we are inside brackets.*/
1292 if(!inside_brackets) {
1294
1295 /* Attempt to parse the port. */
1297 /* Windows expects there to be a valid port for known scheme types. */
1303 } else
1304 /* Windows gives up on trying to parse a port when it
1305 * encounters an invalid port.
1306 */
1307 ignore_col = TRUE;
1308 } else {
1310 break;
1311 }
1312 }
1314 /* Has to be a legit % encoded value. */
1319 } else
1320 continue;
1326 inside_brackets = FALSE;
1328 inside_brackets = TRUE;
1329
1330 ++(*ptr);
1331 }
1332
1333 if(has_start_bracket) {
1334 /* Make sure the last character of the host wasn't a ']'. */
1340 }
1341 }
1342
1343 /* Don't overwrite our length if we found a port earlier. */
1346
1347 /* If the host is empty, then it's an unknown host type. */
1349 data->host_type = Uri_HOST_UNKNOWN;
1350 else {
1352
1353 data->host_type = Uri_HOST_DNS;
1354
1357 data->host_type = Uri_HOST_IDN;
1358 break;
1359 }
1360 }
1361 }
1362
1366}
Referenced by parse_host().
◆ parse_rootdocument()
|
static |
Definition at line 6640 of file uri.c.
6642{
6644
6647
6648 /* Windows only returns the root document if the URI has an authority
6649 * and it's not an unknown scheme type or a file scheme type.
6650 */
6654 *result_len = 0;
6655 if(!output_len)
6657
6658 output[0] = 0;
6660 }
6661
6663 /* For the "://" and '/' which will be added. */
6664 len += 4;
6665
6667 *result_len = len;
6669 }
6670
6671 ptr = output;
6673
6674 /* Add the "://". */
6677
6678 /* Add the authority. */
6681
6682 /* Add the '/' after the authority. */
6685 ptr[1] = 0;
6686
6687 *result_len = len;
6689}
Referenced by CoInternetParseIUri().
◆ parse_schema()
|
static |
Definition at line 6811 of file uri.c.
6813{
6817
6820 *result_len = 0;
6822 }
6823
6824 *result_len = len;
6827
6830 *result_len = 0;
6832 }
6833
6836
6838}
Referenced by CoInternetParseIUri().
◆ parse_scheme()
|
static |
Definition at line 977 of file uri.c.
977 {
978 /* First check to see if the uri could implicitly be a file path. */
984
986 } else {
987 /* Windows does not consider anything that can implicitly be a file
988 * path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set...
989 */
990 TRACE("(%p %p %lx): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n",
993 }
995 /* No scheme was found, this means it could be:
996 * a) an implicit Wildcard scheme
997 * b) a relative URI
998 * c) an invalid URI.
999 */
1004
1009 } else {
1012 }
1013 }
1014
1018
1021
1024}
static BOOL parse_scheme_name(const WCHAR **ptr, parse_data *data, DWORD extras)
Definition: uri.c:900
Referenced by parse_uri(), and validate_scheme_name().
◆ parse_scheme_name()
|
static |
Definition at line 900 of file uri.c.
900 {
902
904 data->scheme_len = 0;
905
908 /* Might have found a wildcard scheme. If it is the next
909 * char has to be a ':' for it to be a valid URI
910 */
911 ++(*ptr);
912 break;
915 break;
916
917 (*ptr)++;
918 }
919
922
923 /* Schemes must end with a ':' */
927 }
928
931
932 ++(*ptr);
934}
Referenced by parse_scheme().
◆ parse_scheme_type()
|
static |
Definition at line 939 of file uri.c.
939 {
940 /* If there's scheme data then see if it's a recognized scheme. */
943
946 /* Has to be a case insensitive compare. */
950 }
951 }
952 }
953
954 /* If we get here it means it's not a recognized scheme. */
958 /* Relative URI's have no scheme. */
961 } else {
962 /* Should never reach here! what happened... */
965 }
966}
static const struct @612 recognized_schemes[]
Referenced by parse_scheme().
◆ parse_site()
|
static |
Definition at line 6840 of file uri.c.
6841{
6845
6848 *result_len = 0;
6850 }
6851
6852 *result_len = len;
6855
6858 *result_len = 0;
6860 }
6861
6864
6866}
Referenced by CoInternetParseIUri().
◆ parse_uri()
|
static |
Definition at line 1798 of file uri.c.
1798 {
1801
1803 pptr = &ptr;
1804
1806
1809
1812
1815
1818
1821}
static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1659
static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:977
static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1761
static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1722
Referenced by combine_uri(), CreateUri(), Marshal_UnmarshalInterface(), and PersistStream_Load().
◆ parse_url_from_path()
|
static |
Definition at line 6782 of file uri.c.
6784{
6788
6791 *result_len = 0;
6793 }
6794
6795 *result_len = len;
6798
6801 *result_len = 0;
6803 }
6804
6807
6809}
Referenced by CoInternetParseIUri().
◆ parse_userinfo()
|
static |
Definition at line 1101 of file uri.c.
1101 {
1103
1106 return;
1107 }
1108
1110 ++(*ptr);
1114 data->username_len = 0;
1116 return;
1117 }
1118 }
1119
1123 data->username_len = 0;
1125 data->password_len = 0;
1126
1128 return;
1129 }
1130
1134
1138
1139 ++(*ptr);
1140}
static BOOL parse_password(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1054
static BOOL parse_username(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1026
Referenced by parse_authority().
◆ parse_username()
|
static |
Definition at line 1026 of file uri.c.
1026 {
1028
1036 }
1037 } else
1038 continue;
1040 break;
1045 }
1046
1047 ++(*ptr);
1048 }
1049
1052}
Referenced by parse_userinfo(), and validate_username().
◆ pct_encode_val()
Definition at line 461 of file uri.c.
461 {
465}
Referenced by canonicalize_fragment(), canonicalize_password(), canonicalize_path_hierarchical(), canonicalize_path_opaque(), canonicalize_query(), canonicalize_reg_name(), canonicalize_username(), and parse_canonicalize().
◆ persist_stream_add_strprop()
|
inlinestatic |
◆ persist_stream_save()
|
inlinestatic |
Definition at line 4938 of file uri.c.
4939{
4941
4943
4945 data->fields_no = 1;
4948 }
4951 return;
4952
4954 data->fields_no++;
4957 }
4958
4960 data->fields_no++;
4964 else
4967 }
4968
4970 data->fields_no++;
4974 }
4975
4977 data->fields_no++;
4980 } else if(marshal) {
4982 data->fields_no++;
4984 }
4985
4987 data->fields_no++;
4994 }
4995
4997 data->fields_no++;
5000 }
5001
5003 data->fields_no++;
5006 }
5007
5009 data->fields_no++;
5013 else
5016 }
5017}
static BYTE * persist_stream_add_strprop(Uri *This, BYTE *p, DWORD type, DWORD len, WCHAR *data)
Definition: uri.c:4925
Referenced by Marshal_MarshalInterface(), and PersistStream_Save().
◆ PersistStream_AddRef()
|
static |
◆ PersistStream_GetClassID()
|
static |
◆ PersistStream_GetSizeMax()
|
static |
◆ PersistStream_IsDirty()
|
static |
◆ PersistStream_Load()
|
static |
Definition at line 4860 of file uri.c.
4861{
4864 parse_data parse;
4867
4869
4872 if(!pStm)
4874
4885 }
4886
4890 }
4891
4896 }
4897
4902 }
4906
4911 This->create_flags = 0;
4913 }
4914
4918 This->create_flags = 0;
4920 }
4921
4923}
◆ PersistStream_QueryInterface()
|
static |
◆ PersistStream_Release()
|
static |
◆ PersistStream_Save()
|
static |
◆ pre_process_uri()
◆ remove_dot_segments()
Definition at line 595 of file uri.c.
595 {
600
602 /* Move the first path segment in the input buffer to the end of
603 * the output buffer, and any subsequent characters up to, including
604 * the next "/" character (if any) or the end of the input buffer.
605 */
609 break;
611
614 break;
615
616 /* Handle ending "/." */
618 ++in;
619 break;
620 }
621
622 /* Handle "/./" */
624 in += 2;
625 continue;
626 }
627
628 /* If we don't have "/../" or ending "/.." */
630 break;
631
632 /* Find the slash preceding out pointer and move out pointer to it */
634 --out;
637 ++out;
638 in += 2;
640 ++in;
641 }
642 }
643
648}
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383
Referenced by canonicalize_path_hierarchical(), canonicalize_path_opaque(), combine_uri(), and parse_canonicalize().
◆ reset_builder()
|
static |
Definition at line 3115 of file uri.c.
3115 {
3119
3122 builder->fragment_len = 0;
3123
3126 builder->host_len = 0;
3127
3130 builder->password_len = 0;
3131
3134 builder->path_len = 0;
3135
3138 builder->query_len = 0;
3139
3142 builder->scheme_len = 0;
3143
3146 builder->username_len = 0;
3147
3149 builder->port = 0;
3150 builder->modified_props = 0;
3151}
Referenced by UriBuilder_SetIUri().
◆ set_builder_component()
|
static |
Definition at line 3082 of file uri.c.
3084{
3085 free(*component);
3086
3087 if(!new_value) {
3088 *component = NULL;
3089 *component_len = 0;
3090 } else {
3094
3096 add_prefix = TRUE;
3098 } else
3100
3101 if(!(*component))
3103
3104 if(add_prefix)
3106
3109 }
3110
3111 *flags |= success_flag;
3113}
Referenced by UriBuilder_RemoveProperties(), UriBuilder_SetFragment(), UriBuilder_SetHost(), UriBuilder_SetPassword(), UriBuilder_SetPath(), UriBuilder_SetQuery(), UriBuilder_SetSchemeName(), and UriBuilder_SetUserName().
◆ setup_port()
|
static |
Definition at line 3304 of file uri.c.
3304 {
3309 }
3313 }
3314
3317}
Referenced by validate_components().
◆ ui2ipv4()
◆ ui2str()
Definition at line 727 of file uri.c.
Referenced by canonicalize_port(), and generate_raw_uri().
◆ Uri_AddRef()
◆ Uri_Construct()
Definition at line 5338 of file uri.c.
5339{
5341
5343
5344 *ppobj = ret;
5347
5352 ret->ref = 1;
5353
5354 *ppobj = &ret->IUri_iface;
5356}
static const IUriBuilderFactoryVtbl UriBuilderFactoryVtbl
Definition: uri.c:4801
Referenced by build_uri(), combine_uri(), and CreateUri().
◆ Uri_GetAbsoluteUri()
◆ Uri_GetAuthority()
◆ Uri_GetDisplayUri()
◆ Uri_GetDomain()
◆ Uri_GetExtension()
◆ Uri_GetFragment()
◆ Uri_GetHost()
◆ Uri_GetHostType()
◆ Uri_GetPassword()
◆ Uri_GetPath()
◆ Uri_GetPathAndQuery()
◆ Uri_GetPort()
◆ Uri_GetProperties()
Definition at line 4630 of file uri.c.
4631{
4634
4637 if(!pdwProperties)
4639
4640 /* All URIs have these. */
4641 *pdwProperties = Uri_HAS_DISPLAY_URI|Uri_HAS_RAW_URI|Uri_HAS_SCHEME|Uri_HAS_HOST_TYPE;
4642
4644 *pdwProperties |= Uri_HAS_ABSOLUTE_URI;
4645
4647 *pdwProperties |= Uri_HAS_SCHEME_NAME;
4648
4650 *pdwProperties |= Uri_HAS_AUTHORITY;
4652 *pdwProperties |= Uri_HAS_USER_INFO;
4654 *pdwProperties |= Uri_HAS_USER_NAME;
4655 }
4657 *pdwProperties |= Uri_HAS_PASSWORD;
4659 *pdwProperties |= Uri_HAS_HOST;
4661 *pdwProperties |= Uri_HAS_DOMAIN;
4662 }
4663
4665 *pdwProperties |= Uri_HAS_PORT;
4667 *pdwProperties |= Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY;
4669 *pdwProperties |= Uri_HAS_QUERY|Uri_HAS_PATH_AND_QUERY;
4670
4672 *pdwProperties |= Uri_HAS_EXTENSION;
4673
4675 *pdwProperties |= Uri_HAS_FRAGMENT;
4676
4678}
◆ Uri_GetPropertyBSTR()
|
static |
Definition at line 3877 of file uri.c.
3878{
3881 TRACE("(%p %s)->(%d %p %lx)\n", This, debugstr_w(This->canon_uri), uriProp, pbstrProperty, dwFlags);
3882
3885 if(!pbstrProperty)
3887
3888 if(uriProp > Uri_PROPERTY_STRING_LAST) {
3889 /* It only returns S_FALSE for the ZONE property... */
3890 if(uriProp == Uri_PROPERTY_ZONE) {
3892 if(!(*pbstrProperty))
3895 }
3896
3897 *pbstrProperty = NULL;
3899 }
3900
3902 && dwFlags != Uri_DISPLAY_IDN_HOST)
3904
3906 || (dwFlags == Uri_PUNYCODE_IDN_HOST && uriProp != Uri_PROPERTY_ABSOLUTE_URI
3907 && uriProp != Uri_PROPERTY_DOMAIN && uriProp != Uri_PROPERTY_HOST)
3908 || (dwFlags == Uri_DISPLAY_IDN_HOST && uriProp != Uri_PROPERTY_ABSOLUTE_URI
3909 && uriProp != Uri_PROPERTY_DOMAIN && uriProp != Uri_PROPERTY_HOST))
3911
3912 switch(uriProp) {
3913 case Uri_PROPERTY_ABSOLUTE_URI:
3917 }
3918 /* Uri_PUNYCODE_IDN_HOST doesn't remove user info containing only "@" and ":@" */
3919 else if (dwFlags == Uri_PUNYCODE_IDN_HOST && This->host_type == Uri_HOST_IDN && This->host_start > -1) {
3920 unsigned int punycode_host_len;
3921
3925 if(*pbstrProperty) {
3927 IdnToAscii(0, This->canon_uri+This->host_start, This->host_len, *pbstrProperty+This->host_start, punycode_host_len);
3931 }
3932 } else {
3935 /* Don't include the '@' after the userinfo component. */
3938 if(*pbstrProperty) {
3939 /* Copy everything before it. */
3941
3942 /* And everything after it. */
3945 }
3947 /* Don't include the ":@" */
3950 if(*pbstrProperty) {
3954 }
3955 } else {
3958 }
3959 } else {
3962 }
3963 }
3964
3965 if(!(*pbstrProperty))
3967
3968 break;
3969 case Uri_PROPERTY_AUTHORITY:
3973 /* Don't include the port in the authority component. */
3975 else
3976 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->authority_start, This->authority_len);
3978 } else {
3981 }
3982
3983 if(!(*pbstrProperty))
3985
3986 break;
3987 case Uri_PROPERTY_DISPLAY_URI:
3988 /* The Display URI contains everything except for the userinfo for known
3989 * scheme types.
3990 */
3993
3994 /* Skip fragment if Uri_DISPLAY_NO_FRAGMENT is specified */
3997
3999
4000 if(*pbstrProperty) {
4001 /* Copy everything before the userinfo over. */
4003
4004 /* Copy everything after the userinfo over. */
4008 }
4009 } else {
4011
4012 /* Skip fragment if Uri_DISPLAY_NO_FRAGMENT is specified */
4015
4017 }
4018
4019 if(!(*pbstrProperty))
4021 else
4023
4024 break;
4025 case Uri_PROPERTY_DOMAIN:
4028 unsigned int punycode_length;
4029
4033 if (*pbstrProperty)
4036 } else {
4039 }
4040
4042 } else {
4045 }
4046
4047 if(!(*pbstrProperty))
4049
4050 break;
4051 case Uri_PROPERTY_EXTENSION:
4056 } else {
4059 }
4060
4061 if(!(*pbstrProperty))
4063
4064 break;
4065 case Uri_PROPERTY_FRAGMENT:
4069 } else {
4072 }
4073
4074 if(!(*pbstrProperty))
4076
4077 break;
4078 case Uri_PROPERTY_HOST:
4080 /* The '[' and ']' aren't included for IPv6 addresses. */
4084 unsigned int punycode_length;
4085
4088 if (*pbstrProperty)
4089 IdnToAscii(0, This->canon_uri+This->host_start, This->host_len, *pbstrProperty, punycode_length);
4090 }
4091 else
4093
4095 } else {
4098 }
4099
4100 if(!(*pbstrProperty))
4102
4103 break;
4104 case Uri_PROPERTY_PASSWORD:
4106 *pbstrProperty = SysAllocStringLen(
4110 } else {
4113 }
4114
4115 if(!(*pbstrProperty))
4117
4118 break;
4119 case Uri_PROPERTY_PATH:
4123 } else {
4126 }
4127
4128 if(!(*pbstrProperty))
4130
4131 break;
4132 case Uri_PROPERTY_PATH_AND_QUERY:
4134 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start, This->path_len+This->query_len);
4139 } else {
4142 }
4143
4144 if(!(*pbstrProperty))
4146
4147 break;
4148 case Uri_PROPERTY_QUERY:
4152 } else {
4155 }
4156
4157 if(!(*pbstrProperty))
4159
4160 break;
4161 case Uri_PROPERTY_RAW_URI:
4163 if(!(*pbstrProperty))
4165 else
4167 break;
4168 case Uri_PROPERTY_SCHEME_NAME:
4172 } else {
4175 }
4176
4177 if(!(*pbstrProperty))
4179
4180 break;
4181 case Uri_PROPERTY_USER_INFO:
4185 } else {
4188 }
4189
4190 if(!(*pbstrProperty))
4192
4193 break;
4194 case Uri_PROPERTY_USER_NAME:
4196 /* If userinfo_split is set, that means a password exists
4197 * so the username is only from userinfo_start to userinfo_split.
4198 */
4200 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->userinfo_start, This->userinfo_split);
4202 } else {
4203 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->userinfo_start, This->userinfo_len);
4205 }
4206 } else {
4209 }
4210
4211 if(!(*pbstrProperty))
4213
4214 break;
4215 default:
4218 }
4219
4221}
INT WINAPI IdnToAscii(DWORD dwFlags, LPCWSTR lpUnicodeCharStr, INT cchUnicodeChar, LPWSTR lpASCIICharStr, INT cchASCIIChar)
Definition: IdnToAscii.c:249
◆ Uri_GetPropertyDWORD()
|
static |
Definition at line 4384 of file uri.c.
4385{
4388
4389 TRACE("(%p %s)->(%d %p %lx)\n", This, debugstr_w(This->canon_uri), uriProp, pcchProperty, dwFlags);
4390
4393 if(!pcchProperty)
4395
4396 /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
4397 * From what I can tell, instead of checking which URLZONE the URI belongs to it
4398 * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies to the GetZone
4399 * function.
4400 */
4401 if(uriProp == Uri_PROPERTY_ZONE) {
4402 *pcchProperty = URLZONE_INVALID;
4404 }
4405
4406 if(uriProp < Uri_PROPERTY_DWORD_START) {
4407 *pcchProperty = 0;
4409 }
4410
4411 switch(uriProp) {
4412 case Uri_PROPERTY_HOST_TYPE:
4413 *pcchProperty = This->host_type;
4415 break;
4416 case Uri_PROPERTY_PORT:
4418 *pcchProperty = 0;
4420 } else {
4421 *pcchProperty = This->port;
4423 }
4424
4425 break;
4426 case Uri_PROPERTY_SCHEME:
4427 *pcchProperty = This->scheme_type;
4429 break;
4430 default:
4433 }
4434
4436}
◆ Uri_GetPropertyLength()
|
static |
Definition at line 4223 of file uri.c.
4224{
4227 TRACE("(%p %s)->(%d %p %lx)\n", This, debugstr_w(This->canon_uri), uriProp, pcchProperty, dwFlags);
4228
4231 if(!pcchProperty)
4233
4234 /* Can only return a length for a property if it's a string. */
4235 if(uriProp > Uri_PROPERTY_STRING_LAST)
4237
4239 && dwFlags != Uri_DISPLAY_IDN_HOST) {
4240 *pcchProperty = 0;
4242 }
4243
4244 switch(uriProp) {
4245 case Uri_PROPERTY_ABSOLUTE_URI:
4247 *pcchProperty = 0;
4249 }
4250 /* Uri_PUNYCODE_IDN_HOST doesn't remove user info containing only "@" and ":@" */
4251 else if(dwFlags == Uri_PUNYCODE_IDN_HOST && This->host_type == Uri_HOST_IDN && This->host_start > -1) {
4252 unsigned int punycode_host_len = IdnToAscii(0, This->canon_uri+This->host_start, This->host_len, NULL, 0);
4255 } else {
4258 /* Don't include the '@' in the length. */
4259 *pcchProperty = This->canon_len-1;
4261 This->userinfo_split == 0)
4262 /* Don't include the ":@" in the length. */
4263 *pcchProperty = This->canon_len-2;
4264 else
4265 *pcchProperty = This->canon_len;
4266 } else
4267 *pcchProperty = This->canon_len;
4268
4270 }
4271
4272 break;
4273 case Uri_PROPERTY_AUTHORITY:
4277 /* Only count up until the port in the authority. */
4278 *pcchProperty = This->port_offset;
4279 else
4280 *pcchProperty = This->authority_len;
4282 break;
4283 case Uri_PROPERTY_DISPLAY_URI:
4286 else
4287 *pcchProperty = This->canon_len;
4288
4290 *pcchProperty -= This->fragment_len;
4291
4293 break;
4294 case Uri_PROPERTY_DOMAIN:
4297 *pcchProperty = IdnToAscii(0, This->canon_uri+This->host_start+This->domain_offset, This->host_len-This->domain_offset, NULL, 0);
4298 else
4300 }
4301 else
4302 *pcchProperty = 0;
4303
4305 break;
4306 case Uri_PROPERTY_EXTENSION:
4310 } else {
4311 *pcchProperty = 0;
4313 }
4314
4315 break;
4316 case Uri_PROPERTY_FRAGMENT:
4317 *pcchProperty = This->fragment_len;
4319 break;
4320 case Uri_PROPERTY_HOST:
4321 *pcchProperty = This->host_len;
4322
4323 /* '[' and ']' aren't included in the length. */
4325 *pcchProperty -= 2;
4326 else if(dwFlags == Uri_PUNYCODE_IDN_HOST && This->host_type == Uri_HOST_IDN && This->host_start > -1)
4328
4330 break;
4331 case Uri_PROPERTY_PASSWORD:
4334 break;
4335 case Uri_PROPERTY_PATH:
4336 *pcchProperty = This->path_len;
4338 break;
4339 case Uri_PROPERTY_PATH_AND_QUERY:
4342 break;
4343 case Uri_PROPERTY_QUERY:
4344 *pcchProperty = This->query_len;
4346 break;
4347 case Uri_PROPERTY_RAW_URI:
4350 break;
4351 case Uri_PROPERTY_SCHEME_NAME:
4352 *pcchProperty = This->scheme_len;
4354 break;
4355 case Uri_PROPERTY_USER_INFO:
4356 *pcchProperty = This->userinfo_len;
4358 break;
4359 case Uri_PROPERTY_USER_NAME:
4363 else
4365 break;
4366 default:
4369 }
4370
4372 && ((dwFlags == Uri_DISPLAY_NO_FRAGMENT && uriProp != Uri_PROPERTY_DISPLAY_URI)
4373 || (dwFlags == Uri_PUNYCODE_IDN_HOST && uriProp != Uri_PROPERTY_ABSOLUTE_URI
4374 && uriProp != Uri_PROPERTY_DOMAIN && uriProp != Uri_PROPERTY_HOST)
4375 || (dwFlags == Uri_DISPLAY_IDN_HOST && uriProp != Uri_PROPERTY_ABSOLUTE_URI
4376 && uriProp != Uri_PROPERTY_DOMAIN && uriProp != Uri_PROPERTY_HOST))) {
4377 *pcchProperty = 0;
4379 }
4380
4382}
◆ Uri_GetQuery()
◆ Uri_GetRawUri()
◆ Uri_GetScheme()
◆ Uri_GetSchemeName()
◆ Uri_GetUserInfo()
◆ Uri_GetUserName()
◆ Uri_GetZone()
◆ Uri_HasProperty()
|
static |
Definition at line 4438 of file uri.c.
4439{
4441
4443
4444 if(!pfHasProperty)
4446
4447 switch(uriProp) {
4448 case Uri_PROPERTY_ABSOLUTE_URI:
4450 break;
4451 case Uri_PROPERTY_AUTHORITY:
4452 *pfHasProperty = This->authority_start > -1;
4453 break;
4454 case Uri_PROPERTY_DISPLAY_URI:
4455 *pfHasProperty = TRUE;
4456 break;
4457 case Uri_PROPERTY_DOMAIN:
4458 *pfHasProperty = This->domain_offset > -1;
4459 break;
4460 case Uri_PROPERTY_EXTENSION:
4461 *pfHasProperty = This->extension_offset > -1;
4462 break;
4463 case Uri_PROPERTY_FRAGMENT:
4464 *pfHasProperty = This->fragment_start > -1;
4465 break;
4466 case Uri_PROPERTY_HOST:
4467 *pfHasProperty = This->host_start > -1;
4468 break;
4469 case Uri_PROPERTY_PASSWORD:
4470 *pfHasProperty = This->userinfo_split > -1;
4471 break;
4472 case Uri_PROPERTY_PATH:
4473 *pfHasProperty = This->path_start > -1;
4474 break;
4475 case Uri_PROPERTY_PATH_AND_QUERY:
4477 break;
4478 case Uri_PROPERTY_QUERY:
4479 *pfHasProperty = This->query_start > -1;
4480 break;
4481 case Uri_PROPERTY_RAW_URI:
4482 *pfHasProperty = TRUE;
4483 break;
4484 case Uri_PROPERTY_SCHEME_NAME:
4485 *pfHasProperty = This->scheme_start > -1;
4486 break;
4487 case Uri_PROPERTY_USER_INFO:
4488 *pfHasProperty = This->userinfo_start > -1;
4489 break;
4490 case Uri_PROPERTY_USER_NAME:
4492 *pfHasProperty = FALSE;
4493 else
4494 *pfHasProperty = This->userinfo_start > -1;
4495 break;
4496 case Uri_PROPERTY_HOST_TYPE:
4497 *pfHasProperty = TRUE;
4498 break;
4499 case Uri_PROPERTY_PORT:
4500 *pfHasProperty = This->has_port;
4501 break;
4502 case Uri_PROPERTY_SCHEME:
4503 *pfHasProperty = TRUE;
4504 break;
4505 case Uri_PROPERTY_ZONE:
4506 *pfHasProperty = FALSE;
4507 break;
4508 default:
4511 }
4512
4514}
◆ Uri_IsEqual()
Definition at line 4680 of file uri.c.
4681{
4684
4686
4689 if(!pfEqual)
4691
4692 if(!pUri) {
4693 *pfEqual = FALSE;
4694
4695 /* For some reason Windows returns S_OK here... */
4697 }
4698
4699 /* Try to convert it to a Uri (allows for a more simple comparison). */
4703 }
4704
4707}
static HRESULT compare_uris(const Uri *a, const Uri *b, BOOL *ret)
Definition: uri.c:3526
◆ Uri_QueryInterface()
◆ Uri_Release()
◆ UriBuilder_AddRef()
|
static |
Definition at line 5615 of file uri.c.
5616{
5619
5621
5623}
static UriBuilder * impl_from_IUriBuilder(IUriBuilder *iface)
Definition: uri.c:5590
◆ UriBuilder_CreateUri()
|
static |
Definition at line 5662 of file uri.c.
5667{
5670 TRACE("(%p)->(0x%08lx %ld %Id %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, dwReserved, ppIUri);
5671
5672 if(dwCreateFlags == -1)
5674 else
5676
5678 FIXME("(%p)->(0x%08lx %ld %Id %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, dwReserved, ppIUri);
5680}
static HRESULT build_uri(const UriBuilder *builder, IUri **uri, DWORD create_flags, DWORD use_orig_flags, DWORD encoding_mask)
Definition: uri.c:5532
◆ UriBuilder_CreateUriSimple()
|
static |
◆ UriBuilder_CreateUriWithFlags()
|
static |
Definition at line 5682 of file uri.c.
5688{
5692 dwAllowEncodingPropertyMask, dwReserved, ppIUri);
5693
5697 dwAllowEncodingPropertyMask, dwReserved, ppIUri);
5699}
◆ UriBuilder_GetFragment()
|
static |
Definition at line 5751 of file uri.c.
5752{
5755
5757 return get_builder_component(&This->fragment, &This->fragment_len, NULL, 0, ppwzFragment, pcchFragment);
5758 else
5759 return get_builder_component(&This->fragment, &This->fragment_len, This->uri->canon_uri+This->uri->fragment_start,
5760 This->uri->fragment_len, ppwzFragment, pcchFragment);
5761}
static HRESULT get_builder_component(LPWSTR *component, DWORD *component_len, LPCWSTR source, DWORD source_len, LPCWSTR *output, DWORD *output_len)
Definition: uri.c:3043
◆ UriBuilder_GetHost()
|
static |
Definition at line 5763 of file uri.c.
5764{
5767
5770 else {
5772 /* Don't include the '[' and ']' around the address. */
5773 return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start+1,
5774 This->uri->host_len-2, ppwzHost, pcchHost);
5775 else
5776 return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start,
5777 This->uri->host_len, ppwzHost, pcchHost);
5778 }
5779}
◆ UriBuilder_GetIUri()
|
static |
◆ UriBuilder_GetPassword()
|
static |
Definition at line 5781 of file uri.c.
5782{
5785
5787 return get_builder_component(&This->password, &This->password_len, NULL, 0, ppwzPassword, pcchPassword);
5788 else {
5789 const WCHAR *start = This->uri->canon_uri+This->uri->userinfo_start+This->uri->userinfo_split+1;
5791 return get_builder_component(&This->password, &This->password_len, start, len, ppwzPassword, pcchPassword);
5792 }
5793}
◆ UriBuilder_GetPath()
|
static |
◆ UriBuilder_GetPort()
|
static |
◆ UriBuilder_GetQuery()
|
static |
◆ UriBuilder_GetSchemeName()
|
static |
Definition at line 5840 of file uri.c.
5841{
5844
5846 return get_builder_component(&This->scheme, &This->scheme_len, NULL, 0, ppwzSchemeName, pcchSchemeName);
5847 else
5848 return get_builder_component(&This->scheme, &This->scheme_len, This->uri->canon_uri+This->uri->scheme_start,
5849 This->uri->scheme_len, ppwzSchemeName, pcchSchemeName);
5850}
◆ UriBuilder_GetUserName()
|
static |
Definition at line 5852 of file uri.c.
5853{
5856
5858 This->modified_props & Uri_HAS_USER_NAME)
5859 return get_builder_component(&This->username, &This->username_len, NULL, 0, ppwzUserName, pcchUserName);
5860 else {
5862
5863 /* Check if there's a password in the userinfo section. */
5865 /* Don't include the password. */
5867 This->uri->userinfo_split, ppwzUserName, pcchUserName);
5868 else
5870 This->uri->userinfo_len, ppwzUserName, pcchUserName);
5871 }
5872}
◆ UriBuilder_HasBeenModified()
|
static |
◆ UriBuilder_QueryInterface()
|
static |
◆ UriBuilder_Release()
|
static |
◆ UriBuilder_RemoveProperties()
|
static |
Definition at line 5951 of file uri.c.
5952{
5953 const DWORD accepted_flags = Uri_HAS_AUTHORITY|Uri_HAS_DOMAIN|Uri_HAS_EXTENSION|Uri_HAS_FRAGMENT|Uri_HAS_HOST|
5954 Uri_HAS_PASSWORD|Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY|Uri_HAS_QUERY|
5955 Uri_HAS_USER_INFO|Uri_HAS_USER_NAME;
5956
5959
5960 if(dwPropertyMask & ~accepted_flags)
5962
5963 if(dwPropertyMask & Uri_HAS_FRAGMENT)
5965
5966 /* Even though you can't set the host name to NULL or an
5967 * empty string, you can still remove it... for some reason.
5968 */
5969 if(dwPropertyMask & Uri_HAS_HOST)
5971 &This->modified_props, Uri_HAS_HOST);
5972
5973 if(dwPropertyMask & Uri_HAS_PASSWORD)
5975
5976 if(dwPropertyMask & Uri_HAS_PATH)
5978
5979 if(dwPropertyMask & Uri_HAS_PORT)
5981
5982 if(dwPropertyMask & Uri_HAS_QUERY)
5984
5985 if(dwPropertyMask & Uri_HAS_USER_NAME)
5987
5989}
static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5903
static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
Definition: uri.c:5911
static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5895
static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5874
static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5943
static HRESULT set_builder_component(LPWSTR *component, DWORD *component_len, LPCWSTR new_value, WCHAR prefix, DWORD *flags, DWORD success_flag)
Definition: uri.c:3082
static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5922
◆ UriBuilder_SetFragment()
|
static |
Definition at line 5874 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetHost()
|
static |
◆ UriBuilder_SetIUri()
|
static |
Definition at line 5719 of file uri.c.
5720{
5723
5724 if(pIUri) {
5726
5728 /* Only reset the builder if its Uri isn't the same as
5729 * the Uri passed to the function.
5730 */
5733
5737
5738 IUri_AddRef(pIUri);
5739 }
5740 } else {
5743 }
5745 /* Only reset the builder if its Uri isn't NULL. */
5747
5749}
◆ UriBuilder_SetPassword()
|
static |
Definition at line 5895 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetPath()
|
static |
Definition at line 5903 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetPort()
|
static |
◆ UriBuilder_SetQuery()
|
static |
Definition at line 5922 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetSchemeName()
|
static |
◆ UriBuilder_SetUserName()
|
static |
Definition at line 5943 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilderFactory_AddRef()
|
static |
Definition at line 4751 of file uri.c.
4752{
4755}
static Uri * impl_from_IUriBuilderFactory(IUriBuilderFactory *iface)
Definition: uri.c:4740
◆ UriBuilderFactory_CreateInitializedIUriBuilder()
|
static |
Definition at line 4782 of file uri.c.
4786{
4789
4790 if(!ppIUriBuilder)
4792
4794 *ppIUriBuilder = NULL;
4796 }
4797
4799}
HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
Definition: uri.c:6035
◆ UriBuilderFactory_CreateIUriBuilder()
|
static |
◆ UriBuilderFactory_QueryInterface()
|
static |
◆ UriBuilderFactory_Release()
|
static |
◆ validate_components()
|
static |
Definition at line 3423 of file uri.c.
3423 {
3425
3427
3429
3433
3434 /* Extra validation for file schemes. */
3441 }
3442 }
3443
3447
3451
3453
3454 /* The URI is opaque if it doesn't have an authority component. */
3458 else
3460
3464
3468
3472
3474
3476}
static HRESULT validate_path(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3319
static HRESULT validate_userinfo(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3258
static HRESULT validate_query(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3361
static void setup_port(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3304
static HRESULT validate_fragment(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3392
static HRESULT validate_host(const UriBuilder *builder, parse_data *data)
Definition: uri.c:3272
static HRESULT validate_scheme_name(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3153
Referenced by build_uri().
◆ validate_fragment()
|
static |
Definition at line 3392 of file uri.c.
3392 {
3395 DWORD expected_len;
3396
3399 expected_len = builder->fragment_len;
3404 }
3405
3408 pptr = &ptr;
3409
3413 else {
3415 debugstr_wn(component, expected_len));
3417 }
3418 }
3419
3421}
Referenced by validate_components().
◆ validate_host()
|
static |
Definition at line 3272 of file uri.c.
3272 {
3275 DWORD expected_len;
3276
3279 expected_len = builder->host_len;
3280 } else if(!(builder->modified_props & Uri_HAS_HOST) && builder->uri && builder->uri->host_start > -1) {
3283 } else
3285
3289 pptr = &ptr;
3290
3294 else {
3296 debugstr_wn(component, expected_len));
3298 }
3299 }
3300
3302}
Referenced by validate_components().
◆ validate_password()
|
static |
Definition at line 3223 of file uri.c.
3223 {
3226 DWORD expected_len;
3227
3230 expected_len = builder->password_len;
3233 data->password = builder->uri->canon_uri+builder->uri->userinfo_start+builder->uri->userinfo_split+1;
3236 } else {
3238 expected_len = 0;
3239 }
3240
3243 pptr = &ptr;
3245 data->password_len == expected_len)
3248 else {
3250 debugstr_wn(component, expected_len));
3252 }
3253 }
3254
3256}
Referenced by validate_userinfo().
◆ validate_path()
|
static |
Definition at line 3319 of file uri.c.
3319 {
3323 DWORD expected_len;
3326
3329 expected_len = builder->path_len;
3334 } else {
3336 check_len = FALSE;
3337 expected_len = -1;
3338 }
3339
3340 component = ptr;
3341 pptr = &ptr;
3342
3343 /* How the path is validated depends on what type of
3344 * URI it is.
3345 */
3348
3351 debugstr_wn(component, expected_len) );
3353 }
3354
3357
3359}
Referenced by validate_components().
◆ validate_query()
|
static |
Definition at line 3361 of file uri.c.
3361 {
3364 DWORD expected_len;
3365
3368 expected_len = builder->query_len;
3373 }
3374
3377 pptr = &ptr;
3378
3382 else {
3384 debugstr_wn(component, expected_len));
3386 }
3387 }
3388
3390}
Referenced by validate_components().
◆ validate_scheme_name()
|
static |
Definition at line 3153 of file uri.c.
3153 {
3157 DWORD expected_len;
3158
3161 expected_len = builder->scheme_len;
3165 } else {
3167 expected_len = 0;
3168 }
3169
3170 component = ptr;
3171 pptr = &ptr;
3173 data->scheme_len == expected_len) {
3177 } else {
3179 debugstr_wn(component, expected_len));
3181 }
3182
3184}
Referenced by validate_components().
◆ validate_userinfo()
|
static |
Definition at line 3258 of file uri.c.
3258 {
3260
3264
3268
3270}
static HRESULT validate_password(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3223
static HRESULT validate_username(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3186
Referenced by validate_components().
◆ validate_username()
|
static |
Definition at line 3186 of file uri.c.
3186 {
3189 DWORD expected_len;
3190
3193 expected_len = builder->username_len;
3196 /* Just use the username from the base Uri. */
3201 } else {
3203 expected_len = 0;
3204 }
3205
3208 pptr = &ptr;
3210 data->username_len == expected_len)
3213 else {
3215 debugstr_wn(component, expected_len));
3217 }
3218 }
3219
3221}
Referenced by validate_userinfo().
◆ WINE_DEFAULT_DEBUG_CHANNEL()
| WINE_DEFAULT_DEBUG_CHANNEL | ( | urlmon | ) |
Variable Documentation
◆
| const struct { ... } default_ports[] |
Initial value:
= {
{URL_SCHEME_FTP, 21},
{URL_SCHEME_HTTP, 80},
{URL_SCHEME_GOPHER, 70},
{URL_SCHEME_NNTP, 119},
{URL_SCHEME_TELNET, 23},
{URL_SCHEME_WAIS, 210},
{URL_SCHEME_HTTPS, 443},
}
Referenced by canonicalize_hierpart(), canonicalize_port(), generate_raw_uri(), and is_default_port().
◆ hexDigits
Definition at line 176 of file uri.c.
Referenced by pct_encode_val().
◆ IID_IUriObj
Definition at line 52 of file uri.c.
Referenced by get_uri_obj(), and Uri_QueryInterface().
◆ MarshalVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI Marshal_ReleaseMarshalData(IMarshal *iface, IStream *pStm)
Definition: uri.c:5287
static HRESULT WINAPI Marshal_MarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
Definition: uri.c:5176
static HRESULT WINAPI Marshal_GetUnmarshalClass(IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
Definition: uri.c:5125
static HRESULT WINAPI Marshal_DisconnectObject(IMarshal *iface, DWORD dwReserved)
Definition: uri.c:5319
static HRESULT WINAPI Marshal_GetMarshalSizeMax(IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
Definition: uri.c:5147
static HRESULT WINAPI Marshal_UnmarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void **ppv)
Definition: uri.c:5229
static HRESULT WINAPI Marshal_QueryInterface(IMarshal *iface, REFIID riid, void **ppvObject)
Definition: uri.c:5107
Definition at line 5326 of file uri.c.
Referenced by Uri_Construct().
◆ PersistStreamVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI PersistStream_IsDirty(IPersistStream *iface)
Definition: uri.c:4844
static HRESULT WINAPI PersistStream_Load(IPersistStream *iface, IStream *pStm)
Definition: uri.c:4860
static ULONG WINAPI PersistStream_Release(IPersistStream *iface)
Definition: uri.c:4826
static HRESULT WINAPI PersistStream_Save(IPersistStream *iface, IStream *pStm, BOOL fClearDirty)
Definition: uri.c:5019
static HRESULT WINAPI PersistStream_GetClassID(IPersistStream *iface, CLSID *pClassID)
Definition: uri.c:4832
static ULONG WINAPI PersistStream_AddRef(IPersistStream *iface)
Definition: uri.c:4820
static HRESULT WINAPI PersistStream_GetSizeMax(IPersistStream *iface, ULARGE_INTEGER *pcbSize)
Definition: uri.c:5046
static HRESULT WINAPI PersistStream_QueryInterface(IPersistStream *iface, REFIID riid, void **ppvObject)
Definition: uri.c:4814
Definition at line 5091 of file uri.c.
Referenced by Uri_Construct().
◆ port
| USHORT port |
Definition at line 210 of file uri.c.
Referenced by __rpc_taddr2uaddr_af(), __rpc_uaddr2taddr_af(), __rpcb_findaddr_timed(), _open_simple_request(), _test_completion(), _test_no_queued_completion(), _test_queued_completion(), add_host_header(), AddrStrToAddr(), AtlCreateTargetDC(), BindToEphemeralPortNumber(), calc_url_length(), CheckRemoteDebuggerPresent(), client(), compare_RtlIpv6StringToAddressExW(), connections_on_initdialog(), create_async_resolve(), create_listening_pcb(), create_system_ports_list(), CreateIoCompletionPort(), dmusic_remove_port(), EISA_ELCR_Read(), FileToURL(), FTPDecodeURL(), fw_ports_Add(), get_server(), get_url_length(), GetAddress(), GetQueuedCompletionStatus(), GetQueuedCompletionStatusEx(), getservbyport(), handle_redirect(), hookup(), HTMLLocation_get_port(), HTTP_HttpOpenRequestW(), HttpProtocol_open_request(), IDirectMusic8Impl_CreatePort(), init(), init_TCPIP_provider(), InstallSubdevice(), InternetCheckConnectionW(), ipv6_string_to_address(), is_default_port(), LibTCPBind(), LibTCPConnect(), LibTCPGetHostName(), LibTCPGetPeerName(), main(), make_listening_socket(), midi_in_port_create(), midi_out_port_create(), midi_port_create(), MIDIMAP_LoadSettingsDefault(), MIDIMAP_LoadSettingsScheme(), mswBufferAppendBlob_Servent(), netconn_resolve(), networkconfig_GetProxyPort(), networkconfig_SetProxyPort(), nfs41_server_resolve(), nsProtocolHandler_AllowPort(), nsURI_GetPort(), open_async_request(), open_connection(), open_read_test_request(), open_socket_request(), OpenControlConnection(), pagesetup_set_devnames(), parse_port(), pmap_getport(), pmap_set(), PostQueuedCompletionStatus(), promise_timing(), resolve_hostname(), rpc_broadcast_exp(), rpcrt4_http_internet_connect(), SBind(), Server(), server(), set_server_for_hostname(), SNewDatagramServer(), SNewStreamServer(), SpoolX(), START_TEST(), StartDevice(), synth_port_create(), TCPSocketObject::TCPSocketObject(), test_accept_encoding(), test_async_cancel_on_handle_close(), test_async_read(), test_bad_header(), test_basic_auth_credentials_cached_manual(), test_basic_auth_credentials_different(), test_basic_auth_credentials_end_session(), test_basic_auth_credentials_manual(), test_basic_auth_credentials_reuse(), test_basic_authentication(), test_basic_request(), test_BuildCommDCB(), test_cache_control_verb(), test_cache_read_gzipped(), test_chunked_request(), test_completion(), test_completion_port_scheduling(), test_CompletionPort(), test_conn_close(), test_connection_break(), test_connection_cache(), test_connection_closing(), test_connection_header(), test_connection_info(), test_cookie_header(), test_cookies(), test_DeviceCapabilities(), test_EnumAddressTypes(), test_exit_process_async(), test_file_completion_information(), test_GetAddrInfoW(), test_GetExtendedTcpTable_owner(), test_GetExtendedUdpTable_owner(), test_head_request(), test_header_handling_order(), test_header_override(), test_http_read(), test_http_status(), test_HttpQueryInfo(), test_HttpSendRequestW(), test_invalid_response_headers(), test_IUriBuilder_GetInvalidArgs(), test_IUriBuilder_Misc(), test_IWinHttpRequest(), test_job_list_attribute(), test_large_content(), test_large_data_authentication(), test_long_url(), test_multi_authentication(), test_multiple_reads(), test_nested_jobs_child(), test_no_cache(), test_no_content(), test_no_headers(), test_not_modified(), test_options(), test_ParseNetworkString(), test_passport_auth(), test_persistent_connection(), test_ports_client(), test_post_completion(), test_premature_disconnect(), test_PrintDlgA(), test_proxy_direct(), test_proxy_indirect(), test_recv(), test_redirect(), test_remove_dot_segments(), test_request_content_length(), test_request_path_escapes(), test_response_without_headers(), test_RtlIpv4AddressToStringEx(), test_RtlIpv4StringToAddressEx(), test_RtlIpv6AddressToStringEx(), test_RtlIpv6StringToAddressEx(), test_successive_HttpSendRequest(), test_udp_create_test_packet(), test_websocket(), test_WinHttpGetProxyForUrl(), USBPORT_CreateDevice(), uses_default_port(), WinHttpConnect(), WSPStringToAddress(), xmlParse3986Port(), and xmlURIEscape().
◆
| const struct { ... } recognized_schemes[] |
Initial value:
= {
}
Referenced by parse_scheme_type().
◆
| const struct { ... } recognized_tlds[] |
◆ scheme
| URL_SCHEME scheme |
Definition at line 180 of file uri.c.
Referenced by canonicalize_port(), is_default_port(), and is_path_delim().
◆ scheme_name
| WCHAR scheme_name[16] |
Definition at line 181 of file uri.c.
Referenced by parse_scheme_type().
◆ tld_name
| WCHAR tld_name[4] |
Definition at line 225 of file uri.c.
Referenced by find_domain_name().
◆ UriBuilderFactoryVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI UriBuilderFactory_QueryInterface(IUriBuilderFactory *iface, REFIID riid, void **ppv)
Definition: uri.c:4745
static ULONG WINAPI UriBuilderFactory_AddRef(IUriBuilderFactory *iface)
Definition: uri.c:4751
static ULONG WINAPI UriBuilderFactory_Release(IUriBuilderFactory *iface)
Definition: uri.c:4757
static HRESULT WINAPI UriBuilderFactory_CreateInitializedIUriBuilder(IUriBuilderFactory *iface, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
Definition: uri.c:4782
static HRESULT WINAPI UriBuilderFactory_CreateIUriBuilder(IUriBuilderFactory *iface, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
Definition: uri.c:4763
Definition at line 4801 of file uri.c.
Referenced by Uri_Construct().
◆ UriBuilderVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri)
Definition: uri.c:5701
static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
Definition: uri.c:5807
static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
Definition: uri.c:5852
static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask)
Definition: uri.c:5951
static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
Definition: uri.c:5828
static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface, DWORD dwCreateFlags, DWORD dwUriBuilderFlags, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
Definition: uri.c:5682
static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
Definition: uri.c:5795
static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri)
Definition: uri.c:5719
static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv)
Definition: uri.c:5595
static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5930
static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface, DWORD dwCreateFlags, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
Definition: uri.c:5662
static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
Definition: uri.c:5751
static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
Definition: uri.c:5647
static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
Definition: uri.c:5840
static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified)
Definition: uri.c:5991
static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:5882
static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
Definition: uri.c:5781
static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
Definition: uri.c:5763
Definition at line 6003 of file uri.c.
Referenced by CreateIUriBuilder().
◆ UriVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery)
Definition: uri.c:4570
static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
Definition: uri.c:4384
static HRESULT WINAPI Uri_GetAbsoluteUri(IUri *iface, BSTR *pstrAbsoluteUri)
Definition: uri.c:4516
static HRESULT WINAPI Uri_HasProperty(IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty)
Definition: uri.c:4438
static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties)
Definition: uri.c:4630
static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual)
Definition: uri.c:4680
static HRESULT WINAPI Uri_GetDomain(IUri *iface, BSTR *pstrDomain)
Definition: uri.c:4534
static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BSTR *pbstrProperty, DWORD dwFlags)
Definition: uri.c:3877
static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
Definition: uri.c:4223
static HRESULT WINAPI Uri_GetUserInfo(IUri *iface, BSTR *pstrUserInfo)
Definition: uri.c:4594
static HRESULT WINAPI Uri_GetPassword(IUri *iface, BSTR *pstrPassword)
Definition: uri.c:4558
static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme)
Definition: uri.c:4618
static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName)
Definition: uri.c:4600
static HRESULT WINAPI Uri_GetExtension(IUri *iface, BSTR *pstrExtension)
Definition: uri.c:4540
static HRESULT WINAPI Uri_GetFragment(IUri *iface, BSTR *pstrFragment)
Definition: uri.c:4546
static HRESULT WINAPI Uri_GetAuthority(IUri *iface, BSTR *pstrAuthority)
Definition: uri.c:4522
static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri)
Definition: uri.c:4582
static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName)
Definition: uri.c:4588
static HRESULT WINAPI Uri_QueryInterface(IUri *iface, REFIID riid, void **ppv)
Definition: uri.c:3821
static HRESULT WINAPI Uri_GetDisplayUri(IUri *iface, BSTR *pstrDisplayUri)
Definition: uri.c:4528
static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType)
Definition: uri.c:4606
Definition at line 4709 of file uri.c.
Referenced by Uri_Construct().
