#include <limits.h>#include <wchar.h>#include "urlmon_main.h"#include "wine/debug.h"#include "shlwapi.h"#include "strsafe.h"
Include dependency graph for uri.c:
Go to the source code of this file.
Classes | |
| struct | Uri |
| struct | UriBuilder |
| struct | h16 |
| struct | ipv6_address |
| 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 398 of file uri.c.
398 {
400 *flags |= Uri_CREATE_CANONICALIZE;
402 *flags |= Uri_CREATE_DECODE_EXTRA_INFO;
404 *flags |= Uri_CREATE_CRACK_UNKNOWN_SCHEMES;
406 *flags |= Uri_CREATE_PRE_PROCESS_HTML_URI;
408 *flags |= Uri_CREATE_NO_IE_SETTINGS;
409}
Referenced by build_uri(), combine_uri(), and CreateUri().
◆ build_uri()
|
static |
Definition at line 5850 of file uri.c.
5852{
5856
5859
5863 }
5864
5865 /* Decide what flags should be used when creating the Uri. */
5868 else {
5872 }
5873
5874 /* Set the default flags if they don't cause a conflict. */
5876 }
5877
5878 /* Return the base IUri if no changes have been made and the create_flags match. */
5881 IUri_AddRef(*uri);
5883 }
5884
5889 }
5890
5895 }
5896
5899 IUri_Release(&ret->IUri_iface);
5902 }
5903
5906}
static BOOL has_invalid_flag_combination(DWORD flags)
Definition: uri.c:387
static HRESULT generate_uri(const UriBuilder *builder, const parse_data *data, Uri *uri, DWORD flags)
Definition: uri.c:4186
static HRESULT validate_components(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3820
Definition: mshtmhst.idl:286
Definition: uri.c:152
Referenced by UriBuilder_CreateUri(), UriBuilder_CreateUriSimple(), and UriBuilder_CreateUriWithFlags().
◆ canonicalize_authority()
|
static |
Definition at line 2794 of file uri.c.
2794 {
2796 uri->authority_len = 0;
2797
2800
2803
2806
2809 else
2810 uri->authority_start = -1;
2811
2813}
static BOOL canonicalize_userinfo(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2259
static BOOL canonicalize_host(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2674
static BOOL canonicalize_port(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2722
Referenced by canonicalize_hierpart().
◆ canonicalize_fragment()
|
static |
Definition at line 3238 of file uri.c.
3238 {
3241
3243 uri->fragment_start = -1;
3244 uri->fragment_len = 0;
3246 }
3247
3249
3256 if(!computeOnly)
3258 ++uri->canon_len;
3259
3260 ptr += 2;
3261 continue;
3262 }
3263 }
3266 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
3267 if(!computeOnly)
3269 uri->canon_len += 3;
3270 continue;
3271 }
3272 }
3273
3274 if(!computeOnly)
3276 ++uri->canon_len;
3277 }
3278
3280
3281 if(!computeOnly)
3284 uri->fragment_len);
3286}
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_hierpart()
|
static |
Definition at line 3097 of file uri.c.
3097 {
3099 /* "//" is only added for non-wildcard scheme types.
3100 *
3101 * A "//" is only added to a relative URI if it has a
3102 * host or port component (this only happens if a IUriBuilder
3103 * is generating an IUri).
3104 */
3109
3110 if(!computeOnly) {
3112
3115 }
3116 uri->canon_len += 2;
3117 }
3118
3121
3125 } else {
3126 if(!computeOnly)
3128 uri->path_len = canonicalize_path_hierarchical(data->path, data->path_len, data->scheme_type, data->host_len != 0,
3132 uri->path_start = -1;
3133 }
3134 } else {
3135 /* Opaque URI's don't have an authority. */
3137 uri->userinfo_len = 0;
3138 uri->host_start = -1;
3139 uri->host_len = 0;
3140 uri->host_type = Uri_HOST_UNKNOWN;
3142 uri->authority_start = -1;
3143 uri->authority_len = 0;
3144 uri->domain_offset = -1;
3145 uri->port_offset = -1;
3146
3149
3150 /* Absolute URIs aren't displayed for known scheme types
3151 * which should be hierarchical URIs.
3152 */
3154
3155 /* Windows also sets the port for these (if they have one). */
3160 break;
3161 }
3162 }
3163 }
3164
3167 }
3168
3170 /* Finding file extensions happens for both types of URIs. */
3172 else
3173 uri->extension_offset = -1;
3174
3176}
static BOOL canonicalize_authority(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2794
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:2844
static const struct @562 default_ports[]
static BOOL canonicalize_path_opaque(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2989
static INT find_file_extension(const WCHAR *path, DWORD path_len)
Definition: uri.c:686
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 2674 of file uri.c.
2674 {
2675 uri->host_start = -1;
2676 uri->host_len = 0;
2677 uri->domain_offset = -1;
2678
2681 case Uri_HOST_DNS:
2682 uri->host_type = Uri_HOST_DNS;
2685
2686 break;
2687 case Uri_HOST_IPV4:
2688 uri->host_type = Uri_HOST_IPV4;
2691
2692 break;
2693 case Uri_HOST_IPV6:
2696
2697 uri->host_type = Uri_HOST_IPV6;
2698 break;
2699 case Uri_HOST_UNKNOWN:
2702
2703 /* Nothing happens to unknown host types. */
2704 if(!computeOnly)
2708 }
2709
2710 uri->host_type = Uri_HOST_UNKNOWN;
2711 break;
2712 default:
2716 }
2717 }
2718
2720}
static BOOL canonicalize_ipv4address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2453
static BOOL canonicalize_reg_name(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2306
static BOOL canonicalize_ipv6address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2562
Referenced by canonicalize_authority().
◆ canonicalize_implicit_ipv4address()
|
static |
Definition at line 2404 of file uri.c.
2404 {
2406
2408 /* For unknown scheme types Windows doesn't convert
2409 * the value into an IP address, but it still considers
2410 * it an IPv4 address.
2411 */
2413 if(!computeOnly)
2416 } else {
2417 if(!computeOnly)
2419 else
2421 }
2422
2424 uri->host_type = Uri_HOST_IPV4;
2425
2426 if(!computeOnly)
2430 uri->host_len);
2431
2433}
Referenced by canonicalize_ipv4address().
◆ canonicalize_ipv4address()
|
static |
Definition at line 2453 of file uri.c.
2453 {
2456 else {
2458
2459 /* Windows only normalizes for known scheme types. */
2461 /* parse_data contains a partial or full IPv4 address, so normalize it. */
2464
2467 /* Can ignore leading zeros if:
2468 * 1) It isn't the last digit of the octet.
2469 * 2) i+1 != data->host_len
2470 * 3) i+1 != '.'
2471 */
2472 if(octetDigitCount == 2 ||
2475 if(!computeOnly)
2477 ++uri->canon_len;
2479 }
2481 if(!computeOnly)
2483 ++uri->canon_len;
2484
2485 octetDigitCount = 0;
2486 octetHasDigit = FALSE;
2487 ++octetCount;
2488 } else {
2489 if(!computeOnly)
2491 ++uri->canon_len;
2492
2493 ++octetDigitCount;
2494 octetHasDigit = TRUE;
2495 }
2496 }
2497
2498 /* Make sure the canonicalized IP address has 4 dec-octets.
2499 * If doesn't add "0" ones until there is 4;
2500 */
2501 for( ; octetCount < 3; ++octetCount) {
2502 if(!computeOnly) {
2505 }
2506
2507 uri->canon_len += 2;
2508 }
2509 } else {
2510 /* Windows doesn't normalize addresses in unknown schemes. */
2511 if(!computeOnly)
2514 }
2515
2517 if(!computeOnly)
2521 uri->host_len);
2522 }
2523
2525}
static BOOL canonicalize_implicit_ipv4address(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2404
Referenced by canonicalize_host().
◆ canonicalize_ipv6address()
|
static |
Definition at line 2562 of file uri.c.
2563 {
2565
2567 if(!computeOnly)
2570 } else {
2572 INT elision_start;
2574
2579 }
2580
2581 if(!computeOnly)
2583 ++uri->canon_len;
2584
2585 /* Find where the elision should occur (if any). */
2587
2589 computeOnly, elision_start, elision_len);
2590
2593 i < elision_start+elision_len);
2595 data->ipv6_address.h16_count == 0);
2596
2598 if(!computeOnly) {
2601 }
2602 uri->canon_len += 2;
2603 }
2604
2605 /* We can ignore the current component if we're in the elision. */
2606 if(in_elision)
2607 continue;
2608
2609 /* We only add a ':' if we're not at i == 0, or when we're at
2610 * the very end of elision range since the ':' colon was handled
2611 * earlier. Otherwise we would end up with ":::" after elision.
2612 */
2614 if(!computeOnly)
2616 ++uri->canon_len;
2617 }
2618
2619 if(do_ipv4) {
2622
2623 /* Combine the two parts of the IPv4 address values. */
2625 val <<= 16;
2627
2628 if(!computeOnly)
2630 else
2632
2634 ++i;
2635 } else {
2636 /* Write a regular h16 component to the URI. */
2637
2638 /* Short circuit for the trivial case. */
2640 if(!computeOnly)
2642 ++uri->canon_len;
2643 } else {
2645
2646 if(!computeOnly)
2649 else {
2650 WCHAR tmp[5];
2652 }
2653 }
2654 }
2655 }
2656
2657 /* Add the closing ']'. */
2658 if(!computeOnly)
2660 ++uri->canon_len;
2661 }
2662
2664
2665 if(!computeOnly)
2668 uri->host_len);
2669
2671}
static BOOL ipv6_to_number(const ipv6_address *address, USHORT number[8])
Definition: uri.c:888
static void compute_elision_location(const ipv6_address *address, const USHORT values[8], INT *index, DWORD *count)
Definition: uri.c:716
Referenced by canonicalize_host().
◆ canonicalize_password()
|
static |
Definition at line 2193 of file uri.c.
2193 {
2195
2197 uri->userinfo_split = -1;
2199 }
2200
2202 /* Has a password, but, doesn't have a username. */
2204
2206
2207 /* Add the ':' to the userinfo component. */
2208 if(!computeOnly)
2210 ++uri->canon_len;
2211
2214 /* Only decode % encoded values for known scheme types. */
2216 /* See if the value really needs decoding. */
2219 if(!computeOnly)
2221
2222 ++uri->canon_len;
2223
2224 /* Move pass the hex characters. */
2225 ptr += 2;
2226 continue;
2227 }
2228 }
2230 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2231 * is NOT set.
2232 */
2234 if(!computeOnly)
2236
2237 uri->canon_len += 3;
2238 continue;
2239 }
2240 }
2241
2242 if(!computeOnly)
2243 /* Nothing special, so just copy the character over. */
2245 ++uri->canon_len;
2246 }
2247
2249}
Referenced by canonicalize_userinfo().
◆ canonicalize_path_hierarchical()
|
static |
Definition at line 2844 of file uri.c.
2845 {
2852
2854 return 0;
2855
2857
2858 if(is_file && !has_host) {
2859 /* Check if a '/' needs to be appended for the file scheme. */
2861 if(ret_path)
2863 len++;
2864 escape_pct = TRUE;
2867 /* Copy the extra '/' over. */
2868 if(ret_path)
2870 len++;
2871 }
2872 ++ptr;
2873 }
2874
2876 if(ret_path) {
2878 /* If there's a '|' after the drive letter, convert it to a ':'. */
2880 }
2881 ptr += 2;
2882 len += 2;
2883 }
2884 }
2885
2887 /* Prepend a '/' to the path if it doesn't have one. */
2888 if(ret_path)
2890 len++;
2891 }
2892
2895
2899
2900 /* Check if the % represents a valid encoded char, or if it needs encoding. */
2901 BOOL force_encode = !check_pct_encoded(&tmp) && is_file && !(flags&Uri_CREATE_FILE_USE_DOS_PATH);
2903
2904 if(force_encode || escape_pct) {
2905 /* Escape the percent sign in the file URI. */
2906 if(ret_path)
2908 len += 3;
2909 do_default_action = FALSE;
2913 if(ret_path)
2915 len++;
2916
2917 ptr += 2;
2918 continue;
2919 }
2921 /* Convert the '/' back to a '\\'. */
2922 if(ret_path)
2924 len++;
2925 do_default_action = FALSE;
2928 /* Convert '\\' into a '/'. */
2929 if(ret_path)
2931 len++;
2932 do_default_action = FALSE;
2933 }
2934 } else if(known_scheme && !is_res && is_ascii(*ptr) && !is_unreserved(*ptr) && !is_reserved(*ptr) &&
2935 (!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) || is_file)) {
2937 /* Escape the forbidden character. */
2938 if(ret_path)
2940 len += 3;
2941 do_default_action = FALSE;
2942 }
2943 }
2944
2945 if(do_default_action) {
2946 if(ret_path)
2948 len++;
2949 }
2950 }
2951
2952 /* Removing the dot segments only happens when it's not in
2953 * computeOnly mode and it's not a wildcard scheme. File schemes
2954 * with USE_DOS_PATH set don't get dot segments removed.
2955 */
2957 scheme_type != URL_SCHEME_WILDCARD) {
2959 /* Remove the dot segments (if any) and reset everything to the new
2960 * correct length.
2961 */
2963 }
2964 }
2965
2966 if(ret_path)
2969}
static DWORD remove_dot_segments(WCHAR *path, DWORD path_len)
Definition: uri.c:630
Definition: wbemprox_private.h:188
Referenced by canonicalize_hierpart(), and compare_file_paths().
◆ canonicalize_path_opaque()
|
static |
Definition at line 2989 of file uri.c.
2989 {
2994
2996 uri->path_start = -1;
2997 uri->path_len = 0;
2999 }
3000
3002
3003 if(is_mk){
3004 /* hijack this flag for SCHEME_MK to tell the function when to start
3005 * converting slashes */
3006 flags |= Uri_CREATE_FILE_USE_DOS_PATH;
3007 }
3008
3009 /* For javascript: URIs, simply copy path part without any canonicalization */
3011 if(!computeOnly)
3016 }
3017
3018 /* Windows doesn't allow a "//" to appear after the scheme
3019 * of a URI, if it's an opaque URI.
3020 */
3022 /* So it inserts a "/." before the "//" if it exists. */
3023 if(!computeOnly) {
3026 }
3027
3028 uri->canon_len += 2;
3029 }
3030
3033
3036
3038 if(!computeOnly)
3040 ++uri->canon_len;
3041
3042 ptr += 2;
3043 continue;
3044 }
3046 if(!computeOnly)
3048 ++uri->canon_len;
3049 do_default_action = FALSE;
3052 /* Convert to a '/'. */
3053 if(!computeOnly)
3055 ++uri->canon_len;
3056 do_default_action = FALSE;
3057 }
3058 } else if(is_mk && *ptr == ':' && ptr + 1 < data->path + data->path_len && *(ptr + 1) == ':') {
3059 flags &= ~Uri_CREATE_FILE_USE_DOS_PATH;
3061 !(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
3063 if(!computeOnly)
3065 uri->canon_len += 3;
3066 do_default_action = FALSE;
3067 }
3068 }
3069
3070 if(do_default_action) {
3071 if(!computeOnly)
3073 ++uri->canon_len;
3074 }
3075 }
3076
3081 }
3082
3084
3085 if(!computeOnly)
3086 TRACE("(%p %p %x %d): Canonicalized opaque URI path %s len=%d\n", data, uri, flags, computeOnly,
3089}
Referenced by canonicalize_hierpart().
◆ canonicalize_port()
|
static |
Definition at line 2722 of file uri.c.
2722 {
2724 USHORT default_port = 0;
2726
2727 uri->port_offset = -1;
2728
2729 /* Check if the scheme has a default port. */
2732 has_default_port = TRUE;
2734 break;
2735 }
2736 }
2737
2739
2740 /* Possible cases:
2741 * 1) Has a port which is the default port.
2742 * 2) Has a port (not the default).
2743 * 3) Doesn't have a port, but, scheme has a default port.
2744 * 4) No port.
2745 */
2747 /* If it's the default port and this flag isn't set, don't do anything. */
2750 if(!computeOnly)
2752 ++uri->canon_len;
2753
2755 /* Copy the original port over. */
2756 if(!computeOnly)
2759 } else {
2760 if(!computeOnly)
2762 else
2764 }
2765 }
2766
2767 uri->port = default_port;
2770 if(!computeOnly)
2772 ++uri->canon_len;
2773
2775 /* Copy the original over without changes. */
2776 if(!computeOnly)
2779 } else {
2780 if(!computeOnly)
2782 else
2784 }
2785
2787 } else if(has_default_port)
2788 uri->port = default_port;
2789
2791}
Referenced by canonicalize_authority().
◆ canonicalize_query()
|
static |
Definition at line 3188 of file uri.c.
3188 {
3191
3193 uri->query_start = -1;
3194 uri->query_len = 0;
3196 }
3197
3199
3206 if(!computeOnly)
3208 ++uri->canon_len;
3209
3210 ptr += 2;
3211 continue;
3212 }
3213 }
3216 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
3217 if(!computeOnly)
3219 uri->canon_len += 3;
3220 continue;
3221 }
3222 }
3223
3224 if(!computeOnly)
3226 ++uri->canon_len;
3227 }
3228
3230
3231 if(!computeOnly)
3234 uri->query_len);
3236}
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_reg_name()
|
static |
Definition at line 2306 of file uri.c.
2307 {
2309 {'l','o','c','a','l','h','o','s','t',0};
2312
2316 uri->host_start = -1;
2317 uri->host_len = 0;
2318 uri->host_type = Uri_HOST_UNKNOWN;
2320 }
2321 }
2322
2324 if(!computeOnly) {
2327 }
2328 uri->canon_len += 2;
2330 }
2331
2333
2338 /* If NO_CANONICALIZE is not set, then windows lower cases the
2339 * decoded value.
2340 */
2342 if(!computeOnly)
2344 } else {
2345 if(!computeOnly)
2347 }
2348 ++uri->canon_len;
2349
2350 /* Skip past the % encoded character. */
2351 ptr += 2;
2352 continue;
2353 } else {
2354 /* Just copy the % over. */
2355 if(!computeOnly)
2357 ++uri->canon_len;
2358 }
2360 /* Only unknown scheme types could have made it here with a '\\' in the host name. */
2361 if(!computeOnly)
2363 ++uri->canon_len;
2366 if(!computeOnly) {
2368
2369 /* The percent encoded value gets lower cased also. */
2373 }
2374 }
2375
2376 uri->canon_len += 3;
2377 } else {
2378 if(!computeOnly) {
2381 else
2383 }
2384
2385 ++uri->canon_len;
2386 }
2387 }
2388
2390
2391 if(!computeOnly)
2394 uri->host_len);
2395
2396 if(!computeOnly)
2398 &(uri->domain_offset));
2399
2401}
void find_domain_name(const WCHAR *host, DWORD host_len, INT *domain_start)
Definition: uri.c:520
Referenced by canonicalize_host().
◆ canonicalize_scheme()
|
static |
Definition at line 3289 of file uri.c.
3289 {
3290 uri->scheme_start = -1;
3291 uri->scheme_len = 0;
3292
3294 /* The only type of URI that doesn't have to have a scheme is a relative
3295 * URI.
3296 */
3301 }
3302 } else {
3303 if(!computeOnly) {
3306
3308 /* Scheme name must be lower case after canonicalization. */
3310 }
3311
3314
3317 }
3318
3319 /* This happens in both computation modes. */
3322 }
3324}
Referenced by canonicalize_uri(), and compute_canonicalized_length().
◆ canonicalize_uri()
|
static |
Definition at line 3373 of file uri.c.
3373 {
3375
3378
3379 TRACE("(%p %p %x): beginning to canonicalize URI %s.\n", data, uri, flags, debugstr_w(data->uri));
3380
3381 /* First try to compute the length of the URI. */
3387 }
3388
3392
3397 }
3399
3403 }
3404
3409 }
3410
3415 }
3416
3417 /* There's a possibility we didn't use all the space we allocated
3418 * earlier.
3419 */
3421 /* This happens if the URI is hierarchical and dot
3422 * segments were removed from its path.
3423 */
3425 if(!tmp)
3427
3428 uri->canon_uri = tmp;
3430 }
3431
3433 TRACE("(%p %p %x): finished canonicalizing the URI. uri=%s\n", data, uri, flags, debugstr_w(uri->canon_uri));
3434
3436}
static int compute_canonicalized_length(const parse_data *data, DWORD flags)
Definition: uri.c:3332
static BOOL canonicalize_fragment(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:3238
static BOOL canonicalize_scheme(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:3289
static BOOL canonicalize_query(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:3188
static BOOL canonicalize_hierpart(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:3097
Referenced by combine_uri(), CreateUri(), generate_uri(), Marshal_UnmarshalInterface(), and PersistStream_Load().
◆ canonicalize_userinfo()
|
static |
Definition at line 2259 of file uri.c.
2259 {
2261 uri->userinfo_len = 0;
2262
2264 /* URI doesn't have userinfo, so nothing to do here. */
2266
2269
2272
2274 if(!computeOnly)
2275 TRACE("(%p %p %x %d): Canonicalized userinfo, userinfo_start=%d, userinfo=%s, userinfo_split=%d userinfo_len=%d.\n",
2276 data, uri, flags, computeOnly, uri->userinfo_start, debugstr_wn(uri->canon_uri + uri->userinfo_start, uri->userinfo_len),
2278
2279 /* Now insert the '@' after the userinfo. */
2280 if(!computeOnly)
2282 ++uri->canon_len;
2283
2285}
static BOOL canonicalize_username(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2145
static BOOL canonicalize_password(const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
Definition: uri.c:2193
Referenced by canonicalize_authority().
◆ canonicalize_username()
|
static |
Definition at line 2145 of file uri.c.
2145 {
2147
2149 uri->userinfo_start = -1;
2151 }
2152
2156 /* Only decode % encoded values for known scheme types. */
2158 /* See if the value really needs decoding. */
2161 if(!computeOnly)
2163
2164 ++uri->canon_len;
2165
2166 /* Move pass the hex characters. */
2167 ptr += 2;
2168 continue;
2169 }
2170 }
2172 /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
2173 * is NOT set.
2174 */
2176 if(!computeOnly)
2178
2179 uri->canon_len += 3;
2180 continue;
2181 }
2182 }
2183
2184 if(!computeOnly)
2185 /* Nothing special, so just copy the character over. */
2187 ++uri->canon_len;
2188 }
2189
2191}
Referenced by canonicalize_userinfo().
◆ check_dec_octet()
Definition at line 964 of file uri.c.
964 {
966
967 c1 = *ptr;
968 /* A dec-octet must be at least 1 digit long. */
969 if(*c1 < '0' || *c1 > '9')
971
972 ++(*ptr);
973
974 c2 = *ptr;
975 /* Since the 1-digit requirement was met, it doesn't
976 * matter if this is a DIGIT value, it's considered a
977 * dec-octet.
978 */
979 if(*c2 < '0' || *c2 > '9')
981
982 ++(*ptr);
983
984 c3 = *ptr;
985 /* Same explanation as above. */
986 if(*c3 < '0' || *c3 > '9')
988
989 /* Anything > 255 isn't a valid IP dec-octet. */
990 if(*c1 >= '2' && *c2 >= '5' && *c3 >= '5') {
991 *ptr = c1;
993 }
994
995 ++(*ptr);
997}
Referenced by check_ipv4address().
◆ check_hierarchical()
Definition at line 293 of file uri.c.
293 {
295
298
299 ++(*ptr);
303 }
304
305 ++(*ptr);
307}
Referenced by is_hierarchical_uri(), and parse_canonicalize().
◆ check_implicit_ipv4()
Definition at line 1005 of file uri.c.
Referenced by parse_ipv4address().
◆ check_ipv4address()
Definition at line 1037 of file uri.c.
1037 {
1039
1043 }
1044
1048 }
1049
1050 ++(*ptr);
1054 }
1055
1060 } else
1062 }
1063
1064 ++(*ptr);
1068 }
1069
1074 } else
1076 }
1077
1078 ++(*ptr);
1082 }
1083
1084 /* Found a four digit ip address. */
1086}
Referenced by parse_ipv4address(), and parse_ipv6address().
◆ check_pct_encoded()
Definition at line 936 of file uri.c.
936 {
938
941
942 ++(*ptr);
946 }
947
948 ++(*ptr);
952 }
953
954 ++(*ptr);
956}
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 6716 of file uri.c.
6718{
6722 TRACE("(%p %p %x %p %x)\n", pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
6723
6724 if(!ppCombinedUri)
6726
6727 if(!pBaseUri || !pRelativeUri) {
6728 *ppCombinedUri = NULL;
6730 }
6731
6732 relative = get_uri_obj(pRelativeUri);
6735 *ppCombinedUri = NULL;
6739 }
6740
6744 DWORD result_len = 0;
6745
6746 hr = IInternetProtocolInfo_CombineUrl(info, base->canon_uri, relative->canon_uri, dwCombineFlags,
6748 IInternetProtocolInfo_Release(info);
6753 }
6754 }
6755
6757}
HRESULT WINAPI CreateUri(LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
Definition: uri.c:5700
static HRESULT combine_uri(Uri *base, Uri *relative, DWORD flags, IUri **result, DWORD extras)
Definition: uri.c:6450
Definition: urlmon.idl:911
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
Definition: uninitialized_test.cpp:81
Definition: notification.c:61
Referenced by CreateURLMonikerEx2().
◆ CoInternetCombineUrlEx()
| HRESULT WINAPI CoInternetCombineUrlEx | ( | IUri * | pBaseUri, |
| LPCWSTR | pwzRelativeUrl, | ||
| DWORD | dwCombineFlags, | ||
| IUri ** | ppCombinedUri, | ||
| DWORD_PTR | dwReserved | ||
| ) |
Definition at line 6762 of file uri.c.
6764{
6765 IUri *relative;
6769
6772
6773 if(!ppCombinedUri)
6775
6776 if(!pwzRelativeUrl) {
6777 *ppCombinedUri = NULL;
6779 }
6780
6781 if(!pBaseUri) {
6782 *ppCombinedUri = NULL;
6784 }
6785
6788 *ppCombinedUri = NULL;
6789 FIXME("(%p %s %x %p %x) Unknown IUri's not supported yet.\n", pBaseUri, debugstr_w(pwzRelativeUrl),
6792 }
6793
6797 DWORD result_len = 0;
6798
6801 IInternetProtocolInfo_Release(info);
6806 }
6807 }
6808
6809 hr = CreateUri(pwzRelativeUrl, Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, &relative);
6811 *ppCombinedUri = NULL;
6813 }
6814
6815 hr = combine_uri(base, get_uri_obj(relative), dwCombineFlags, ppCombinedUri, COMBINE_URI_FORCE_FLAG_USE);
6816
6817 IUri_Release(relative);
6819}
Definition: urlmon.idl:1711
Referenced by check_codebase(), combine_url(), create_relative_uri(), CreateURLMonikerEx(), 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 7247 of file uri.c.
7250{
7254
7257
7258 if(!pcchResult)
7260
7261 if(!pwzResult || !pIUri) {
7262 *pcchResult = 0;
7264 }
7265
7267 *pcchResult = 0;
7271 }
7272
7276 pwzResult, cchResult, pcchResult, 0);
7277 IInternetProtocolInfo_Release(info);
7279 }
7280
7281 switch(ParseAction) {
7282 case PARSE_CANONICALIZE:
7284 break;
7285 case PARSE_FRIENDLY:
7287 break;
7288 case PARSE_ROOTDOCUMENT:
7290 break;
7291 case PARSE_DOCUMENT:
7293 break;
7294 case PARSE_PATH_FROM_URL:
7296 break;
7297 case PARSE_URL_FROM_PATH:
7299 break;
7300 case PARSE_SCHEMA:
7302 break;
7303 case PARSE_SITE:
7305 break;
7306 case PARSE_DOMAIN:
7308 break;
7309 case PARSE_LOCATION:
7310 case PARSE_ANCHOR:
7312 break;
7313 case PARSE_SECURITY_URL:
7314 case PARSE_MIME:
7315 case PARSE_SERVER:
7316 case PARSE_SECURITY_DOMAIN:
7317 *pcchResult = 0;
7319 break;
7320 default:
7321 *pcchResult = 0;
7325 }
7326
7328}
static HRESULT parse_site(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7160
static HRESULT parse_domain(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7188
static HRESULT parse_anchor(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7216
static HRESULT parse_path_from_url(const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7044
static HRESULT parse_rootdocument(const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6960
static HRESULT parse_canonicalize(const Uri *uri, DWORD flags, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6821
static HRESULT parse_document(const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7011
static HRESULT parse_url_from_path(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7102
static HRESULT parse_schema(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:7131
static HRESULT parse_friendly(IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
Definition: uri.c:6932
Referenced by FileProtocol_StartEx(), and nsFileURL_GetFile().
◆ combine_uri()
|
static |
Definition at line 6450 of file uri.c.
6450 {
6456
6458
6459 /* Base case is when the relative Uri has a scheme name,
6460 * if it does, then 'result' will contain the same data
6461 * as the relative Uri.
6462 */
6468 }
6469
6471
6476 }
6477
6480 create_flags |= Uri_CREATE_NO_CANONICALIZE;
6482 create_flags |= Uri_CREATE_NO_DECODE_EXTRA_INFO;
6483 }
6484
6488 IUri_Release(&ret->IUri_iface);
6491 }
6492
6495
6497 } else {
6499 DWORD raw_flags = 0;
6500
6505 } else {
6508 create_flags |= Uri_CREATE_ALLOW_RELATIVE;
6509 }
6510
6512 proc_uri = relative;
6513
6517 data.username_len = (proc_uri->userinfo_split > -1) ? proc_uri->userinfo_split : proc_uri->userinfo_len;
6518 }
6519
6523 }
6524
6529 }
6530
6534 }
6537
6543 /* Just set the path as a '/' if the base didn't have
6544 * one and if it's a hierarchical URI.
6545 */
6548 data.path_len = 1;
6549 }
6550
6552 proc_uri = relative;
6553
6557 }
6558 } else {
6561
6562 /* There's two possibilities on what will happen to the path component
6563 * of the result IUri. First, if the relative path begins with a '/'
6564 * then the resulting path will just be the relative path. Second, if
6565 * relative path doesn't begin with a '/' then the base path and relative
6566 * path are merged together.
6567 */
6568 if(relative->path_len && *(relative->canon_uri+relative->path_start) == '/' && data.scheme_type != URL_SCHEME_MK) {
6571
6572 /* If the relative IUri's path starts with a '/', then we
6573 * don't use the base IUri's path. Unless the base IUri
6574 * is a file URI, in which case it uses the drive path of
6575 * the base IUri (if it has any) in the new path.
6576 */
6580 path_len += 3;
6581 copy_drive_path = TRUE;
6582 }
6583 }
6584
6586
6591 }
6592
6593 tmp = path;
6594
6595 /* Copy the base paths, drive path over. */
6596 if(copy_drive_path) {
6598 tmp += 3;
6599 }
6600
6603 } else {
6604 /* Merge the base path with the relative path. */
6611 }
6612
6613 /* If the resulting IUri is a file URI, the drive path isn't
6614 * reduced out when the dot segments are removed.
6615 */
6618 path_offset = 2;
6620 path_offset = 1;
6621 }
6622 }
6623
6624 /* Check if the dot segments need to be removed from the path. */
6628
6631 if(!tmp) {
6635 }
6636
6638 path = tmp;
6640 }
6641 }
6642
6646 }
6647
6648 /* Make sure the path component is valid. */
6650 pptr = &ptr;
6656 }
6657 }
6658
6662 }
6663
6665 raw_flags |= RAW_URI_FORCE_PORT_DISP;
6667 raw_flags |= RAW_URI_CONVERT_TO_DOS_PATH;
6668
6675 }
6676
6678
6685 }
6686
6688 create_flags |= Uri_CREATE_NO_CANONICALIZE;
6690 create_flags |= Uri_CREATE_FILE_USE_DOS_PATH;
6691
6695 IUri_Release(&ret->IUri_iface);
6698 }
6699
6702
6706
6708 }
6709
6711}
static BOOL parse_path_opaque(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1921
static BOOL parse_path_hierarchical(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1844
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:6400
static DWORD generate_raw_uri(const parse_data *data, BSTR uri, DWORD flags)
Definition: uri.c:4042
static HRESULT canonicalize_uri(const parse_data *data, Uri *uri, DWORD flags)
Definition: uri.c:3373
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
Referenced by CoInternetCombineIUri(), and CoInternetCombineUrlEx().
◆ compare_file_paths()
Definition at line 3875 of file uri.c.
3876{
3877 WCHAR *canon_path_a, *canon_path_b;
3878 DWORD len_a, len_b;
3879
3883 }
3884
3888 }
3889
3890 /* Fast path */
3891 if(a->path_len == b->path_len && !_wcsnicmp(a->canon_uri+a->path_start, b->canon_uri+b->path_start, a->path_len)) {
3894 }
3895
3896 len_a = canonicalize_path_hierarchical(a->canon_uri+a->path_start, a->path_len, a->scheme_type, FALSE, 0, FALSE, NULL);
3897 len_b = canonicalize_path_hierarchical(b->canon_uri+b->path_start, b->path_len, b->scheme_type, FALSE, 0, FALSE, NULL);
3898
3900 if(!canon_path_a)
3903 if(!canon_path_b) {
3904 heap_free(canon_path_a);
3906 }
3907
3908 len_a = canonicalize_path_hierarchical(a->canon_uri+a->path_start, a->path_len, a->scheme_type, FALSE, 0, FALSE, canon_path_a);
3909 len_b = canonicalize_path_hierarchical(b->canon_uri+b->path_start, b->path_len, b->scheme_type, FALSE, 0, FALSE, canon_path_b);
3910
3912
3913 heap_free(canon_path_a);
3914 heap_free(canon_path_b);
3916}
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
Referenced by compare_uris().
◆ compare_uris()
Definition at line 3923 of file uri.c.
3923 {
3927
3929
3932
3933 /* Only compare the scheme names (if any) if their unknown scheme types. */
3934 if(!known_scheme) {
3937 /* Make sure the schemes are the same. */
3941 /* One of the Uri's has a scheme name, while the other doesn't. */
3943 }
3944
3945 /* If they have a userinfo component, perform case sensitive compare. */
3951 /* One of the Uri's had a userinfo, while the other one doesn't. */
3953
3954 /* Check if they have a host name. */
3957 /* Perform a case insensitive compare if they are a known scheme type. */
3958 if(known_scheme) {
3964 /* One of the Uri's had a host, while the other one didn't. */
3966
3971 /* One had a port, while the other one didn't. */
3973
3974 /* Windows is weird with how it handles paths. For example
3975 * One URI could be "http://google.com" (after canonicalization)
3976 * and one could be "http://google.com/" and the IsEqual function
3977 * would still evaluate to TRUE, but, only if they are both hierarchical
3978 * URIs.
3979 */
3982
3998
3999 /* Compare the query strings of the two URIs. */
4006
4013
4014 /* If we get here, the two URIs are equivalent. */
4017}
static HRESULT compare_file_paths(const Uri *a, const Uri *b, BOOL *ret)
Definition: uri.c:3875
Referenced by Uri_IsEqual().
◆ compute_canonicalized_length()
|
static |
Definition at line 3332 of file uri.c.
3332 {
3334
3336
3339
3342 return -1;
3343 }
3344
3347 return -1;
3348 }
3349
3352 return -1;
3353 }
3354
3357 return -1;
3358 }
3359
3360 TRACE("(%p %x): Finished computing canonicalized URI length. length=%d\n", data, flags, uri.canon_len);
3361
3363}
Referenced by canonicalize_uri().
◆ compute_elision_location()
|
static |
Definition at line 716 of file uri.c.
717 {
719 INT max_index, cur_index;
720
721 max_len = cur_len = 0;
722 max_index = cur_index = -1;
726
727 if(check_ipv4) {
728 /* Check if the IPv4 address contains only zeros. */
730 if(cur_index == -1)
731 cur_index = i;
732
733 cur_len += 2;
734 ++i;
735 }
737 if(cur_index == -1)
738 cur_index = i;
739
740 ++cur_len;
741 }
742
744 /* We only consider it for an elision if it's
745 * more than 1 component long.
746 */
747 if(cur_len > 1 && cur_len > max_len) {
748 /* Found the new elision location. */
749 max_len = cur_len;
750 max_index = cur_index;
751 }
752
753 /* Reset the current range for the next range of zeros. */
754 cur_index = -1;
755 cur_len = 0;
756 }
757 }
758
759 *index = max_index;
760 *count = max_len;
761}
Referenced by canonicalize_ipv6address().
◆ compute_ipv6_comps_size()
|
static |
Definition at line 445 of file uri.c.
445 {
447
449 /* IPv4 address is 4 bytes. */
450 address->components_size += 4;
451
453 /* An elision can be anywhere from 2 bytes up to 16 bytes.
454 * Its size depends on the size of the h16 and IPv4 components.
455 */
458 address->elision_size = 2;
459 } else
460 address->elision_size = 0;
461}
Referenced by parse_ipv6address().
◆ convert_to_dos_path()
|
static |
Definition at line 4019 of file uri.c.
4021{
4023
4025 /* Skip over the leading / before the drive path. */
4026 ++ptr;
4027
4030 if(output)
4031 *output++ = '\\';
4032 (*output_len)++;
4033 } else {
4034 if(output)
4035 *output++ = *ptr;
4036 (*output_len)++;
4037 }
4038 }
4039}
Referenced by generate_raw_uri().
◆ CreateIUriBuilder()
| HRESULT WINAPI CreateIUriBuilder | ( | IUri * | pIUri, |
| DWORD | dwFlags, | ||
| DWORD_PTR | dwReserved, | ||
| IUriBuilder ** | ppIUriBuilder | ||
| ) |
Definition at line 6353 of file uri.c.
6354{
6356
6358
6359 if(!ppIUriBuilder)
6361
6365
6367 ret->ref = 1;
6368
6369 if(pIUri) {
6371
6376 }
6377 IUri_AddRef(pIUri);
6379
6381 /* Windows doesn't set 'has_port' to TRUE in this case. */
6383
6384 } else {
6386 *ppIUriBuilder = NULL;
6390 }
6391 }
6392
6393 *ppIUriBuilder = &ret->IUriBuilder_iface;
6395}
Definition: uri.c:99
Referenced by ensure_uri_builder(), get_uri_nofrag(), nsURI_GetPrePath(), UriBuilderFactory_CreateInitializedIUriBuilder(), and UriBuilderFactory_CreateIUriBuilder().
◆ CreateUri()
Definition at line 5700 of file uri.c.
5701{
5702 const DWORD supported_flags = Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME|
5703 Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_NO_CANONICALIZE|Uri_CREATE_CANONICALIZE|
5704 Uri_CREATE_DECODE_EXTRA_INFO|Uri_CREATE_NO_DECODE_EXTRA_INFO|Uri_CREATE_CRACK_UNKNOWN_SCHEMES|
5705 Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES|Uri_CREATE_PRE_PROCESS_HTML_URI|Uri_CREATE_NO_PRE_PROCESS_HTML_URI|
5706 Uri_CREATE_NO_IE_SETTINGS|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS|Uri_CREATE_FILE_USE_DOS_PATH;
5710
5712
5713 if(!ppURI)
5715
5716 if(!pwzURI) {
5717 *ppURI = NULL;
5719 }
5720
5721 /* Check for invalid flags. */
5723 *ppURI = NULL;
5725 }
5726
5727 /* Currently unsupported. */
5730
5733 *ppURI = NULL;
5735 }
5736
5737 /* Explicitly set the default flags if it doesn't cause a flag conflict. */
5739
5740 /* Pre process the URI, unless told otherwise. */
5743 else
5745
5749 }
5750
5753
5754 /* Validate and parse the URI into its components. */
5756 /* Encountered an unsupported or invalid URI */
5757 IUri_Release(&ret->IUri_iface);
5758 *ppURI = NULL;
5760 }
5761
5762 /* Canonicalize the URI. */
5765 IUri_Release(&ret->IUri_iface);
5766 *ppURI = NULL;
5768 }
5769
5771
5772 *ppURI = &ret->IUri_iface;
5774}
Referenced by AsyncInstallDistributionUnit(), BindProtocol_Start(), CoInternetCombineIUri(), CoInternetCombineUrlEx(), CoInternetGetSecurityUrlEx(), create_uri(), CreateUriWithFragment(), CreateURLMonikerEx(), FileProtocol_Start(), FtpProtocol_Start(), get_security_id_for_url(), GopherProtocol_Start(), HttpProtocol_Start(), map_url_to_zone(), MkProtocol_Start(), and URLMoniker_Load().
◆ CreateUriWithFragment()
| HRESULT WINAPI CreateUriWithFragment | ( | LPCWSTR | pwzURI, |
| LPCWSTR | pwzFragment, | ||
| DWORD | dwFlags, | ||
| DWORD_PTR | dwReserved, | ||
| IUri ** | ppURI | ||
| ) |
Definition at line 5795 of file uri.c.
5797{
5799 TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI), debugstr_w(pwzFragment), dwFlags, (DWORD)dwReserved, ppURI);
5800
5801 if(!ppURI)
5803
5804 if(!pwzURI) {
5805 *ppURI = NULL;
5807 }
5808
5809 /* Check if a fragment should be appended to the URI string. */
5810 if(pwzFragment) {
5811 WCHAR *uriW;
5812 DWORD uri_len, frag_len;
5813 BOOL add_pound;
5814
5815 /* Check if the original URI already has a fragment component. */
5817 *ppURI = NULL;
5819 }
5820
5821 uri_len = lstrlenW(pwzURI);
5822 frag_len = lstrlenW(pwzFragment);
5823
5824 /* If the fragment doesn't start with a '#', one will be added. */
5825 add_pound = *pwzFragment != '#';
5826
5827 if(add_pound)
5829 else
5831
5832 if(!uriW)
5834
5836 if(add_pound)
5837 uriW[uri_len++] = '#';
5839
5841
5842 heap_free(uriW);
5843 } else
5844 /* A fragment string wasn't specified, so just forward the call. */
5846
5848}
◆ decode_pct_val()
Definition at line 483 of file uri.c.
483 {
485
489
492 }
493
495}
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()
◆ find_domain_name()
Definition at line 520 of file uri.c.
521 {
523
525
526 *domain_start = -1;
527
528 /* There has to be at least enough room for a '.' followed by a
529 * 3-character TLD for a domain to even exist in the host name.
530 */
531 if(host_len < 4)
532 return;
533
535 {
537 {
538 sec_last_tld = last_tld;
539 last_tld = p;
540 }
541 }
542 if(!last_tld)
543 /* http://hostname -> has no domain name. */
544 return;
545
546 if(!sec_last_tld) {
547 /* If the '.' is at the beginning of the host there
548 * has to be at least 3 characters in the TLD for it
549 * to be valid.
550 * Ex: .com -> .com as the domain name.
551 * .co -> has no domain name.
552 */
555 return;
558
559 /* If there are three characters in front of last_tld and
560 * they are on the list of recognized TLDs, then this
561 * host doesn't have a domain (since the host only contains
562 * a TLD name.
563 * Ex: edu.uk -> has no domain name.
564 * foo.uk -> foo.uk as the domain name.
565 */
568 return;
569 }
571 /* Anything less than 3 characters is considered part
572 * of the TLD name.
573 * Ex: ak.uk -> Has no domain name.
574 */
575 return;
576
577 /* Otherwise the domain name is the whole host name. */
578 *domain_start = 0;
580 /* If the last_tld has more than 3 characters, then it's automatically
581 * considered the TLD of the domain name.
582 * Ex: www.winehq.org.uk.test -> uk.test as the domain name.
583 */
584 *domain_start = (sec_last_tld+1)-host;
585 } else if(last_tld - (sec_last_tld+1) < 4) {
587 /* If the sec_last_tld is 3 characters long it HAS to be on the list of
588 * recognized to still be considered part of the TLD name, otherwise
589 * it's considered the domain name.
590 * Ex: www.google.com.uk -> google.com.uk as the domain name.
591 * www.google.foo.uk -> foo.uk as the domain name.
592 */
593 if(last_tld - (sec_last_tld+1) == 3) {
600 return;
601 }
602 }
603
604 *domain_start = (sec_last_tld+1)-host;
605 } else {
606 /* Since the sec_last_tld is less than 3 characters it's considered
607 * part of the TLD.
608 * Ex: www.google.fo.uk -> google.fo.uk as the domain name.
609 */
612 }
613 } else {
614 /* The second to last TLD has more than 3 characters making it
615 * the domain name.
616 * Ex: www.google.test.us -> test.us as the domain name.
617 */
618 *domain_start = (sec_last_tld+1)-host;
619 }
620
623}
static const struct @563 recognized_tlds[]
Referenced by canonicalize_reg_name(), and search_domain_for_zone().
◆ find_file_extension()
◆ generate_raw_uri()
|
static |
Definition at line 4042 of file uri.c.
4042 {
4044
4049 }
4051 }
4052
4054 /* For the "//" which appears before the authority component. */
4058 }
4059 length += 2;
4060
4061 /* Check if we need to add the "\\" before the host name
4062 * of a UNC server name in a DOS path.
4063 */
4069 }
4070 length += 2;
4071 }
4072 }
4073
4078 }
4079
4084 }
4086 }
4087
4091 ++length;
4092 }
4093
4095 /* IPv6 addresses get the brackets added around them if they don't already
4096 * have them.
4097 */
4099 if(add_brackets) {
4102 ++length;
4103 }
4104
4108
4109 if(add_brackets) {
4112 length++;
4113 }
4114 }
4115
4117 /* The port isn't included in the raw uri if it's the default
4118 * port for the scheme type.
4119 */
4122
4126 is_default = TRUE;
4127 }
4128
4132 ++length;
4133
4136 else
4138 }
4139 }
4140
4141 /* Check if a '/' should be added before the path for hierarchical URIs. */
4145 ++length;
4146 }
4147
4152
4155 else
4157
4159 } else {
4163 }
4164 }
4165
4170 }
4171
4176 }
4177
4180 else
4182
4184}
static void convert_to_dos_path(const WCHAR *path, DWORD path_len, WCHAR *output, DWORD *output_len)
Definition: uri.c:4019
Referenced by combine_uri(), and generate_uri().
◆ generate_uri()
|
static |
Definition at line 4186 of file uri.c.
4186 {
4192
4194
4198 return INET_E_INVALID_URL;
4200 }
4201
4204}
Referenced by build_uri().
◆ get_builder_component()
|
static |
Definition at line 3438 of file uri.c.
3441{
3442 if(!output_len) {
3443 if(output)
3444 *output = NULL;
3446 }
3447
3448 if(!output) {
3449 *output_len = 0;
3451 }
3452
3454 /* Allocate 'component', and copy the contents from 'source'
3455 * into the new allocation.
3456 */
3458 if(!(*component))
3460
3462 (*component)[source_len] = '\0';
3463 *component_len = source_len;
3464 }
3465
3466 *output = *component;
3467 *output_len = *component_len;
3469}
Definition: pdh_main.c:172
Referenced by UriBuilder_GetFragment(), UriBuilder_GetHost(), UriBuilder_GetPassword(), UriBuilder_GetPath(), UriBuilder_GetQuery(), UriBuilder_GetSchemeName(), and UriBuilder_GetUserName().
◆ get_uri_obj()
Definition at line 254 of file uri.c.
255{
258
261}
Referenced by CoInternetCombineIUri(), CoInternetCombineUrlEx(), CoInternetParseIUri(), CreateIUriBuilder(), Uri_IsEqual(), and UriBuilder_SetIUri().
◆ h16tous()
Definition at line 872 of file uri.c.
Referenced by ipv6_to_number().
◆ has_invalid_flag_combination()
◆ hex_to_int()
◆ impl_from_IMarshal()
Definition at line 5420 of file uri.c.
5421{
5423}
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 5127 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 4206 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 5908 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 5058 of file uri.c.
Referenced by UriBuilderFactory_AddRef(), UriBuilderFactory_CreateInitializedIUriBuilder(), UriBuilderFactory_CreateIUriBuilder(), UriBuilderFactory_QueryInterface(), and UriBuilderFactory_Release().
◆ ipv4toui()
Definition at line 806 of file uri.c.
806 {
810
813 ret <<= 8;
815 comp_value = 0;
816 } else
818 }
819
820 ret <<= 8;
822
824}
Definition: dhcpd.h:62
Referenced by ipv6_to_number().
◆ ipv6_to_number()
|
static |
Definition at line 888 of file uri.c.
888 {
891
895 /* Means we just passed the elision and need to add its values to
896 * 'number' before we do anything else.
897 */
900 number[cur_component++] = 0;
901
902 already_passed_elision = TRUE;
903 }
904 }
905
907 }
908
909 /* Case when the elision appears after the h16 components. */
913 number[cur_component++] = 0;
914 }
915
918
919 if(cur_component != 6) {
922 }
923
926 }
927
929}
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 GLint GLint j
Definition: glfuncs.h:250
Definition: pdh_main.c:94
Referenced by canonicalize_ipv6address().
◆ is_alpha()
◆ is_ascii()
Definition at line 361 of file uri.c.
Referenced by canonicalize_fragment(), canonicalize_password(), canonicalize_path_hierarchical(), canonicalize_path_opaque(), canonicalize_query(), canonicalize_reg_name(), canonicalize_username(), and parse_canonicalize().
◆ is_auth_delim()
Definition at line 336 of file uri.c.
336 {
339}
Referenced by parse_ipv4address(), parse_ipv6address(), parse_password(), parse_port(), parse_reg_name(), and parse_username().
◆ is_default_port()
|
static |
Definition at line 366 of file uri.c.
366 {
368
372 }
373
375}
Referenced by Uri_GetPropertyBSTR(), and Uri_GetPropertyLength().
◆ is_drive_path()
Definition at line 271 of file uri.c.
271 {
273}
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 279 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 346 of file uri.c.
346 {
350}
Referenced by check_pct_encoded(), decode_pct_val(), parse_ipv6address(), and parse_ipvfuture().
◆ is_hierarchical_scheme()
|
inlinestatic |
Definition at line 378 of file uri.c.
378 {
384}
Referenced by canonicalize_hierpart(), and is_hierarchical_uri().
◆ is_hierarchical_uri()
|
inlinestatic |
Definition at line 421 of file uri.c.
Referenced by parse_hierpart().
◆ is_implicit_file_path()
◆ is_num()
Definition at line 267 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 352 of file uri.c.
Referenced by parse_path_hierarchical(), and parse_path_opaque().
◆ is_reserved()
Definition at line 342 of file uri.c.
342 {
344}
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 356 of file uri.c.
Referenced by remove_dot_segments().
◆ is_subdelim()
◆ is_unc_path()
Definition at line 275 of file uri.c.
Referenced by is_implicit_file_path(), and parse_reg_name().
◆ is_unreserved()
Definition at line 310 of file uri.c.
310 {
313}
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 5465 of file uri.c.
5467{
5472 dwDestContext, pvDestContext, mshlflags, pSize);
5473
5474 if(!pSize || (dwDestContext!=MSHCTX_LOCAL && dwDestContext!=MSHCTX_NOSHAREDMEM
5475 && dwDestContext!=MSHCTX_INPROC))
5477
5478 if(dwDestContext == MSHCTX_INPROC) {
5481 }
5482
5492}
Definition: ms-dtyp.idl:184
Definition: uri.c:5458
◆ Marshal_GetUnmarshalClass()
|
static |
◆ Marshal_MarshalInterface()
|
static |
Definition at line 5494 of file uri.c.
5496{
5501
5503 dwDestContext, pvDestContext, mshlflags);
5504
5505 if(!pStm || mshlflags!=MSHLFLAGS_NORMAL || (dwDestContext!=MSHCTX_LOCAL
5506 && dwDestContext!=MSHCTX_NOSHAREDMEM && dwDestContext!=MSHCTX_INPROC))
5508
5509 if(dwDestContext == MSHCTX_INPROC) {
5511
5513 data.mshlflags = MSHCTX_INPROC;
5514 data.unk[0] = 0;
5515 data.unk[1] = 0;
5516 data.unk[2] = 0;
5517 data.unk[3] = 0;
5519
5523
5524 IUri_AddRef(&This->IUri_iface);
5526 }
5527
5532
5536
5538 data[1] = dwDestContext;
5541
5545}
static void persist_stream_save(Uri *This, IStream *pStm, BOOL marshal, struct persist_uri *data)
Definition: uri.c:5256
Definition: uri.c:5169
◆ Marshal_QueryInterface()
|
static |
Definition at line 5425 of file uri.c.
5426{
5429}
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD _Outptr_opt_ void ** ppvObject
Definition: wincrypt.h:6082
◆ Marshal_Release()
◆ Marshal_ReleaseMarshalData()
Definition at line 5605 of file uri.c.
5606{
5608 LARGE_INTEGER off;
5611
5613
5614 if(!pStm)
5616
5620
5623
5627
5628 IUri_Release(&data.uri->IUri_iface);
5630 }
5631
5633 off.u.HighPart = 0;
5635}
Definition: winhttp_private.h:132
Definition: typedefs.h:103
struct _LARGE_INTEGER::@2295 u
◆ Marshal_UnmarshalInterface()
|
static |
◆ merge_paths()
|
static |
Definition at line 6400 of file uri.c.
6402{
6404 DWORD base_copy_len = 0;
6406
6407 if(base_len) {
6409 /* Find '::' segment */
6412 end++;
6413 break;
6414 }
6415 }
6416
6417 /* If not found, try finding the end of @xxx: */
6420 }else {
6421 /* Find the characters that will be copied over from the base path. */
6424 /* Try looking for a '\\'. */
6426 }
6427 }
6428
6431
6433 *result_len = 0;
6435 }
6436
6439 ptr += base_copy_len;
6440
6442 ptr += relative_len;
6444
6448}
_CONST_RETURN wchar_t *__cdecl wmemchr(_In_reads_(_N) const wchar_t *_S, _In_ wchar_t _C, _In_ size_t _N)
Definition: wchar.h:2554
Referenced by combine_uri().
◆ parse_anchor()
|
static |
Definition at line 7216 of file uri.c.
7217{
7221
7224 *result_len = 0;
7226 }
7227
7228 *result_len = len;
7231
7234 *result_len = 0;
7236 }
7237
7240
7242}
Referenced by CoInternetParseIUri().
◆ parse_authority()
|
static |
Definition at line 1831 of file uri.c.
1831 {
1833
1834 /* Parsing the port will happen during one of the host parsing
1835 * routines (if the URI has a port).
1836 */
1839
1841}
static BOOL parse_host(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1813
static void parse_userinfo(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1296
Referenced by parse_hierpart().
◆ parse_canonicalize()
|
static |
Definition at line 6821 of file uri.c.
6823{
6828 BOOL reduce_path;
6829
6830 /* URL_UNESCAPE only has effect if none of the URL_ESCAPE flags are set. */
6834
6835
6836 /* Check if the dot segments need to be removed from the
6837 * path component.
6838 */
6841 pptr = &ptr;
6842 }
6845
6848
6849 /* Keep track of the path if we need to remove dot segments from
6850 * it later.
6851 */
6854
6855 /* Check if it's time to reduce the path. */
6859
6860 /* Update the current length. */
6861 len -= (current_path_len-new_path_len);
6862 reduce_path = FALSE;
6863 }
6864
6867 if(decoded) {
6870 output[len] = decoded;
6871 len++;
6872 ptr += 2;
6873 do_default_action = FALSE;
6874 }
6875 }
6876
6877 /* See if %'s needed to encoded. */
6881 len += 3;
6882 do_default_action = FALSE;
6883 }
6889 len += 3;
6890 do_default_action = FALSE;
6891 }
6896 len += 3;
6897 do_default_action = FALSE;
6898 }
6899 }
6900
6901 if(do_default_action) {
6904 len++;
6905 }
6906 }
6907
6908 /* Sometimes the path is the very last component of the IUri, so
6909 * see if the dot segments need to be reduced now.
6910 */
6914
6915 /* Update the current length. */
6916 len -= (current_path_len-new_path_len);
6917 }
6918
6920 output[len] = 0;
6921 else
6922 output[output_len-1] = 0;
6923
6924 /* The null terminator isn't included in the length. */
6925 *result_len = len;
6928
6930}
Referenced by CoInternetParseIUri().
◆ parse_document()
|
static |
Definition at line 7011 of file uri.c.
7013{
7015
7016 /* It has to be a known scheme type, but, it can't be a file
7017 * scheme. It also has to hierarchical.
7018 */
7021 uri->authority_start == -1) {
7022 *result_len = 0;
7023 if(output_len < 1)
7025
7026 output[0] = 0;
7028 }
7029
7032 else
7034
7035 *result_len = len;
7038
7040 output[len] = 0;
7042}
Referenced by CoInternetParseIUri().
◆ parse_domain()
|
static |
Definition at line 7188 of file uri.c.
7189{
7193
7196 *result_len = 0;
7198 }
7199
7200 *result_len = len;
7203
7206 *result_len = 0;
7208 }
7209
7212
7214}
Referenced by CoInternetParseIUri().
◆ parse_fragment()
|
static |
Definition at line 2083 of file uri.c.
2083 {
2085
2089 }
2090
2092
2093 ++(*ptr);
2096 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
2101 } else
2102 continue;
2103 }
2104
2105 ++(*ptr);
2106 }
2107
2109
2113}
Referenced by parse_uri(), and validate_fragment().
◆ parse_friendly()
|
static |
Definition at line 6932 of file uri.c.
6934{
6936 DWORD display_len;
6938
6941 *result_len = 0;
6943 }
6944
6945 *result_len = display_len;
6946 if(display_len+1 > output_len)
6948
6951 *result_len = 0;
6953 }
6954
6958}
Referenced by CoInternetParseIUri().
◆ parse_hierpart()
|
static |
Definition at line 1981 of file uri.c.
1981 {
1983
1985
1986 /* For javascript: URIs, simply set everything as a path */
1993 }
1994
1995 /* Checks if the authority information needs to be parsed. */
1997 /* Only treat it as a hierarchical URI if the scheme_type is known or
1998 * the Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES flag is not set.
1999 */
2001 !(flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES)) {
2004
2008 *ptr += 2;
2009 }
2010 }
2011
2012 /* TODO: Handle hierarchical URI's, parse authority then parse the path. */
2015
2017 } else
2018 /* Reset ptr to its starting position so opaque path parsing
2019 * begins at the correct location.
2020 */
2022 }
2023
2024 /* If it reaches here, then the URI will be treated as an opaque
2025 * URI.
2026 */
2027
2029
2033
2035}
static BOOL is_hierarchical_uri(const WCHAR **ptr, const parse_data *data)
Definition: uri.c:421
static BOOL parse_authority(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1831
Referenced by parse_uri().
◆ parse_host()
Definition at line 1813 of file uri.c.
1813 {
1820 }
1821 }
1822 }
1823
1825}
static BOOL parse_ip_literal(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1763
static BOOL parse_reg_name(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1452
static BOOL parse_ipv4address(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1390
Referenced by parse_authority(), and validate_host().
◆ parse_ip_literal()
|
static |
Definition at line 1763 of file uri.c.
1763 {
1765
1770 ++(*ptr);
1771
1777 }
1778 }
1779
1785 /* The IP literal didn't contain brackets and was followed by
1786 * a NULL terminator, so no reason to even check the port.
1787 */
1790 }
1791
1792 ++(*ptr);
1794 ++(*ptr);
1795 /* If a valid port is not found, then let it trickle down to
1796 * parse_reg_name.
1797 */
1802 }
1803 } else
1805
1807}
static BOOL parse_port(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1345
static BOOL parse_ipv6address(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1575
static BOOL parse_ipvfuture(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1720
Referenced by parse_host().
◆ parse_ipv4address()
|
static |
Definition at line 1390 of file uri.c.
1390 {
1393
1401 } else
1403 }
1404
1406 data->host_type = Uri_HOST_IPV4;
1407
1408 /* Check if what we found is the only part of the host name (if it isn't
1409 * we don't have an IPv4 address).
1410 */
1412 ++(*ptr);
1417 }
1419 /* Found more data which belongs to the host, so this isn't an IPv4. */
1424 }
1425
1430}
static BOOL check_ipv4address(const WCHAR **ptr, BOOL strict)
Definition: uri.c:1037
static BOOL check_implicit_ipv4(const WCHAR **ptr, UINT *val)
Definition: uri.c:1005
Referenced by parse_host().
◆ parse_ipv6address()
|
static |
Definition at line 1575 of file uri.c.
1575 {
1578
1581
1582 for(;; ++(*ptr)) {
1583 /* Check if we're on the last character of the host. */
1586
1589
1590 /* Check if we're at the end of a component, or
1591 * if we're at the end of the IPv6 address.
1592 */
1593 if(is_split || is_end) {
1594 DWORD cur_len = 0;
1595
1596 cur_len = *ptr - cur_start;
1597
1598 /* h16 can't have a length > 4. */
1599 if(cur_len > 4) {
1601
1605 }
1606
1607 if(cur_len == 0) {
1608 /* An h16 component can't have the length of 0 unless
1609 * the elision is at the beginning of the address, or
1610 * at the end of the address.
1611 */
1618 }
1619 }
1620
1621 if(cur_len > 0) {
1622 /* An IPv6 address can have no more than 8 h16 components. */
1628 }
1629
1632
1635 ip.h16_count);
1636 ++ip.h16_count;
1637 }
1638 }
1639
1640 if(is_end)
1641 break;
1642
1643 if(is_elision) {
1644 /* A IPv6 address can only have 1 elision ('::'). */
1647
1651 }
1652
1654 ++(*ptr);
1655 }
1656
1657 if(is_split)
1658 cur_start = *ptr+1;
1659 else {
1662 /* Not a valid character for an IPv6 address. */
1665 }
1666 } else {
1667 /* Found an IPv4 address. */
1668 ip.ipv4 = cur_start;
1670
1673 ip.ipv4_len);
1674
1675 /* IPv4 addresses can only appear at the end of a IPv6. */
1676 break;
1677 }
1678 }
1679 }
1680
1682
1683 /* Make sure the IPv6 address adds up to 16 bytes. */
1689 }
1690
1692 /* For some reason on Windows if an elision that represents
1693 * only one h16 component is encountered at the very begin or
1694 * end of an IPv6 address, Windows does not consider it a
1695 * valid IPv6 address.
1696 *
1697 * Ex: [::2:3:4:5:6:7] is not valid, even though the sum
1698 * of all the components == 128bits.
1699 */
1703 TRACE("(%p %p %x): Invalid IPv6 address. Detected elision of 2 bytes at the beginning or end of the address.\n",
1706 }
1707 }
1708
1709 data->host_type = Uri_HOST_IPV6;
1712
1717}
static void compute_ipv6_comps_size(ipv6_address *address)
Definition: uri.c:445
Definition: uri.c:136
Referenced by parse_ip_literal().
◆ parse_ipvfuture()
|
static |
Definition at line 1720 of file uri.c.
1720 {
1722
1723 /* IPvFuture has to start with a 'v' or 'V'. */
1726
1727 /* Following the v there must be at least 1 hex digit. */
1728 ++(*ptr);
1732 }
1733
1734 ++(*ptr);
1736 ++(*ptr);
1737
1738 /* End of the hexdigit sequence must be a '.' */
1742 }
1743
1744 ++(*ptr);
1748 }
1749
1750 ++(*ptr);
1752 ++(*ptr);
1753
1754 data->host_type = Uri_HOST_UNKNOWN;
1755
1758
1760}
Referenced by parse_ip_literal().
◆ parse_password()
|
static |
Definition at line 1249 of file uri.c.
1249 {
1251
1259 }
1260 } else
1261 continue;
1263 break;
1268 }
1269
1270 ++(*ptr);
1271 }
1272
1275}
Referenced by parse_userinfo(), and validate_password().
◆ parse_path_from_url()
|
static |
Definition at line 7044 of file uri.c.
7046{
7050
7052 *result_len = 0;
7053 if(output_len > 0)
7054 output[0] = 0;
7056 }
7057
7061
7066 }
7067
7070 /* Skip past the '/' in front of the drive path. */
7071 ++path_ptr;
7072
7075
7076 if(*path_ptr == '%') {
7078 if(decoded) {
7079 *ptr = decoded;
7080 path_ptr += 2;
7081 do_default_action = FALSE;
7082 }
7083 } else if(*path_ptr == '/') {
7085 do_default_action = FALSE;
7086 }
7087
7088 if(do_default_action)
7089 *ptr = *path_ptr;
7090 }
7091
7092 *ptr = 0;
7093
7095 if(*result_len+1 > output_len)
7097
7100}
Referenced by CoInternetParseIUri().
◆ parse_path_hierarchical()
|
static |
Definition at line 1844 of file uri.c.
1844 {
1848
1852 data->path_len = 0;
1854 /* If the path component is empty, then a '/' is added. */
1855 data->path = slash;
1856 data->path_len = 1;
1857 }
1858 } else {
1864 } else
1865 continue;
1867 (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
1868 /* File schemes with USE_DOS_PATH set aren't allowed to have
1869 * a '<' or '>' or '\"' appear in them.
1870 */
1874 /* Not allowed to have a backslash if NO_CANONICALIZE is set
1875 * and the scheme is known type (but not a file scheme).
1876 */
1882 }
1883 }
1884 }
1885
1886 ++(*ptr);
1887 }
1888
1889 /* The only time a URI doesn't have a path is when
1890 * the NO_CANONICALIZE flag is set and the raw URI
1891 * didn't contain one.
1892 */
1895 data->path_len = 0;
1896 } else {
1899 }
1900 }
1901
1905 else
1907
1909}
Referenced by combine_uri(), parse_hierpart(), and validate_path().
◆ parse_path_opaque()
|
static |
Definition at line 1921 of file uri.c.
1921 {
1925
1927 {
1930 }
1931 else
1933
1940 } else
1941 continue;
1943 (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
1947 }
1948
1949 ++(*ptr);
1950 }
1951
1956}
Referenced by combine_uri(), parse_hierpart(), and validate_path().
◆ parse_port()
|
static |
Definition at line 1345 of file uri.c.
1345 {
1348
1354 }
1355
1357
1362 }
1363
1364 ++(*ptr);
1365 }
1366
1370
1374}
Referenced by parse_ip_literal(), parse_ipv4address(), and parse_reg_name().
◆ parse_query()
|
static |
Definition at line 2044 of file uri.c.
2044 {
2046
2050 }
2051
2053
2054 ++(*ptr);
2057 !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
2062 } else
2063 continue;
2064 }
2065
2066 ++(*ptr);
2067 }
2068
2070
2074}
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 1452 of file uri.c.
1452 {
1456 BOOL inside_brackets = has_start_bracket;
1457
1458 /* res URIs don't have ports. */
1460
1461 /* We have to be careful with file schemes. */
1463 /* This is because an implicit file scheme could be "C:\\test" and it
1464 * would trick this function into thinking the host is "C", when after
1465 * canonicalization the host would end up being an empty string. A drive
1466 * path can also have a '|' instead of a ':' after the drive letter.
1467 */
1469 /* Regular old drive paths have no host type (or host name). */
1470 data->host_type = Uri_HOST_UNKNOWN;
1472 data->host_len = 0;
1475 /* Skip past the "\\" of a UNC path. */
1476 *ptr += 2;
1477 }
1478
1480
1481 /* For res URIs, everything before the first '/' is
1482 * considered the host.
1483 */
1487 /* We can ignore ':' if we are inside brackets.*/
1488 if(!inside_brackets) {
1490
1491 /* Attempt to parse the port. */
1493 /* Windows expects there to be a valid port for known scheme types. */
1499 } else
1500 /* Windows gives up on trying to parse a port when it
1501 * encounters an invalid port.
1502 */
1503 ignore_col = TRUE;
1504 } else {
1506 break;
1507 }
1508 }
1510 /* Has to be a legit % encoded value. */
1515 } else
1516 continue;
1522 inside_brackets = FALSE;
1524 inside_brackets = TRUE;
1525
1526 ++(*ptr);
1527 }
1528
1529 if(has_start_bracket) {
1530 /* Make sure the last character of the host wasn't a ']'. */
1537 }
1538 }
1539
1540 /* Don't overwrite our length if we found a port earlier. */
1543
1544 /* If the host is empty, then it's an unknown host type. */
1546 data->host_type = Uri_HOST_UNKNOWN;
1547 else
1548 data->host_type = Uri_HOST_DNS;
1549
1553}
Referenced by parse_host().
◆ parse_rootdocument()
|
static |
Definition at line 6960 of file uri.c.
6962{
6964
6967
6968 /* Windows only returns the root document if the URI has an authority
6969 * and it's not an unknown scheme type or a file scheme type.
6970 */
6974 *result_len = 0;
6975 if(!output_len)
6977
6978 output[0] = 0;
6980 }
6981
6983 /* For the "://" and '/' which will be added. */
6984 len += 4;
6985
6987 *result_len = len;
6989 }
6990
6991 ptr = output;
6993
6994 /* Add the "://". */
6997
6998 /* Add the authority. */
7001
7002 /* Add the '/' after the authority. */
7005 ptr[1] = 0;
7006
7007 *result_len = len;
7009}
Referenced by CoInternetParseIUri().
◆ parse_schema()
|
static |
Definition at line 7131 of file uri.c.
7133{
7137
7140 *result_len = 0;
7142 }
7143
7144 *result_len = len;
7147
7150 *result_len = 0;
7152 }
7153
7156
7158}
Referenced by CoInternetParseIUri().
◆ parse_scheme()
|
static |
Definition at line 1169 of file uri.c.
1169 {
1172
1173 /* First check to see if the uri could implicitly be a file path. */
1179
1181 } else {
1182 /* Windows does not consider anything that can implicitly be a file
1183 * path to be a valid URI if the ALLOW_IMPLICIT_FILE_SCHEME flag is not set...
1184 */
1185 TRACE("(%p %p %x): URI is implicitly a file path, but, the ALLOW_IMPLICIT_FILE_SCHEME flag wasn't set.\n",
1188 }
1190 /* No scheme was found, this means it could be:
1191 * a) an implicit Wildcard scheme
1192 * b) a relative URI
1193 * c) an invalid URI.
1194 */
1199
1204 } else {
1207 }
1208 }
1209
1213
1216
1219}
static BOOL parse_scheme_name(const WCHAR **ptr, parse_data *data, DWORD extras)
Definition: uri.c:1092
Referenced by parse_uri(), and validate_scheme_name().
◆ parse_scheme_name()
|
static |
Definition at line 1092 of file uri.c.
1092 {
1094
1096 data->scheme_len = 0;
1097
1100 /* Might have found a wildcard scheme. If it is the next
1101 * char has to be a ':' for it to be a valid URI
1102 */
1103 ++(*ptr);
1104 break;
1107 break;
1108
1109 (*ptr)++;
1110 }
1111
1114
1115 /* Schemes must end with a ':' */
1119 }
1120
1123
1124 ++(*ptr);
1126}
Referenced by parse_scheme().
◆ parse_scheme_type()
|
static |
Definition at line 1131 of file uri.c.
1131 {
1132 /* If there's scheme data then see if it's a recognized scheme. */
1135
1138 /* Has to be a case insensitive compare. */
1142 }
1143 }
1144 }
1145
1146 /* If we get here it means it's not a recognized scheme. */
1150 /* Relative URI's have no scheme. */
1153 } else {
1154 /* Should never reach here! what happened... */
1157 }
1158}
static const struct @561 recognized_schemes[]
Referenced by parse_scheme().
◆ parse_site()
|
static |
Definition at line 7160 of file uri.c.
7161{
7165
7168 *result_len = 0;
7170 }
7171
7172 *result_len = len;
7175
7178 *result_len = 0;
7180 }
7181
7184
7186}
Referenced by CoInternetParseIUri().
◆ parse_uri()
|
static |
Definition at line 2120 of file uri.c.
2120 {
2123
2125 pptr = &ptr;
2126
2128
2131
2134
2137
2140
2143}
static BOOL parse_hierpart(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:1981
static BOOL parse_scheme(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1169
static BOOL parse_fragment(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:2083
static BOOL parse_query(const WCHAR **ptr, parse_data *data, DWORD flags)
Definition: uri.c:2044
Referenced by combine_uri(), CreateUri(), Marshal_UnmarshalInterface(), and PersistStream_Load().
◆ parse_url_from_path()
|
static |
Definition at line 7102 of file uri.c.
7104{
7108
7111 *result_len = 0;
7113 }
7114
7115 *result_len = len;
7118
7121 *result_len = 0;
7123 }
7124
7127
7129}
Referenced by CoInternetParseIUri().
◆ parse_userinfo()
|
static |
Definition at line 1296 of file uri.c.
1296 {
1298
1301 return;
1302 }
1303
1305 ++(*ptr);
1309 data->username_len = 0;
1311 return;
1312 }
1313 }
1314
1318 data->username_len = 0;
1320 data->password_len = 0;
1321
1323 return;
1324 }
1325
1329
1333
1334 ++(*ptr);
1335}
static BOOL parse_password(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1249
static BOOL parse_username(const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
Definition: uri.c:1221
Referenced by parse_authority().
◆ parse_username()
|
static |
Definition at line 1221 of file uri.c.
1221 {
1223
1231 }
1232 } else
1233 continue;
1235 break;
1240 }
1241
1242 ++(*ptr);
1243 }
1244
1247}
Referenced by parse_userinfo(), and validate_username().
◆ pct_encode_val()
Definition at line 504 of file uri.c.
504 {
508}
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 5256 of file uri.c.
5257{
5259
5261
5263 data->fields_no = 1;
5266 }
5269 return;
5270
5272 data->fields_no++;
5275 }
5276
5278 data->fields_no++;
5282 else
5285 }
5286
5288 data->fields_no++;
5292 }
5293
5295 data->fields_no++;
5298 } else if(marshal) {
5300 data->fields_no++;
5302 }
5303
5305 data->fields_no++;
5312 }
5313
5315 data->fields_no++;
5318 }
5319
5321 data->fields_no++;
5324 }
5325
5327 data->fields_no++;
5331 else
5334 }
5335}
static BYTE * persist_stream_add_strprop(Uri *This, BYTE *p, DWORD type, DWORD len, WCHAR *data)
Definition: uri.c:5243
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 5178 of file uri.c.
5179{
5182 parse_data parse;
5185
5187
5190 if(!pStm)
5192
5203 }
5204
5208 }
5209
5214 }
5215
5220 }
5224
5229 This->create_flags = 0;
5231 }
5232
5236 This->create_flags = 0;
5238 }
5239
5241}
◆ PersistStream_QueryInterface()
|
static |
◆ PersistStream_Release()
|
static |
◆ PersistStream_Save()
|
static |
◆ pre_process_uri()
◆ remove_dot_segments()
Definition at line 630 of file uri.c.
630 {
635
637 /* Move the first path segment in the input buffer to the end of
638 * the output buffer, and any subsequent characters up to, including
639 * the next "/" character (if any) or the end of the input buffer.
640 */
644 break;
646
649 break;
650
651 /* Handle ending "/." */
653 ++in;
654 break;
655 }
656
657 /* Handle "/./" */
659 in += 2;
660 continue;
661 }
662
663 /* If we don't have "/../" or ending "/.." */
665 break;
666
667 /* Find the slash preceding out pointer and move out pointer to it */
669 --out;
672 ++out;
673 in += 2;
675 ++in;
676 }
677 }
678
683}
Referenced by canonicalize_path_hierarchical(), canonicalize_path_opaque(), combine_uri(), and parse_canonicalize().
◆ reset_builder()
|
static |
Definition at line 3510 of file uri.c.
3510 {
3514
3517 builder->fragment_len = 0;
3518
3521 builder->host_len = 0;
3522
3525 builder->password_len = 0;
3526
3529 builder->path_len = 0;
3530
3533 builder->query_len = 0;
3534
3537 builder->scheme_len = 0;
3538
3541 builder->username_len = 0;
3542
3544 builder->port = 0;
3545 builder->modified_props = 0;
3546}
Referenced by UriBuilder_SetIUri().
◆ set_builder_component()
|
static |
Definition at line 3477 of file uri.c.
3479{
3480 heap_free(*component);
3481
3482 if(!new_value) {
3483 *component = NULL;
3484 *component_len = 0;
3485 } else {
3489
3490 if(prefix && *new_value != prefix) {
3491 add_prefix = TRUE;
3493 } else
3495
3496 if(!(*component))
3498
3499 if(add_prefix)
3500 (*component)[pos++] = prefix;
3501
3504 }
3505
3506 *flags |= success_flag;
3508}
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 3700 of file uri.c.
3700 {
3705 }
3709 }
3710
3713}
Referenced by validate_components().
◆ ui2ipv4()
Definition at line 834 of file uri.c.
834 {
836 {'%','u','.','%','u','.','%','u','.','%','u',0};
839
844
846 WCHAR tmp[16];
848 } else
850
852}
Referenced by canonicalize_implicit_ipv4address(), and canonicalize_ipv6address().
◆ ui2str()
Definition at line 854 of file uri.c.
Referenced by canonicalize_port(), and generate_raw_uri().
◆ Uri_AddRef()
◆ Uri_Construct()
Definition at line 5656 of file uri.c.
5657{
5659
5661
5662 *ppobj = ret;
5665
5670 ret->ref = 1;
5671
5672 *ppobj = &ret->IUri_iface;
5674}
static const IUriBuilderFactoryVtbl UriBuilderFactoryVtbl
Definition: uri.c:5119
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 4948 of file uri.c.
4949{
4952
4955 if(!pdwProperties)
4957
4958 /* All URIs have these. */
4959 *pdwProperties = Uri_HAS_DISPLAY_URI|Uri_HAS_RAW_URI|Uri_HAS_SCHEME|Uri_HAS_HOST_TYPE;
4960
4962 *pdwProperties |= Uri_HAS_ABSOLUTE_URI;
4963
4965 *pdwProperties |= Uri_HAS_SCHEME_NAME;
4966
4968 *pdwProperties |= Uri_HAS_AUTHORITY;
4970 *pdwProperties |= Uri_HAS_USER_INFO;
4972 *pdwProperties |= Uri_HAS_USER_NAME;
4973 }
4975 *pdwProperties |= Uri_HAS_PASSWORD;
4977 *pdwProperties |= Uri_HAS_HOST;
4979 *pdwProperties |= Uri_HAS_DOMAIN;
4980 }
4981
4983 *pdwProperties |= Uri_HAS_PORT;
4985 *pdwProperties |= Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY;
4987 *pdwProperties |= Uri_HAS_QUERY|Uri_HAS_PATH_AND_QUERY;
4988
4990 *pdwProperties |= Uri_HAS_EXTENSION;
4991
4993 *pdwProperties |= Uri_HAS_FRAGMENT;
4994
4996}
◆ Uri_GetPropertyBSTR()
|
static |
Definition at line 4274 of file uri.c.
4275{
4278 TRACE("(%p %s)->(%d %p %x)\n", This, debugstr_w(This->canon_uri), uriProp, pbstrProperty, dwFlags);
4279
4282 if(!pbstrProperty)
4284
4285 if(uriProp > Uri_PROPERTY_STRING_LAST) {
4286 /* It only returns S_FALSE for the ZONE property... */
4287 if(uriProp == Uri_PROPERTY_ZONE) {
4289 if(!(*pbstrProperty))
4292 }
4293
4294 *pbstrProperty = NULL;
4296 }
4297
4298 /* Don't have support for flags yet. */
4302 }
4303
4304 switch(uriProp) {
4305 case Uri_PROPERTY_ABSOLUTE_URI:
4309 } else {
4312 /* Don't include the '@' after the userinfo component. */
4315 if(*pbstrProperty) {
4316 /* Copy everything before it. */
4318
4319 /* And everything after it. */
4322 }
4324 /* Don't include the ":@" */
4327 if(*pbstrProperty) {
4331 }
4332 } else {
4335 }
4336 } else {
4339 }
4340 }
4341
4342 if(!(*pbstrProperty))
4344
4345 break;
4346 case Uri_PROPERTY_AUTHORITY:
4350 /* Don't include the port in the authority component. */
4352 else
4353 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->authority_start, This->authority_len);
4355 } else {
4358 }
4359
4360 if(!(*pbstrProperty))
4362
4363 break;
4364 case Uri_PROPERTY_DISPLAY_URI:
4365 /* The Display URI contains everything except for the userinfo for known
4366 * scheme types.
4367 */
4370
4371 if(*pbstrProperty) {
4372 /* Copy everything before the userinfo over. */
4374 /* Copy everything after the userinfo over. */
4378 }
4379 } else
4381
4382 if(!(*pbstrProperty))
4384 else
4386
4387 break;
4388 case Uri_PROPERTY_DOMAIN:
4393 } else {
4396 }
4397
4398 if(!(*pbstrProperty))
4400
4401 break;
4402 case Uri_PROPERTY_EXTENSION:
4407 } else {
4410 }
4411
4412 if(!(*pbstrProperty))
4414
4415 break;
4416 case Uri_PROPERTY_FRAGMENT:
4420 } else {
4423 }
4424
4425 if(!(*pbstrProperty))
4427
4428 break;
4429 case Uri_PROPERTY_HOST:
4431 /* The '[' and ']' aren't included for IPv6 addresses. */
4434 else
4436
4438 } else {
4441 }
4442
4443 if(!(*pbstrProperty))
4445
4446 break;
4447 case Uri_PROPERTY_PASSWORD:
4449 *pbstrProperty = SysAllocStringLen(
4453 } else {
4456 }
4457
4458 if(!(*pbstrProperty))
4460
4461 break;
4462 case Uri_PROPERTY_PATH:
4466 } else {
4469 }
4470
4471 if(!(*pbstrProperty))
4473
4474 break;
4475 case Uri_PROPERTY_PATH_AND_QUERY:
4477 *pbstrProperty = SysAllocStringLen(This->canon_uri+This->path_start, This->path_len+This->query_len);
4482 } else {
4485 }
4486
4487 if(!(*pbstrProperty))
4489
4490 break;
4491 case Uri_PROPERTY_QUERY:
4495 } else {
4498 }
4499
4500 if(!(*pbstrProperty))
4502
4503 break;
4504 case Uri_PROPERTY_RAW_URI:
4506 if(!(*pbstrProperty))
4508 else
4510 break;
4511 case Uri_PROPERTY_SCHEME_NAME:
4515 } else {
4518 }
4519
4520 if(!(*pbstrProperty))
4522
4523 break;
4524 case Uri_PROPERTY_USER_INFO:
4528 } else {
4531 }
4532
4533 if(!(*pbstrProperty))
4535
4536 break;
4537 case Uri_PROPERTY_USER_NAME:
4539 /* If userinfo_split is set, that means a password exists
4540 * so the username is only from userinfo_start to userinfo_split.
4541 */
4543 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->userinfo_start, This->userinfo_split);
4545 } else {
4546 *pbstrProperty = SysAllocStringLen(This->canon_uri + This->userinfo_start, This->userinfo_len);
4548 }
4549 } else {
4552 }
4553
4554 if(!(*pbstrProperty))
4556
4557 break;
4558 default:
4561 }
4562
4564}
◆ Uri_GetPropertyDWORD()
|
static |
Definition at line 4702 of file uri.c.
4703{
4706
4707 TRACE("(%p %s)->(%d %p %x)\n", This, debugstr_w(This->canon_uri), uriProp, pcchProperty, dwFlags);
4708
4711 if(!pcchProperty)
4713
4714 /* Microsoft's implementation for the ZONE property of a URI seems to be lacking...
4715 * From what I can tell, instead of checking which URLZONE the URI belongs to it
4716 * simply assigns URLZONE_INVALID and returns E_NOTIMPL. This also applies to the GetZone
4717 * function.
4718 */
4719 if(uriProp == Uri_PROPERTY_ZONE) {
4720 *pcchProperty = URLZONE_INVALID;
4722 }
4723
4724 if(uriProp < Uri_PROPERTY_DWORD_START) {
4725 *pcchProperty = 0;
4727 }
4728
4729 switch(uriProp) {
4730 case Uri_PROPERTY_HOST_TYPE:
4731 *pcchProperty = This->host_type;
4733 break;
4734 case Uri_PROPERTY_PORT:
4736 *pcchProperty = 0;
4738 } else {
4739 *pcchProperty = This->port;
4741 }
4742
4743 break;
4744 case Uri_PROPERTY_SCHEME:
4745 *pcchProperty = This->scheme_type;
4747 break;
4748 default:
4751 }
4752
4754}
◆ Uri_GetPropertyLength()
|
static |
Definition at line 4566 of file uri.c.
4567{
4570 TRACE("(%p %s)->(%d %p %x)\n", This, debugstr_w(This->canon_uri), uriProp, pcchProperty, dwFlags);
4571
4574 if(!pcchProperty)
4576
4577 /* Can only return a length for a property if it's a string. */
4578 if(uriProp > Uri_PROPERTY_STRING_LAST)
4580
4581 /* Don't have support for flags yet. */
4585 }
4586
4587 switch(uriProp) {
4588 case Uri_PROPERTY_ABSOLUTE_URI:
4590 *pcchProperty = 0;
4592 } else {
4595 /* Don't include the '@' in the length. */
4596 *pcchProperty = This->canon_len-1;
4598 This->userinfo_split == 0)
4599 /* Don't include the ":@" in the length. */
4600 *pcchProperty = This->canon_len-2;
4601 else
4602 *pcchProperty = This->canon_len;
4603 } else
4604 *pcchProperty = This->canon_len;
4605
4607 }
4608
4609 break;
4610 case Uri_PROPERTY_AUTHORITY:
4614 /* Only count up until the port in the authority. */
4615 *pcchProperty = This->port_offset;
4616 else
4617 *pcchProperty = This->authority_len;
4619 break;
4620 case Uri_PROPERTY_DISPLAY_URI:
4623 else
4624 *pcchProperty = This->canon_len;
4625
4627 break;
4628 case Uri_PROPERTY_DOMAIN:
4631 else
4632 *pcchProperty = 0;
4633
4635 break;
4636 case Uri_PROPERTY_EXTENSION:
4640 } else {
4641 *pcchProperty = 0;
4643 }
4644
4645 break;
4646 case Uri_PROPERTY_FRAGMENT:
4647 *pcchProperty = This->fragment_len;
4649 break;
4650 case Uri_PROPERTY_HOST:
4651 *pcchProperty = This->host_len;
4652
4653 /* '[' and ']' aren't included in the length. */
4655 *pcchProperty -= 2;
4656
4658 break;
4659 case Uri_PROPERTY_PASSWORD:
4662 break;
4663 case Uri_PROPERTY_PATH:
4664 *pcchProperty = This->path_len;
4666 break;
4667 case Uri_PROPERTY_PATH_AND_QUERY:
4670 break;
4671 case Uri_PROPERTY_QUERY:
4672 *pcchProperty = This->query_len;
4674 break;
4675 case Uri_PROPERTY_RAW_URI:
4678 break;
4679 case Uri_PROPERTY_SCHEME_NAME:
4680 *pcchProperty = This->scheme_len;
4682 break;
4683 case Uri_PROPERTY_USER_INFO:
4684 *pcchProperty = This->userinfo_len;
4686 break;
4687 case Uri_PROPERTY_USER_NAME:
4691 else
4693 break;
4694 default:
4697 }
4698
4700}
◆ Uri_GetQuery()
◆ Uri_GetRawUri()
◆ Uri_GetScheme()
◆ Uri_GetSchemeName()
◆ Uri_GetUserInfo()
◆ Uri_GetUserName()
◆ Uri_GetZone()
◆ Uri_HasProperty()
|
static |
Definition at line 4756 of file uri.c.
4757{
4759
4761
4762 if(!pfHasProperty)
4764
4765 switch(uriProp) {
4766 case Uri_PROPERTY_ABSOLUTE_URI:
4768 break;
4769 case Uri_PROPERTY_AUTHORITY:
4770 *pfHasProperty = This->authority_start > -1;
4771 break;
4772 case Uri_PROPERTY_DISPLAY_URI:
4773 *pfHasProperty = TRUE;
4774 break;
4775 case Uri_PROPERTY_DOMAIN:
4776 *pfHasProperty = This->domain_offset > -1;
4777 break;
4778 case Uri_PROPERTY_EXTENSION:
4779 *pfHasProperty = This->extension_offset > -1;
4780 break;
4781 case Uri_PROPERTY_FRAGMENT:
4782 *pfHasProperty = This->fragment_start > -1;
4783 break;
4784 case Uri_PROPERTY_HOST:
4785 *pfHasProperty = This->host_start > -1;
4786 break;
4787 case Uri_PROPERTY_PASSWORD:
4788 *pfHasProperty = This->userinfo_split > -1;
4789 break;
4790 case Uri_PROPERTY_PATH:
4791 *pfHasProperty = This->path_start > -1;
4792 break;
4793 case Uri_PROPERTY_PATH_AND_QUERY:
4795 break;
4796 case Uri_PROPERTY_QUERY:
4797 *pfHasProperty = This->query_start > -1;
4798 break;
4799 case Uri_PROPERTY_RAW_URI:
4800 *pfHasProperty = TRUE;
4801 break;
4802 case Uri_PROPERTY_SCHEME_NAME:
4803 *pfHasProperty = This->scheme_start > -1;
4804 break;
4805 case Uri_PROPERTY_USER_INFO:
4806 *pfHasProperty = This->userinfo_start > -1;
4807 break;
4808 case Uri_PROPERTY_USER_NAME:
4810 *pfHasProperty = FALSE;
4811 else
4812 *pfHasProperty = This->userinfo_start > -1;
4813 break;
4814 case Uri_PROPERTY_HOST_TYPE:
4815 *pfHasProperty = TRUE;
4816 break;
4817 case Uri_PROPERTY_PORT:
4818 *pfHasProperty = This->has_port;
4819 break;
4820 case Uri_PROPERTY_SCHEME:
4821 *pfHasProperty = TRUE;
4822 break;
4823 case Uri_PROPERTY_ZONE:
4824 *pfHasProperty = FALSE;
4825 break;
4826 default:
4829 }
4830
4832}
◆ Uri_IsEqual()
Definition at line 4998 of file uri.c.
4999{
5002
5004
5007 if(!pfEqual)
5009
5010 if(!pUri) {
5011 *pfEqual = FALSE;
5012
5013 /* For some reason Windows returns S_OK here... */
5015 }
5016
5017 /* Try to convert it to a Uri (allows for a more simple comparison). */
5021 }
5022
5025}
static HRESULT compare_uris(const Uri *a, const Uri *b, BOOL *ret)
Definition: uri.c:3923
◆ Uri_QueryInterface()
◆ Uri_Release()
◆ UriBuilder_AddRef()
|
static |
Definition at line 5933 of file uri.c.
5934{
5937
5939
5941}
static UriBuilder * impl_from_IUriBuilder(IUriBuilder *iface)
Definition: uri.c:5908
◆ UriBuilder_CreateUri()
|
static |
Definition at line 5980 of file uri.c.
5985{
5988 TRACE("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5989
5990 if(dwCreateFlags == -1)
5992 else
5994
5996 FIXME("(%p)->(0x%08x %d %d %p)\n", This, dwCreateFlags, dwAllowEncodingPropertyMask, (DWORD)dwReserved, ppIUri);
5998}
static HRESULT build_uri(const UriBuilder *builder, IUri **uri, DWORD create_flags, DWORD use_orig_flags, DWORD encoding_mask)
Definition: uri.c:5850
◆ UriBuilder_CreateUriSimple()
|
static |
◆ UriBuilder_CreateUriWithFlags()
|
static |
◆ UriBuilder_GetFragment()
|
static |
Definition at line 6069 of file uri.c.
6070{
6073
6075 return get_builder_component(&This->fragment, &This->fragment_len, NULL, 0, ppwzFragment, pcchFragment);
6076 else
6077 return get_builder_component(&This->fragment, &This->fragment_len, This->uri->canon_uri+This->uri->fragment_start,
6078 This->uri->fragment_len, ppwzFragment, pcchFragment);
6079}
static HRESULT get_builder_component(LPWSTR *component, DWORD *component_len, LPCWSTR source, DWORD source_len, LPCWSTR *output, DWORD *output_len)
Definition: uri.c:3438
◆ UriBuilder_GetHost()
|
static |
Definition at line 6081 of file uri.c.
6082{
6085
6088 else {
6090 /* Don't include the '[' and ']' around the address. */
6091 return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start+1,
6092 This->uri->host_len-2, ppwzHost, pcchHost);
6093 else
6094 return get_builder_component(&This->host, &This->host_len, This->uri->canon_uri+This->uri->host_start,
6095 This->uri->host_len, ppwzHost, pcchHost);
6096 }
6097}
◆ UriBuilder_GetIUri()
|
static |
◆ UriBuilder_GetPassword()
|
static |
Definition at line 6099 of file uri.c.
6100{
6103
6105 return get_builder_component(&This->password, &This->password_len, NULL, 0, ppwzPassword, pcchPassword);
6106 else {
6107 const WCHAR *start = This->uri->canon_uri+This->uri->userinfo_start+This->uri->userinfo_split+1;
6109 return get_builder_component(&This->password, &This->password_len, start, len, ppwzPassword, pcchPassword);
6110 }
6111}
◆ UriBuilder_GetPath()
|
static |
◆ UriBuilder_GetPort()
|
static |
◆ UriBuilder_GetQuery()
|
static |
◆ UriBuilder_GetSchemeName()
|
static |
Definition at line 6158 of file uri.c.
6159{
6162
6164 return get_builder_component(&This->scheme, &This->scheme_len, NULL, 0, ppwzSchemeName, pcchSchemeName);
6165 else
6166 return get_builder_component(&This->scheme, &This->scheme_len, This->uri->canon_uri+This->uri->scheme_start,
6167 This->uri->scheme_len, ppwzSchemeName, pcchSchemeName);
6168}
◆ UriBuilder_GetUserName()
|
static |
Definition at line 6170 of file uri.c.
6171{
6174
6176 This->modified_props & Uri_HAS_USER_NAME)
6177 return get_builder_component(&This->username, &This->username_len, NULL, 0, ppwzUserName, pcchUserName);
6178 else {
6180
6181 /* Check if there's a password in the userinfo section. */
6183 /* Don't include the password. */
6185 This->uri->userinfo_split, ppwzUserName, pcchUserName);
6186 else
6188 This->uri->userinfo_len, ppwzUserName, pcchUserName);
6189 }
6190}
◆ UriBuilder_HasBeenModified()
|
static |
◆ UriBuilder_QueryInterface()
|
static |
◆ UriBuilder_Release()
|
static |
◆ UriBuilder_RemoveProperties()
|
static |
Definition at line 6269 of file uri.c.
6270{
6271 const DWORD accepted_flags = Uri_HAS_AUTHORITY|Uri_HAS_DOMAIN|Uri_HAS_EXTENSION|Uri_HAS_FRAGMENT|Uri_HAS_HOST|
6272 Uri_HAS_PASSWORD|Uri_HAS_PATH|Uri_HAS_PATH_AND_QUERY|Uri_HAS_QUERY|
6273 Uri_HAS_USER_INFO|Uri_HAS_USER_NAME;
6274
6277
6278 if(dwPropertyMask & ~accepted_flags)
6280
6281 if(dwPropertyMask & Uri_HAS_FRAGMENT)
6283
6284 /* Even though you can't set the host name to NULL or an
6285 * empty string, you can still remove it... for some reason.
6286 */
6287 if(dwPropertyMask & Uri_HAS_HOST)
6289 &This->modified_props, Uri_HAS_HOST);
6290
6291 if(dwPropertyMask & Uri_HAS_PASSWORD)
6293
6294 if(dwPropertyMask & Uri_HAS_PATH)
6296
6297 if(dwPropertyMask & Uri_HAS_PORT)
6299
6300 if(dwPropertyMask & Uri_HAS_QUERY)
6302
6303 if(dwPropertyMask & Uri_HAS_USER_NAME)
6305
6307}
static HRESULT WINAPI UriBuilder_SetPath(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6221
static HRESULT WINAPI UriBuilder_SetPort(IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
Definition: uri.c:6229
static HRESULT WINAPI UriBuilder_SetPassword(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6213
static HRESULT WINAPI UriBuilder_SetFragment(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6192
static HRESULT WINAPI UriBuilder_SetUserName(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6261
static HRESULT set_builder_component(LPWSTR *component, DWORD *component_len, LPCWSTR new_value, WCHAR prefix, DWORD *flags, DWORD success_flag)
Definition: uri.c:3477
static HRESULT WINAPI UriBuilder_SetQuery(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6240
◆ UriBuilder_SetFragment()
|
static |
Definition at line 6192 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetHost()
|
static |
◆ UriBuilder_SetIUri()
|
static |
Definition at line 6037 of file uri.c.
6038{
6041
6042 if(pIUri) {
6044
6046 /* Only reset the builder if its Uri isn't the same as
6047 * the Uri passed to the function.
6048 */
6051
6055
6056 IUri_AddRef(pIUri);
6057 }
6058 } else {
6061 }
6063 /* Only reset the builder if its Uri isn't NULL. */
6065
6067}
◆ UriBuilder_SetPassword()
|
static |
Definition at line 6213 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetPath()
|
static |
Definition at line 6221 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetPort()
|
static |
◆ UriBuilder_SetQuery()
|
static |
Definition at line 6240 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilder_SetSchemeName()
|
static |
◆ UriBuilder_SetUserName()
|
static |
Definition at line 6261 of file uri.c.
Referenced by UriBuilder_RemoveProperties().
◆ UriBuilderFactory_AddRef()
|
static |
Definition at line 5069 of file uri.c.
5070{
5073}
static Uri * impl_from_IUriBuilderFactory(IUriBuilderFactory *iface)
Definition: uri.c:5058
◆ UriBuilderFactory_CreateInitializedIUriBuilder()
|
static |
Definition at line 5100 of file uri.c.
5104{
5107
5108 if(!ppIUriBuilder)
5110
5112 *ppIUriBuilder = NULL;
5114 }
5115
5117}
HRESULT WINAPI CreateIUriBuilder(IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
Definition: uri.c:6353
◆ UriBuilderFactory_CreateIUriBuilder()
|
static |
◆ UriBuilderFactory_QueryInterface()
|
static |
◆ UriBuilderFactory_Release()
|
static |
◆ validate_components()
|
static |
Definition at line 3820 of file uri.c.
3820 {
3822
3824
3826
3830
3831 /* Extra validation for file schemes. */
3837 return INET_E_INVALID_URL;
3838 }
3839 }
3840
3844
3848
3850
3851 /* The URI is opaque if it doesn't have an authority component. */
3855 else
3857
3861
3865
3869
3871
3873}
static HRESULT validate_host(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3668
static HRESULT validate_path(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3715
static HRESULT validate_userinfo(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3654
static HRESULT validate_query(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3758
static void setup_port(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3700
static HRESULT validate_fragment(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3789
static HRESULT validate_scheme_name(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3548
Referenced by build_uri().
◆ validate_fragment()
|
static |
Definition at line 3789 of file uri.c.
3789 {
3792 DWORD expected_len;
3793
3796 expected_len = builder->fragment_len;
3801 }
3802
3805 pptr = &ptr;
3806
3810 else {
3812 debugstr_wn(component, expected_len));
3813 return INET_E_INVALID_URL;
3814 }
3815 }
3816
3818}
Referenced by validate_components().
◆ validate_host()
|
static |
Definition at line 3668 of file uri.c.
3668 {
3671 DWORD expected_len;
3672
3675 expected_len = builder->host_len;
3676 } else if(!(builder->modified_props & Uri_HAS_HOST) && builder->uri && builder->uri->host_start > -1) {
3679 } else
3681
3685 pptr = &ptr;
3686
3690 else {
3692 debugstr_wn(component, expected_len));
3693 return INET_E_INVALID_URL;
3694 }
3695 }
3696
3698}
Referenced by validate_components().
◆ validate_password()
|
static |
Definition at line 3619 of file uri.c.
3619 {
3622 DWORD expected_len;
3623
3626 expected_len = builder->password_len;
3629 data->password = builder->uri->canon_uri+builder->uri->userinfo_start+builder->uri->userinfo_split+1;
3632 } else {
3634 expected_len = 0;
3635 }
3636
3639 pptr = &ptr;
3641 data->password_len == expected_len)
3644 else {
3646 debugstr_wn(component, expected_len));
3647 return INET_E_INVALID_URL;
3648 }
3649 }
3650
3652}
Referenced by validate_userinfo().
◆ validate_path()
|
static |
Definition at line 3715 of file uri.c.
3715 {
3719 DWORD expected_len;
3722
3725 expected_len = builder->path_len;
3730 } else {
3733 check_len = FALSE;
3734 expected_len = -1;
3735 }
3736
3737 component = ptr;
3738 pptr = &ptr;
3739
3740 /* How the path is validated depends on what type of
3741 * URI it is.
3742 */
3745
3748 debugstr_wn(component, expected_len) );
3749 return INET_E_INVALID_URL;
3750 }
3751
3754
3756}
Referenced by validate_components().
◆ validate_query()
|
static |
Definition at line 3758 of file uri.c.
3758 {
3761 DWORD expected_len;
3762
3765 expected_len = builder->query_len;
3770 }
3771
3774 pptr = &ptr;
3775
3779 else {
3781 debugstr_wn(component, expected_len));
3782 return INET_E_INVALID_URL;
3783 }
3784 }
3785
3787}
Referenced by validate_components().
◆ validate_scheme_name()
|
static |
Definition at line 3548 of file uri.c.
3548 {
3552 DWORD expected_len;
3553
3556 expected_len = builder->scheme_len;
3560 } else {
3563 expected_len = 0;
3564 }
3565
3566 component = ptr;
3567 pptr = &ptr;
3569 data->scheme_len == expected_len) {
3573 } else {
3575 debugstr_wn(component, expected_len));
3576 return INET_E_INVALID_URL;
3577 }
3578
3580}
Referenced by validate_components().
◆ validate_userinfo()
|
static |
Definition at line 3654 of file uri.c.
3654 {
3656
3660
3664
3666}
static HRESULT validate_password(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3619
static HRESULT validate_username(const UriBuilder *builder, parse_data *data, DWORD flags)
Definition: uri.c:3582
Referenced by validate_components().
◆ validate_username()
|
static |
Definition at line 3582 of file uri.c.
3582 {
3585 DWORD expected_len;
3586
3589 expected_len = builder->username_len;
3592 /* Just use the username from the base Uri. */
3597 } else {
3599 expected_len = 0;
3600 }
3601
3604 pptr = &ptr;
3606 data->username_len == expected_len)
3609 else {
3611 debugstr_wn(component, expected_len));
3612 return INET_E_INVALID_URL;
3613 }
3614 }
3615
3617}
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 194 of file uri.c.
Referenced by pct_encode_val().
◆ IID_IUriObj
Definition at line 48 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:5605
static HRESULT WINAPI Marshal_MarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
Definition: uri.c:5494
static HRESULT WINAPI Marshal_GetUnmarshalClass(IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
Definition: uri.c:5443
static HRESULT WINAPI Marshal_DisconnectObject(IMarshal *iface, DWORD dwReserved)
Definition: uri.c:5637
static HRESULT WINAPI Marshal_GetMarshalSizeMax(IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
Definition: uri.c:5465
static HRESULT WINAPI Marshal_UnmarshalInterface(IMarshal *iface, IStream *pStm, REFIID riid, void **ppv)
Definition: uri.c:5547
static HRESULT WINAPI Marshal_QueryInterface(IMarshal *iface, REFIID riid, void **ppvObject)
Definition: uri.c:5425
Definition at line 5644 of file uri.c.
Referenced by Uri_Construct().
◆ PersistStreamVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI PersistStream_IsDirty(IPersistStream *iface)
Definition: uri.c:5162
static HRESULT WINAPI PersistStream_Load(IPersistStream *iface, IStream *pStm)
Definition: uri.c:5178
static ULONG WINAPI PersistStream_Release(IPersistStream *iface)
Definition: uri.c:5144
static HRESULT WINAPI PersistStream_Save(IPersistStream *iface, IStream *pStm, BOOL fClearDirty)
Definition: uri.c:5337
static HRESULT WINAPI PersistStream_GetClassID(IPersistStream *iface, CLSID *pClassID)
Definition: uri.c:5150
static ULONG WINAPI PersistStream_AddRef(IPersistStream *iface)
Definition: uri.c:5138
static HRESULT WINAPI PersistStream_GetSizeMax(IPersistStream *iface, ULARGE_INTEGER *pcbSize)
Definition: uri.c:5364
static HRESULT WINAPI PersistStream_QueryInterface(IPersistStream *iface, REFIID riid, void **ppvObject)
Definition: uri.c:5132
Definition at line 5409 of file uri.c.
Referenced by Uri_Construct().
◆ port
| USHORT port |
Definition at line 228 of file uri.c.
Referenced by __rpc_taddr2uaddr_af(), __rpc_uaddr2taddr_af(), __rpcb_findaddr_timed(), _open_simple_request(), _test_completion(), add_host_header(), AddrStrToAddr(), AtlCreateTargetDC(), BindToEphemeralPortNumber(), calc_url_length(), client(), compare_RtlIpv6StringToAddressExW(), connections_on_initdialog(), create_system_ports_list(), dmusic_remove_port(), EISA_ELCR_Read(), FileToURL(), FTPDecodeURL(), fw_ports_Add(), get_server(), get_url_length(), GetAddress(), getservbyport(), handle_redirect(), hookup(), HTMLLocation_get_port(), HTTP_HttpOpenRequestW(), HttpProtocol_open_request(), IDirectMusic8Impl_CreatePort(), init(), init_TCPIP_provider(), InstallSubdevice(), InternetCheckConnectionW(), 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(), 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_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_completion(), test_CompletionPort(), test_conn_close(), test_connection_break(), test_connection_closing(), test_connection_header(), test_connection_info(), test_cookie_header(), test_cookies(), test_DeviceCapabilities(), test_EnumAddressTypes(), test_file_completion_information(), test_GetAddrInfoW(), 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_large_content(), test_large_data_authentication(), test_long_url(), test_multi_authentication(), test_multiple_reads(), test_no_cache(), test_no_content(), test_no_headers(), test_not_modified(), test_options(), test_passport_auth(), test_persistent_connection(), test_ports_client(), test_premature_disconnect(), test_PrintDlgA(), test_proxy_direct(), test_proxy_indirect(), 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(), 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[] |
Initial value:
= {
{{'c','o','m',0}},
{{'e','d','u',0}},
{{'g','o','v',0}},
{{'i','n','t',0}},
{{'m','i','l',0}},
{{'n','e','t',0}},
{{'o','r','g',0}}
}
Referenced by find_domain_name().
◆ scheme
| URL_SCHEME scheme |
Definition at line 198 of file uri.c.
Referenced by canonicalize_port(), is_default_port(), and is_path_delim().
◆ scheme_name
| WCHAR scheme_name[16] |
Definition at line 199 of file uri.c.
Referenced by parse_scheme_type().
◆ tld_name
| WCHAR tld_name[4] |
Definition at line 243 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:5063
static ULONG WINAPI UriBuilderFactory_AddRef(IUriBuilderFactory *iface)
Definition: uri.c:5069
static ULONG WINAPI UriBuilderFactory_Release(IUriBuilderFactory *iface)
Definition: uri.c:5075
static HRESULT WINAPI UriBuilderFactory_CreateInitializedIUriBuilder(IUriBuilderFactory *iface, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
Definition: uri.c:5100
static HRESULT WINAPI UriBuilderFactory_CreateIUriBuilder(IUriBuilderFactory *iface, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
Definition: uri.c:5081
Definition at line 5119 of file uri.c.
Referenced by Uri_Construct().
◆ UriBuilderVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI UriBuilder_GetIUri(IUriBuilder *iface, IUri **ppIUri)
Definition: uri.c:6019
static HRESULT WINAPI UriBuilder_GetPort(IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
Definition: uri.c:6125
static HRESULT WINAPI UriBuilder_GetUserName(IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
Definition: uri.c:6170
static HRESULT WINAPI UriBuilder_RemoveProperties(IUriBuilder *iface, DWORD dwPropertyMask)
Definition: uri.c:6269
static HRESULT WINAPI UriBuilder_GetQuery(IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
Definition: uri.c:6146
static HRESULT WINAPI UriBuilder_CreateUriWithFlags(IUriBuilder *iface, DWORD dwCreateFlags, DWORD dwUriBuilderFlags, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
Definition: uri.c:6000
static HRESULT WINAPI UriBuilder_GetPath(IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
Definition: uri.c:6113
static HRESULT WINAPI UriBuilder_SetIUri(IUriBuilder *iface, IUri *pIUri)
Definition: uri.c:6037
static HRESULT WINAPI UriBuilder_QueryInterface(IUriBuilder *iface, REFIID riid, void **ppv)
Definition: uri.c:5913
static HRESULT WINAPI UriBuilder_SetSchemeName(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6248
static HRESULT WINAPI UriBuilder_CreateUri(IUriBuilder *iface, DWORD dwCreateFlags, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
Definition: uri.c:5980
static HRESULT WINAPI UriBuilder_GetFragment(IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
Definition: uri.c:6069
static HRESULT WINAPI UriBuilder_CreateUriSimple(IUriBuilder *iface, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
Definition: uri.c:5965
static HRESULT WINAPI UriBuilder_GetSchemeName(IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
Definition: uri.c:6158
static HRESULT WINAPI UriBuilder_HasBeenModified(IUriBuilder *iface, BOOL *pfModified)
Definition: uri.c:6309
static HRESULT WINAPI UriBuilder_SetHost(IUriBuilder *iface, LPCWSTR pwzNewValue)
Definition: uri.c:6200
static HRESULT WINAPI UriBuilder_GetPassword(IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
Definition: uri.c:6099
static HRESULT WINAPI UriBuilder_GetHost(IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
Definition: uri.c:6081
Definition at line 6321 of file uri.c.
Referenced by CreateIUriBuilder().
◆ UriVtbl
|
static |
Initial value:
= {
}
static HRESULT WINAPI Uri_GetPathAndQuery(IUri *iface, BSTR *pstrPathAndQuery)
Definition: uri.c:4888
static HRESULT WINAPI Uri_GetPropertyDWORD(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
Definition: uri.c:4702
static HRESULT WINAPI Uri_GetAbsoluteUri(IUri *iface, BSTR *pstrAbsoluteUri)
Definition: uri.c:4834
static HRESULT WINAPI Uri_HasProperty(IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty)
Definition: uri.c:4756
static HRESULT WINAPI Uri_GetProperties(IUri *iface, DWORD *pdwProperties)
Definition: uri.c:4948
static HRESULT WINAPI Uri_IsEqual(IUri *iface, IUri *pUri, BOOL *pfEqual)
Definition: uri.c:4998
static HRESULT WINAPI Uri_GetDomain(IUri *iface, BSTR *pstrDomain)
Definition: uri.c:4852
static HRESULT WINAPI Uri_GetPropertyBSTR(IUri *iface, Uri_PROPERTY uriProp, BSTR *pbstrProperty, DWORD dwFlags)
Definition: uri.c:4274
static HRESULT WINAPI Uri_GetPropertyLength(IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
Definition: uri.c:4566
static HRESULT WINAPI Uri_GetUserInfo(IUri *iface, BSTR *pstrUserInfo)
Definition: uri.c:4912
static HRESULT WINAPI Uri_GetPassword(IUri *iface, BSTR *pstrPassword)
Definition: uri.c:4876
static HRESULT WINAPI Uri_GetScheme(IUri *iface, DWORD *pdwScheme)
Definition: uri.c:4936
static HRESULT WINAPI Uri_GetUserName(IUri *iface, BSTR *pstrUserName)
Definition: uri.c:4918
static HRESULT WINAPI Uri_GetExtension(IUri *iface, BSTR *pstrExtension)
Definition: uri.c:4858
static HRESULT WINAPI Uri_GetFragment(IUri *iface, BSTR *pstrFragment)
Definition: uri.c:4864
static HRESULT WINAPI Uri_GetAuthority(IUri *iface, BSTR *pstrAuthority)
Definition: uri.c:4840
static HRESULT WINAPI Uri_GetRawUri(IUri *iface, BSTR *pstrRawUri)
Definition: uri.c:4900
static HRESULT WINAPI Uri_GetSchemeName(IUri *iface, BSTR *pstrSchemeName)
Definition: uri.c:4906
static HRESULT WINAPI Uri_QueryInterface(IUri *iface, REFIID riid, void **ppv)
Definition: uri.c:4218
static HRESULT WINAPI Uri_GetDisplayUri(IUri *iface, BSTR *pstrDisplayUri)
Definition: uri.c:4846
static HRESULT WINAPI Uri_GetHostType(IUri *iface, DWORD *pdwHostType)
Definition: uri.c:4924
Definition at line 5027 of file uri.c.
Referenced by Uri_Construct().
