uri.c File Reference

#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

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (urlmon)
static Uri *	get_uri_obj (IUri *uri)
static BOOL	is_alpha (WCHAR val)
static BOOL	is_num (WCHAR val)
static BOOL	is_drive_path (const WCHAR *str)
static BOOL	is_unc_path (const WCHAR *str)
static BOOL	is_forbidden_dos_path_char (WCHAR val)
static BOOL	is_implicit_file_path (const WCHAR *str)
static BOOL	check_hierarchical (const WCHAR **ptr)
static BOOL	is_unreserved (WCHAR val)
static BOOL	is_subdelim (WCHAR val)
static BOOL	is_gendelim (WCHAR val)
static BOOL	is_auth_delim (WCHAR val, BOOL acceptSlash)
static BOOL	is_reserved (WCHAR val)
static BOOL	is_hexdigit (WCHAR val)
static BOOL	is_path_delim (URL_SCHEME scheme, WCHAR val)
static BOOL	is_slash (WCHAR c)
static BOOL	is_ascii (WCHAR c)
static BOOL	is_default_port (URL_SCHEME scheme, DWORD port)
static BOOL	is_hierarchical_scheme (URL_SCHEME type)
static BOOL	has_invalid_flag_combination (DWORD flags)
static void	apply_default_flags (DWORD *flags)
static BOOL	is_hierarchical_uri (const WCHAR **ptr, const parse_data *data)
static void	compute_ipv6_comps_size (ipv6_address *address)
static int	hex_to_int (WCHAR val)
static WCHAR	decode_pct_val (const WCHAR *ptr)
static void	pct_encode_val (WCHAR val, WCHAR *dest)
void	find_domain_name (const WCHAR *host, DWORD host_len, INT *domain_start)
static DWORD	remove_dot_segments (WCHAR *path, DWORD path_len)
static INT	find_file_extension (const WCHAR *path, DWORD path_len)
static void	compute_elision_location (const ipv6_address *address, const USHORT values[8], INT *index, DWORD *count)
static BSTR	pre_process_uri (LPCWSTR uri)
static UINT	ipv4toui (const WCHAR *ip, DWORD len)
static DWORD	ui2ipv4 (WCHAR *dest, UINT address)
static DWORD	ui2str (WCHAR *dest, UINT value)
static USHORT	h16tous (h16 component)
static BOOL	ipv6_to_number (const ipv6_address *address, USHORT number[8])
static BOOL	check_pct_encoded (const WCHAR **ptr)
static BOOL	check_dec_octet (const WCHAR **ptr)
static BOOL	check_implicit_ipv4 (const WCHAR **ptr, UINT *val)
static BOOL	check_ipv4address (const WCHAR **ptr, BOOL strict)
static BOOL	parse_scheme_name (const WCHAR **ptr, parse_data *data, DWORD extras)
static BOOL	parse_scheme_type (parse_data *data)
static BOOL	parse_scheme (const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
static BOOL	parse_username (const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
static BOOL	parse_password (const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
static void	parse_userinfo (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_port (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_ipv4address (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_reg_name (const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
static BOOL	parse_ipv6address (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_ipvfuture (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_ip_literal (const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
static BOOL	parse_host (const WCHAR **ptr, parse_data *data, DWORD flags, DWORD extras)
static BOOL	parse_authority (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_path_hierarchical (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_path_opaque (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_hierpart (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_query (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_fragment (const WCHAR **ptr, parse_data *data, DWORD flags)
static BOOL	parse_uri (parse_data *data, DWORD flags)
static BOOL	canonicalize_username (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_password (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_userinfo (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_reg_name (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_implicit_ipv4address (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_ipv4address (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_ipv6address (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_host (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_port (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_authority (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
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)
static BOOL	canonicalize_path_opaque (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_hierpart (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_query (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_fragment (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static BOOL	canonicalize_scheme (const parse_data *data, Uri *uri, DWORD flags, BOOL computeOnly)
static int	compute_canonicalized_length (const parse_data *data, DWORD flags)
static HRESULT	canonicalize_uri (const parse_data *data, Uri *uri, DWORD flags)
static HRESULT	get_builder_component (LPWSTR *component, DWORD *component_len, LPCWSTR source, DWORD source_len, LPCWSTR *output, DWORD *output_len)
static HRESULT	set_builder_component (LPWSTR *component, DWORD *component_len, LPCWSTR new_value, WCHAR prefix, DWORD *flags, DWORD success_flag)
static void	reset_builder (UriBuilder *builder)
static HRESULT	validate_scheme_name (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_username (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_password (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_userinfo (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_host (const UriBuilder *builder, parse_data *data, DWORD flags)
static void	setup_port (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_path (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_query (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_fragment (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	validate_components (const UriBuilder *builder, parse_data *data, DWORD flags)
static HRESULT	compare_file_paths (const Uri *a, const Uri *b, BOOL *ret)
static HRESULT	compare_uris (const Uri *a, const Uri *b, BOOL *ret)
static void	convert_to_dos_path (const WCHAR *path, DWORD path_len, WCHAR *output, DWORD *output_len)
static DWORD	generate_raw_uri (const parse_data *data, BSTR uri, DWORD flags)
static HRESULT	generate_uri (const UriBuilder *builder, const parse_data *data, Uri *uri, DWORD flags)
static Uri *	impl_from_IUri (IUri *iface)
static void	destroy_uri_obj (Uri *This)
static HRESULT WINAPI	Uri_QueryInterface (IUri *iface, REFIID riid, void **ppv)
static ULONG WINAPI	Uri_AddRef (IUri *iface)
static ULONG WINAPI	Uri_Release (IUri *iface)
static HRESULT WINAPI	Uri_GetPropertyBSTR (IUri *iface, Uri_PROPERTY uriProp, BSTR *pbstrProperty, DWORD dwFlags)
static HRESULT WINAPI	Uri_GetPropertyLength (IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
static HRESULT WINAPI	Uri_GetPropertyDWORD (IUri *iface, Uri_PROPERTY uriProp, DWORD *pcchProperty, DWORD dwFlags)
static HRESULT WINAPI	Uri_HasProperty (IUri *iface, Uri_PROPERTY uriProp, BOOL *pfHasProperty)
static HRESULT WINAPI	Uri_GetAbsoluteUri (IUri *iface, BSTR *pstrAbsoluteUri)
static HRESULT WINAPI	Uri_GetAuthority (IUri *iface, BSTR *pstrAuthority)
static HRESULT WINAPI	Uri_GetDisplayUri (IUri *iface, BSTR *pstrDisplayUri)
static HRESULT WINAPI	Uri_GetDomain (IUri *iface, BSTR *pstrDomain)
static HRESULT WINAPI	Uri_GetExtension (IUri *iface, BSTR *pstrExtension)
static HRESULT WINAPI	Uri_GetFragment (IUri *iface, BSTR *pstrFragment)
static HRESULT WINAPI	Uri_GetHost (IUri *iface, BSTR *pstrHost)
static HRESULT WINAPI	Uri_GetPassword (IUri *iface, BSTR *pstrPassword)
static HRESULT WINAPI	Uri_GetPath (IUri *iface, BSTR *pstrPath)
static HRESULT WINAPI	Uri_GetPathAndQuery (IUri *iface, BSTR *pstrPathAndQuery)
static HRESULT WINAPI	Uri_GetQuery (IUri *iface, BSTR *pstrQuery)
static HRESULT WINAPI	Uri_GetRawUri (IUri *iface, BSTR *pstrRawUri)
static HRESULT WINAPI	Uri_GetSchemeName (IUri *iface, BSTR *pstrSchemeName)
static HRESULT WINAPI	Uri_GetUserInfo (IUri *iface, BSTR *pstrUserInfo)
static HRESULT WINAPI	Uri_GetUserName (IUri *iface, BSTR *pstrUserName)
static HRESULT WINAPI	Uri_GetHostType (IUri *iface, DWORD *pdwHostType)
static HRESULT WINAPI	Uri_GetPort (IUri *iface, DWORD *pdwPort)
static HRESULT WINAPI	Uri_GetScheme (IUri *iface, DWORD *pdwScheme)
static HRESULT WINAPI	Uri_GetZone (IUri *iface, DWORD *pdwZone)
static HRESULT WINAPI	Uri_GetProperties (IUri *iface, DWORD *pdwProperties)
static HRESULT WINAPI	Uri_IsEqual (IUri *iface, IUri *pUri, BOOL *pfEqual)
static Uri *	impl_from_IUriBuilderFactory (IUriBuilderFactory *iface)
static HRESULT WINAPI	UriBuilderFactory_QueryInterface (IUriBuilderFactory *iface, REFIID riid, void **ppv)
static ULONG WINAPI	UriBuilderFactory_AddRef (IUriBuilderFactory *iface)
static ULONG WINAPI	UriBuilderFactory_Release (IUriBuilderFactory *iface)
static HRESULT WINAPI	UriBuilderFactory_CreateIUriBuilder (IUriBuilderFactory *iface, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
static HRESULT WINAPI	UriBuilderFactory_CreateInitializedIUriBuilder (IUriBuilderFactory *iface, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
static Uri *	impl_from_IPersistStream (IPersistStream *iface)
static HRESULT WINAPI	PersistStream_QueryInterface (IPersistStream *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	PersistStream_AddRef (IPersistStream *iface)
static ULONG WINAPI	PersistStream_Release (IPersistStream *iface)
static HRESULT WINAPI	PersistStream_GetClassID (IPersistStream *iface, CLSID *pClassID)
static HRESULT WINAPI	PersistStream_IsDirty (IPersistStream *iface)
static HRESULT WINAPI	PersistStream_Load (IPersistStream *iface, IStream *pStm)
static BYTE *	persist_stream_add_strprop (Uri *This, BYTE *p, DWORD type, DWORD len, WCHAR *data)
static void	persist_stream_save (Uri *This, IStream *pStm, BOOL marshal, struct persist_uri *data)
static HRESULT WINAPI	PersistStream_Save (IPersistStream *iface, IStream *pStm, BOOL fClearDirty)
static HRESULT WINAPI	PersistStream_GetSizeMax (IPersistStream *iface, ULARGE_INTEGER *pcbSize)
static Uri *	impl_from_IMarshal (IMarshal *iface)
static HRESULT WINAPI	Marshal_QueryInterface (IMarshal *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	Marshal_AddRef (IMarshal *iface)
static ULONG WINAPI	Marshal_Release (IMarshal *iface)
static HRESULT WINAPI	Marshal_GetUnmarshalClass (IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *pCid)
static HRESULT WINAPI	Marshal_GetMarshalSizeMax (IMarshal *iface, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *pSize)
static HRESULT WINAPI	Marshal_MarshalInterface (IMarshal *iface, IStream *pStm, REFIID riid, void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags)
static HRESULT WINAPI	Marshal_UnmarshalInterface (IMarshal *iface, IStream *pStm, REFIID riid, void **ppv)
static HRESULT WINAPI	Marshal_ReleaseMarshalData (IMarshal *iface, IStream *pStm)
static HRESULT WINAPI	Marshal_DisconnectObject (IMarshal *iface, DWORD dwReserved)
HRESULT	Uri_Construct (IUnknown *pUnkOuter, LPVOID *ppobj)
HRESULT WINAPI	CreateUri (LPCWSTR pwzURI, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
HRESULT WINAPI	CreateUriWithFragment (LPCWSTR pwzURI, LPCWSTR pwzFragment, DWORD dwFlags, DWORD_PTR dwReserved, IUri **ppURI)
static HRESULT	build_uri (const UriBuilder *builder, IUri **uri, DWORD create_flags, DWORD use_orig_flags, DWORD encoding_mask)
static UriBuilder *	impl_from_IUriBuilder (IUriBuilder *iface)
static HRESULT WINAPI	UriBuilder_QueryInterface (IUriBuilder *iface, REFIID riid, void **ppv)
static ULONG WINAPI	UriBuilder_AddRef (IUriBuilder *iface)
static ULONG WINAPI	UriBuilder_Release (IUriBuilder *iface)
static HRESULT WINAPI	UriBuilder_CreateUriSimple (IUriBuilder *iface, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
static HRESULT WINAPI	UriBuilder_CreateUri (IUriBuilder *iface, DWORD dwCreateFlags, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
static HRESULT WINAPI	UriBuilder_CreateUriWithFlags (IUriBuilder *iface, DWORD dwCreateFlags, DWORD dwUriBuilderFlags, DWORD dwAllowEncodingPropertyMask, DWORD_PTR dwReserved, IUri **ppIUri)
static HRESULT WINAPI	UriBuilder_GetIUri (IUriBuilder *iface, IUri **ppIUri)
static HRESULT WINAPI	UriBuilder_SetIUri (IUriBuilder *iface, IUri *pIUri)
static HRESULT WINAPI	UriBuilder_GetFragment (IUriBuilder *iface, DWORD *pcchFragment, LPCWSTR *ppwzFragment)
static HRESULT WINAPI	UriBuilder_GetHost (IUriBuilder *iface, DWORD *pcchHost, LPCWSTR *ppwzHost)
static HRESULT WINAPI	UriBuilder_GetPassword (IUriBuilder *iface, DWORD *pcchPassword, LPCWSTR *ppwzPassword)
static HRESULT WINAPI	UriBuilder_GetPath (IUriBuilder *iface, DWORD *pcchPath, LPCWSTR *ppwzPath)
static HRESULT WINAPI	UriBuilder_GetPort (IUriBuilder *iface, BOOL *pfHasPort, DWORD *pdwPort)
static HRESULT WINAPI	UriBuilder_GetQuery (IUriBuilder *iface, DWORD *pcchQuery, LPCWSTR *ppwzQuery)
static HRESULT WINAPI	UriBuilder_GetSchemeName (IUriBuilder *iface, DWORD *pcchSchemeName, LPCWSTR *ppwzSchemeName)
static HRESULT WINAPI	UriBuilder_GetUserName (IUriBuilder *iface, DWORD *pcchUserName, LPCWSTR *ppwzUserName)
static HRESULT WINAPI	UriBuilder_SetFragment (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_SetHost (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_SetPassword (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_SetPath (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_SetPort (IUriBuilder *iface, BOOL fHasPort, DWORD dwNewValue)
static HRESULT WINAPI	UriBuilder_SetQuery (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_SetSchemeName (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_SetUserName (IUriBuilder *iface, LPCWSTR pwzNewValue)
static HRESULT WINAPI	UriBuilder_RemoveProperties (IUriBuilder *iface, DWORD dwPropertyMask)
static HRESULT WINAPI	UriBuilder_HasBeenModified (IUriBuilder *iface, BOOL *pfModified)
HRESULT WINAPI	CreateIUriBuilder (IUri *pIUri, DWORD dwFlags, DWORD_PTR dwReserved, IUriBuilder **ppIUriBuilder)
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)
static HRESULT	combine_uri (Uri *base, Uri *relative, DWORD flags, IUri **result, DWORD extras)
HRESULT WINAPI	CoInternetCombineIUri (IUri *pBaseUri, IUri *pRelativeUri, DWORD dwCombineFlags, IUri **ppCombinedUri, DWORD_PTR dwReserved)
HRESULT WINAPI	CoInternetCombineUrlEx (IUri *pBaseUri, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, IUri **ppCombinedUri, DWORD_PTR dwReserved)
static HRESULT	parse_canonicalize (const Uri *uri, DWORD flags, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_friendly (IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_rootdocument (const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_document (const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_path_from_url (const Uri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_url_from_path (IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_schema (IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_site (IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_domain (IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
static HRESULT	parse_anchor (IUri *uri, LPWSTR output, DWORD output_len, DWORD *result_len)
HRESULT WINAPI	CoInternetParseIUri (IUri *pIUri, PARSEACTION ParseAction, DWORD dwFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult, DWORD_PTR dwReserved)

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

#define ALLOW_BRACKETLESS_IP_LITERAL   0x08

Definition at line 37 of file uri.c.

ALLOW_NULL_TERM_PASSWORD

#define ALLOW_NULL_TERM_PASSWORD   0x04

Definition at line 36 of file uri.c.

ALLOW_NULL_TERM_SCHEME

#define ALLOW_NULL_TERM_SCHEME   0x01

Definition at line 34 of file uri.c.

ALLOW_NULL_TERM_USER_NAME

#define ALLOW_NULL_TERM_USER_NAME   0x02

Definition at line 35 of file uri.c.

COMBINE_URI_FORCE_FLAG_USE

#define COMBINE_URI_FORCE_FLAG_USE   0x1

Definition at line 44 of file uri.c.

IGNORE_PORT_DELIMITER

#define IGNORE_PORT_DELIMITER   0x20

Definition at line 39 of file uri.c.

NO_SHLWAPI_REG

#define NO_SHLWAPI_REG

Definition at line 26 of file uri.c.

RAW_URI_CONVERT_TO_DOS_PATH

#define RAW_URI_CONVERT_TO_DOS_PATH   0x2

Definition at line 42 of file uri.c.

RAW_URI_FORCE_PORT_DISP

#define RAW_URI_FORCE_PORT_DISP   0x1

Definition at line 41 of file uri.c.

SKIP_IP_FUTURE_CHECK

#define SKIP_IP_FUTURE_CHECK   0x10

Definition at line 38 of file uri.c.

URI_DISPLAY_NO_ABSOLUTE_URI

#define URI_DISPLAY_NO_ABSOLUTE_URI   0x1

Definition at line 31 of file uri.c.

URI_DISPLAY_NO_DEFAULT_PORT_AUTH

#define URI_DISPLAY_NO_DEFAULT_PORT_AUTH   0x2

Definition at line 32 of file uri.c.

Function Documentation

apply_default_flags()

static void apply_default_flags ( DWORD *  flags )

static

Definition at line 398 of file uri.c.

                                              {
    if(!(*flags & Uri_CREATE_NO_CANONICALIZE))
        *flags |= Uri_CREATE_CANONICALIZE;
    if(!(*flags & Uri_CREATE_NO_DECODE_EXTRA_INFO))
        *flags |= Uri_CREATE_DECODE_EXTRA_INFO;
    if(!(*flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES))
        *flags |= Uri_CREATE_CRACK_UNKNOWN_SCHEMES;
    if(!(*flags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI))
        *flags |= Uri_CREATE_PRE_PROCESS_HTML_URI;
    if(!(*flags & Uri_CREATE_IE_SETTINGS))
        *flags |= Uri_CREATE_NO_IE_SETTINGS;
}

Referenced by build_uri(), combine_uri(), and CreateUri().

build_uri()

static HRESULT build_uri ( const UriBuilder *  builder, IUri **  uri, DWORD  create_flags, DWORD  use_orig_flags, DWORD  encoding_mask  )

static

Definition at line 5850 of file uri.c.

{
    HRESULT hr;
    parse_data data;
    Uri *ret;
 
    if(!uri)
        return E_POINTER;
 
    if(encoding_mask && (!builder->uri || builder->modified_props)) {
        *uri = NULL;
        return E_NOTIMPL;
    }
 
    /* Decide what flags should be used when creating the Uri. */
    if((use_orig_flags & UriBuilder_USE_ORIGINAL_FLAGS) && builder->uri)
        create_flags = builder->uri->create_flags;
    else {
        if(has_invalid_flag_combination(create_flags)) {
            *uri = NULL;
            return E_INVALIDARG;
        }
 
        /* Set the default flags if they don't cause a conflict. */
        apply_default_flags(&create_flags);
    }
 
    /* Return the base IUri if no changes have been made and the create_flags match. */
    if(builder->uri && !builder->modified_props && builder->uri->create_flags == create_flags) {
        *uri = &builder->uri->IUri_iface;
        IUri_AddRef(*uri);
        return S_OK;
    }
 
    hr = validate_components(builder, &data, create_flags);
    if(FAILED(hr)) {
        *uri = NULL;
        return hr;
    }
 
    hr = Uri_Construct(NULL, (void**)&ret);
    if(FAILED(hr)) {
        *uri = NULL;
        return hr;
    }
 
    hr = generate_uri(builder, &data, ret, create_flags);
    if(FAILED(hr)) {
        IUri_Release(&ret->IUri_iface);
        *uri = NULL;
        return hr;
    }
 
    *uri = &ret->IUri_iface;
    return S_OK;
}

Referenced by UriBuilder_CreateUri(), UriBuilder_CreateUriSimple(), and UriBuilder_CreateUriWithFlags().

canonicalize_authority()

static BOOL canonicalize_authority ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2794 of file uri.c.

                                                                                                    {
    uri->authority_start = uri->canon_len;
    uri->authority_len = 0;
 
    if(!canonicalize_userinfo(data, uri, flags, computeOnly))
        return FALSE;
 
    if(!canonicalize_host(data, uri, flags, computeOnly))
        return FALSE;
 
    if(!canonicalize_port(data, uri, flags, computeOnly))
        return FALSE;
 
    if(uri->host_start != -1 || (data->is_relative && (data->password || data->username)))
        uri->authority_len = uri->canon_len - uri->authority_start;
    else
        uri->authority_start = -1;
 
    return TRUE;
}

Referenced by canonicalize_hierpart().

canonicalize_fragment()

static BOOL canonicalize_fragment ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 3238 of file uri.c.

                                                                                                   {
    const WCHAR *ptr, *end;
    const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
 
    if(!data->fragment) {
        uri->fragment_start = -1;
        uri->fragment_len = 0;
        return TRUE;
    }
 
    uri->fragment_start = uri->canon_len;
 
    end = data->fragment + data->fragment_len;
    for(ptr = data->fragment; ptr < end; ++ptr) {
        if(*ptr == '%') {
            if(known_scheme && !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
                WCHAR val = decode_pct_val(ptr);
                if(is_unreserved(val)) {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = val;
                    ++uri->canon_len;
 
                    ptr += 2;
                    continue;
                }
            }
        } else if(known_scheme && is_ascii(*ptr) && !is_unreserved(*ptr) && !is_reserved(*ptr)) {
            if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) &&
               !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
                if(!computeOnly)
                    pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
                uri->canon_len += 3;
                continue;
            }
        }
 
        if(!computeOnly)
            uri->canon_uri[uri->canon_len] = *ptr;
        ++uri->canon_len;
    }
 
    uri->fragment_len = uri->canon_len - uri->fragment_start;
 
    if(!computeOnly)
        TRACE("(%p %p %x %d): Canonicalized fragment %s len=%d\n", data, uri, flags,
            computeOnly, debugstr_wn(uri->canon_uri+uri->fragment_start, uri->fragment_len),
            uri->fragment_len);
    return TRUE;
}

Referenced by canonicalize_uri(), and compute_canonicalized_length().

canonicalize_hierpart()

static BOOL canonicalize_hierpart ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 3097 of file uri.c.

                                                                                                   {
    if(!data->is_opaque || (data->is_relative && (data->password || data->username))) {
        /* "//" is only added for non-wildcard scheme types.
         *
         * A "//" is only added to a relative URI if it has a
         * host or port component (this only happens if a IUriBuilder
         * is generating an IUri).
         */
        if((data->is_relative && (data->host || data->has_port)) ||
           (!data->is_relative && data->scheme_type != URL_SCHEME_WILDCARD)) {
            if(data->scheme_type == URL_SCHEME_WILDCARD)
                FIXME("Here\n");
 
            if(!computeOnly) {
                INT pos = uri->canon_len;
 
                uri->canon_uri[pos] = '/';
                uri->canon_uri[pos+1] = '/';
           }
           uri->canon_len += 2;
        }
 
        if(!canonicalize_authority(data, uri, flags, computeOnly))
            return FALSE;
 
        if(data->is_relative && (data->password || data->username)) {
            if(!canonicalize_path_opaque(data, uri, flags, computeOnly))
                return FALSE;
        } else {
            if(!computeOnly)
                uri->path_start = uri->canon_len;
            uri->path_len = canonicalize_path_hierarchical(data->path, data->path_len, data->scheme_type, data->host_len != 0,
                    flags, data->has_implicit_scheme, computeOnly ? NULL : uri->canon_uri+uri->canon_len);
            uri->canon_len += uri->path_len;
            if(!computeOnly && !uri->path_len)
                uri->path_start = -1;
        }
    } else {
        /* Opaque URI's don't have an authority. */
        uri->userinfo_start = uri->userinfo_split = -1;
        uri->userinfo_len = 0;
        uri->host_start = -1;
        uri->host_len = 0;
        uri->host_type = Uri_HOST_UNKNOWN;
        uri->has_port = FALSE;
        uri->authority_start = -1;
        uri->authority_len = 0;
        uri->domain_offset = -1;
        uri->port_offset = -1;
 
        if(is_hierarchical_scheme(data->scheme_type)) {
            DWORD i;
 
            /* Absolute URIs aren't displayed for known scheme types
             * which should be hierarchical URIs.
             */
            uri->display_modifiers |= URI_DISPLAY_NO_ABSOLUTE_URI;
 
            /* Windows also sets the port for these (if they have one). */
            for(i = 0; i < ARRAY_SIZE(default_ports); ++i) {
                if(data->scheme_type == default_ports[i].scheme) {
                    uri->has_port = TRUE;
                    uri->port = default_ports[i].port;
                    break;
                }
            }
        }
 
        if(!canonicalize_path_opaque(data, uri, flags, computeOnly))
            return FALSE;
    }
 
    if(uri->path_start > -1 && !computeOnly)
        /* Finding file extensions happens for both types of URIs. */
        uri->extension_offset = find_file_extension(uri->canon_uri+uri->path_start, uri->path_len);
    else
        uri->extension_offset = -1;
 
    return TRUE;
}

Referenced by canonicalize_uri(), and compute_canonicalized_length().

canonicalize_host()

static BOOL canonicalize_host ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2674 of file uri.c.

                                                                                               {
    uri->host_start = -1;
    uri->host_len = 0;
    uri->domain_offset = -1;
 
    if(data->host) {
        switch(data->host_type) {
        case Uri_HOST_DNS:
            uri->host_type = Uri_HOST_DNS;
            if(!canonicalize_reg_name(data, uri, flags, computeOnly))
                return FALSE;
 
            break;
        case Uri_HOST_IPV4:
            uri->host_type = Uri_HOST_IPV4;
            if(!canonicalize_ipv4address(data, uri, flags, computeOnly))
                return FALSE;
 
            break;
        case Uri_HOST_IPV6:
            if(!canonicalize_ipv6address(data, uri, flags, computeOnly))
                return FALSE;
 
            uri->host_type = Uri_HOST_IPV6;
            break;
        case Uri_HOST_UNKNOWN:
            if(data->host_len > 0 || data->scheme_type != URL_SCHEME_FILE) {
                uri->host_start = uri->canon_len;
 
                /* Nothing happens to unknown host types. */
                if(!computeOnly)
                    memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
                uri->canon_len += data->host_len;
                uri->host_len = data->host_len;
            }
 
            uri->host_type = Uri_HOST_UNKNOWN;
            break;
        default:
            FIXME("(%p %p %x %d): Canonicalization for host type %d not supported.\n", data,
                    uri, flags, computeOnly, data->host_type);
            return FALSE;
       }
   }
 
   return TRUE;
}

Referenced by canonicalize_authority().

canonicalize_implicit_ipv4address()

static BOOL canonicalize_implicit_ipv4address ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2404 of file uri.c.

                                                                                                               {
    uri->host_start = uri->canon_len;
 
    TRACE("%u\n", data->implicit_ipv4);
    /* For unknown scheme types Windows doesn't convert
     * the value into an IP address, but it still considers
     * it an IPv4 address.
     */
    if(data->scheme_type == URL_SCHEME_UNKNOWN) {
        if(!computeOnly)
            memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
        uri->canon_len += data->host_len;
    } else {
        if(!computeOnly)
            uri->canon_len += ui2ipv4(uri->canon_uri+uri->canon_len, data->implicit_ipv4);
        else
            uri->canon_len += ui2ipv4(NULL, data->implicit_ipv4);
    }
 
    uri->host_len = uri->canon_len - uri->host_start;
    uri->host_type = Uri_HOST_IPV4;
 
    if(!computeOnly)
        TRACE("%p %p %x %d): Canonicalized implicit IP address=%s len=%d\n",
            data, uri, flags, computeOnly,
            debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
            uri->host_len);
 
    return TRUE;
}

Referenced by canonicalize_ipv4address().

canonicalize_ipv4address()

static BOOL canonicalize_ipv4address ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2453 of file uri.c.

                                                                                                      {
    if(data->has_implicit_ip)
        return canonicalize_implicit_ipv4address(data, uri, flags, computeOnly);
    else {
        uri->host_start = uri->canon_len;
 
        /* Windows only normalizes for known scheme types. */
        if(data->scheme_type != URL_SCHEME_UNKNOWN) {
            /* parse_data contains a partial or full IPv4 address, so normalize it. */
            DWORD i, octetDigitCount = 0, octetCount = 0;
            BOOL octetHasDigit = FALSE;
 
            for(i = 0; i < data->host_len; ++i) {
                if(data->host[i] == '0' && !octetHasDigit) {
                    /* Can ignore leading zeros if:
                     *  1) It isn't the last digit of the octet.
                     *  2) i+1 != data->host_len
                     *  3) i+1 != '.'
                     */
                    if(octetDigitCount == 2 ||
                       i+1 == data->host_len ||
                       data->host[i+1] == '.') {
                        if(!computeOnly)
                            uri->canon_uri[uri->canon_len] = data->host[i];
                        ++uri->canon_len;
                        TRACE("Adding zero\n");
                    }
                } else if(data->host[i] == '.') {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = data->host[i];
                    ++uri->canon_len;
 
                    octetDigitCount = 0;
                    octetHasDigit = FALSE;
                    ++octetCount;
                } else {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = data->host[i];
                    ++uri->canon_len;
 
                    ++octetDigitCount;
                    octetHasDigit = TRUE;
                }
            }
 
            /* Make sure the canonicalized IP address has 4 dec-octets.
             * If doesn't add "0" ones until there is 4;
             */
            for( ; octetCount < 3; ++octetCount) {
                if(!computeOnly) {
                    uri->canon_uri[uri->canon_len] = '.';
                    uri->canon_uri[uri->canon_len+1] = '0';
                }
 
                uri->canon_len += 2;
            }
        } else {
            /* Windows doesn't normalize addresses in unknown schemes. */
            if(!computeOnly)
                memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
            uri->canon_len += data->host_len;
        }
 
        uri->host_len = uri->canon_len - uri->host_start;
        if(!computeOnly)
            TRACE("(%p %p %x %d): Canonicalized IPv4 address, ip=%s len=%d\n",
                data, uri, flags, computeOnly,
                debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
                uri->host_len);
    }
 
    return TRUE;
}

Referenced by canonicalize_host().

canonicalize_ipv6address()

static BOOL canonicalize_ipv6address ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2562 of file uri.c.

                                                                    {
    uri->host_start = uri->canon_len;
 
    if(data->scheme_type == URL_SCHEME_UNKNOWN) {
        if(!computeOnly)
            memcpy(uri->canon_uri+uri->canon_len, data->host, data->host_len*sizeof(WCHAR));
        uri->canon_len += data->host_len;
    } else {
        USHORT values[8];
        INT elision_start;
        DWORD i, elision_len;
 
        if(!ipv6_to_number(&(data->ipv6_address), values)) {
            TRACE("(%p %p %x %d): Failed to compute numerical value for IPv6 address.\n",
                data, uri, flags, computeOnly);
            return FALSE;
        }
 
        if(!computeOnly)
            uri->canon_uri[uri->canon_len] = '[';
        ++uri->canon_len;
 
        /* Find where the elision should occur (if any). */
        compute_elision_location(&(data->ipv6_address), values, &elision_start, &elision_len);
 
        TRACE("%p %p %x %d): Elision starts at %d, len=%u\n", data, uri, flags,
            computeOnly, elision_start, elision_len);
 
        for(i = 0; i < 8; ++i) {
            BOOL in_elision = (elision_start > -1 && i >= elision_start &&
                               i < elision_start+elision_len);
            BOOL do_ipv4 = (i == 6 && data->ipv6_address.ipv4 && !in_elision &&
                            data->ipv6_address.h16_count == 0);
 
            if(i == elision_start) {
                if(!computeOnly) {
                    uri->canon_uri[uri->canon_len] = ':';
                    uri->canon_uri[uri->canon_len+1] = ':';
                }
                uri->canon_len += 2;
            }
 
            /* We can ignore the current component if we're in the elision. */
            if(in_elision)
                continue;
 
            /* We only add a ':' if we're not at i == 0, or when we're at
             * the very end of elision range since the ':' colon was handled
             * earlier. Otherwise we would end up with ":::" after elision.
             */
            if(i != 0 && !(elision_start > -1 && i == elision_start+elision_len)) {
                if(!computeOnly)
                    uri->canon_uri[uri->canon_len] = ':';
                ++uri->canon_len;
            }
 
            if(do_ipv4) {
                UINT val;
                DWORD len;
 
                /* Combine the two parts of the IPv4 address values. */
                val = values[i];
                val <<= 16;
                val += values[i+1];
 
                if(!computeOnly)
                    len = ui2ipv4(uri->canon_uri+uri->canon_len, val);
                else
                    len = ui2ipv4(NULL, val);
 
                uri->canon_len += len;
                ++i;
            } else {
                /* Write a regular h16 component to the URI. */
 
                /* Short circuit for the trivial case. */
                if(values[i] == 0) {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = '0';
                    ++uri->canon_len;
                } else {
                    static const WCHAR formatW[] = {'%','x',0};
 
                    if(!computeOnly)
                        uri->canon_len += swprintf(uri->canon_uri+uri->canon_len,
                                            formatW, values[i]);
                    else {
                        WCHAR tmp[5];
                        uri->canon_len += swprintf(tmp, formatW, values[i]);
                    }
                }
            }
        }
 
        /* Add the closing ']'. */
        if(!computeOnly)
            uri->canon_uri[uri->canon_len] = ']';
        ++uri->canon_len;
    }
 
    uri->host_len = uri->canon_len - uri->host_start;
 
    if(!computeOnly)
        TRACE("(%p %p %x %d): Canonicalized IPv6 address %s, len=%d\n", data, uri, flags,
            computeOnly, debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
            uri->host_len);
 
    return TRUE;
}

Referenced by canonicalize_host().

canonicalize_password()

static BOOL canonicalize_password ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2193 of file uri.c.

                                                                                                   {
    const WCHAR *ptr;
 
    if(!data->password) {
        uri->userinfo_split = -1;
        return TRUE;
    }
 
    if(uri->userinfo_start == -1)
        /* Has a password, but, doesn't have a username. */
        uri->userinfo_start = uri->canon_len;
 
    uri->userinfo_split = uri->canon_len - uri->userinfo_start;
 
    /* Add the ':' to the userinfo component. */
    if(!computeOnly)
        uri->canon_uri[uri->canon_len] = ':';
    ++uri->canon_len;
 
    for(ptr = data->password; ptr < data->password+data->password_len; ++ptr) {
        if(*ptr == '%') {
            /* Only decode % encoded values for known scheme types. */
            if(data->scheme_type != URL_SCHEME_UNKNOWN) {
                /* See if the value really needs decoding. */
                WCHAR val = decode_pct_val(ptr);
                if(is_unreserved(val)) {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = val;
 
                    ++uri->canon_len;
 
                    /* Move pass the hex characters. */
                    ptr += 2;
                    continue;
                }
            }
        } else if(is_ascii(*ptr) && !is_reserved(*ptr) && !is_unreserved(*ptr) && *ptr != '\\') {
            /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
             * is NOT set.
             */
            if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
                if(!computeOnly)
                    pct_encode_val(*ptr, uri->canon_uri + uri->canon_len);
 
                uri->canon_len += 3;
                continue;
            }
        }
 
        if(!computeOnly)
            /* Nothing special, so just copy the character over. */
            uri->canon_uri[uri->canon_len] = *ptr;
        ++uri->canon_len;
    }
 
    return TRUE;
}

Referenced by canonicalize_userinfo().

canonicalize_path_hierarchical()

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  )

static

Definition at line 2844 of file uri.c.

                                                  {
    const BOOL known_scheme = scheme_type != URL_SCHEME_UNKNOWN;
    const BOOL is_file = scheme_type == URL_SCHEME_FILE;
    const BOOL is_res = scheme_type == URL_SCHEME_RES;
    const WCHAR *ptr;
    BOOL escape_pct = FALSE;
    DWORD len = 0;
 
    if(!path)
        return 0;
 
    ptr = path;
 
    if(is_file && !has_host) {
        /* Check if a '/' needs to be appended for the file scheme. */
        if(path_len > 1 && is_drive_path(ptr) && !(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
            if(ret_path)
                ret_path[len] = '/';
            len++;
            escape_pct = TRUE;
        } else if(*ptr == '/') {
            if(!(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
                /* Copy the extra '/' over. */
                if(ret_path)
                    ret_path[len] = '/';
                len++;
            }
            ++ptr;
        }
 
        if(is_drive_path(ptr)) {
            if(ret_path) {
                ret_path[len] = *ptr;
                /* If there's a '|' after the drive letter, convert it to a ':'. */
                ret_path[len+1] = ':';
            }
            ptr += 2;
            len += 2;
        }
    }
 
    if(!is_file && *path && *path != '/') {
        /* Prepend a '/' to the path if it doesn't have one. */
        if(ret_path)
            ret_path[len] = '/';
        len++;
    }
 
    for(; ptr < path+path_len; ++ptr) {
        BOOL do_default_action = TRUE;
 
        if(*ptr == '%' && !is_res) {
            const WCHAR *tmp = ptr;
            WCHAR val;
 
            /* Check if the % represents a valid encoded char, or if it needs encoding. */
            BOOL force_encode = !check_pct_encoded(&tmp) && is_file && !(flags&Uri_CREATE_FILE_USE_DOS_PATH);
            val = decode_pct_val(ptr);
 
            if(force_encode || escape_pct) {
                /* Escape the percent sign in the file URI. */
                if(ret_path)
                    pct_encode_val(*ptr, ret_path+len);
                len += 3;
                do_default_action = FALSE;
            } else if((is_unreserved(val) && known_scheme) ||
                      (is_file && !is_implicit_scheme && (is_unreserved(val) || is_reserved(val) ||
                      (val && flags&Uri_CREATE_FILE_USE_DOS_PATH && !is_forbidden_dos_path_char(val))))) {
                if(ret_path)
                    ret_path[len] = val;
                len++;
 
                ptr += 2;
                continue;
            }
        } else if(*ptr == '/' && is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
            /* Convert the '/' back to a '\\'. */
            if(ret_path)
                ret_path[len] = '\\';
            len++;
            do_default_action = FALSE;
        } else if(*ptr == '\\' && known_scheme) {
            if(!(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH))) {
                /* Convert '\\' into a '/'. */
                if(ret_path)
                    ret_path[len] = '/';
                len++;
                do_default_action = FALSE;
            }
        } else if(known_scheme && !is_res && is_ascii(*ptr) && !is_unreserved(*ptr) && !is_reserved(*ptr) &&
                  (!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) || is_file)) {
            if(!is_file || !(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
                /* Escape the forbidden character. */
                if(ret_path)
                    pct_encode_val(*ptr, ret_path+len);
                len += 3;
                do_default_action = FALSE;
            }
        }
 
        if(do_default_action) {
            if(ret_path)
                ret_path[len] = *ptr;
            len++;
        }
    }
 
    /* Removing the dot segments only happens when it's not in
     * computeOnly mode and it's not a wildcard scheme. File schemes
     * with USE_DOS_PATH set don't get dot segments removed.
     */
    if(!(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) &&
       scheme_type != URL_SCHEME_WILDCARD) {
        if(!(flags & Uri_CREATE_NO_CANONICALIZE) && ret_path) {
            /* Remove the dot segments (if any) and reset everything to the new
             * correct length.
             */
            len = remove_dot_segments(ret_path, len);
        }
    }
 
    if(ret_path)
        TRACE("Canonicalized path %s len=%d\n", debugstr_wn(ret_path, len), len);
    return len;
}

Referenced by canonicalize_hierpart(), and compare_file_paths().

canonicalize_path_opaque()

static BOOL canonicalize_path_opaque ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2989 of file uri.c.

                                                                                                      {
    const WCHAR *ptr;
    const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
    const BOOL is_file = data->scheme_type == URL_SCHEME_FILE;
    const BOOL is_mk = data->scheme_type == URL_SCHEME_MK;
 
    if(!data->path) {
        uri->path_start = -1;
        uri->path_len = 0;
        return TRUE;
    }
 
    uri->path_start = uri->canon_len;
 
    if(is_mk){
        /* hijack this flag for SCHEME_MK to tell the function when to start
         * converting slashes */
        flags |= Uri_CREATE_FILE_USE_DOS_PATH;
    }
 
    /* For javascript: URIs, simply copy path part without any canonicalization */
    if(data->scheme_type == URL_SCHEME_JAVASCRIPT) {
        if(!computeOnly)
            memcpy(uri->canon_uri+uri->canon_len, data->path, data->path_len*sizeof(WCHAR));
        uri->path_len = data->path_len;
        uri->canon_len += data->path_len;
        return TRUE;
    }
 
    /* Windows doesn't allow a "//" to appear after the scheme
     * of a URI, if it's an opaque URI.
     */
    if(data->scheme && *(data->path) == '/' && *(data->path+1) == '/') {
        /* So it inserts a "/." before the "//" if it exists. */
        if(!computeOnly) {
            uri->canon_uri[uri->canon_len] = '/';
            uri->canon_uri[uri->canon_len+1] = '.';
        }
 
        uri->canon_len += 2;
    }
 
    for(ptr = data->path; ptr < data->path+data->path_len; ++ptr) {
        BOOL do_default_action = TRUE;
 
        if(*ptr == '%' && known_scheme) {
            WCHAR val = decode_pct_val(ptr);
 
            if(is_unreserved(val)) {
                if(!computeOnly)
                    uri->canon_uri[uri->canon_len] = val;
                ++uri->canon_len;
 
                ptr += 2;
                continue;
            }
        } else if(*ptr == '/' && is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
            if(!computeOnly)
                uri->canon_uri[uri->canon_len] = '\\';
            ++uri->canon_len;
            do_default_action = FALSE;
        } else if(*ptr == '\\') {
            if((data->is_relative || is_mk || is_file) && !(flags & Uri_CREATE_FILE_USE_DOS_PATH)) {
                /* Convert to a '/'. */
                if(!computeOnly)
                    uri->canon_uri[uri->canon_len] = '/';
                ++uri->canon_len;
                do_default_action = FALSE;
            }
        } else if(is_mk && *ptr == ':' && ptr + 1 < data->path + data->path_len && *(ptr + 1) == ':') {
            flags &= ~Uri_CREATE_FILE_USE_DOS_PATH;
        } else if(known_scheme && is_ascii(*ptr) && !is_unreserved(*ptr) && !is_reserved(*ptr) &&
                  !(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
            if(!(is_file && (flags & Uri_CREATE_FILE_USE_DOS_PATH))) {
                if(!computeOnly)
                    pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
                uri->canon_len += 3;
                do_default_action = FALSE;
            }
        }
 
        if(do_default_action) {
            if(!computeOnly)
                uri->canon_uri[uri->canon_len] = *ptr;
            ++uri->canon_len;
        }
    }
 
    if(is_mk && !computeOnly && !(flags & Uri_CREATE_NO_CANONICALIZE)) {
        DWORD new_len = remove_dot_segments(uri->canon_uri + uri->path_start,
                                            uri->canon_len - uri->path_start);
        uri->canon_len = uri->path_start + new_len;
    }
 
    uri->path_len = uri->canon_len - uri->path_start;
 
    if(!computeOnly)
        TRACE("(%p %p %x %d): Canonicalized opaque URI path %s len=%d\n", data, uri, flags, computeOnly,
            debugstr_wn(uri->canon_uri+uri->path_start, uri->path_len), uri->path_len);
    return TRUE;
}

Referenced by canonicalize_hierpart().

canonicalize_port()

static BOOL canonicalize_port ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2722 of file uri.c.

                                                                                               {
    BOOL has_default_port = FALSE;
    USHORT default_port = 0;
    DWORD i;
 
    uri->port_offset = -1;
 
    /* Check if the scheme has a default port. */
    for(i = 0; i < ARRAY_SIZE(default_ports); ++i) {
        if(default_ports[i].scheme == data->scheme_type) {
            has_default_port = TRUE;
            default_port = default_ports[i].port;
            break;
        }
    }
 
    uri->has_port = data->has_port || has_default_port;
 
    /* Possible cases:
     *  1)  Has a port which is the default port.
     *  2)  Has a port (not the default).
     *  3)  Doesn't have a port, but, scheme has a default port.
     *  4)  No port.
     */
    if(has_default_port && data->has_port && data->port_value == default_port) {
        /* If it's the default port and this flag isn't set, don't do anything. */
        if(flags & Uri_CREATE_NO_CANONICALIZE) {
            uri->port_offset = uri->canon_len-uri->authority_start;
            if(!computeOnly)
                uri->canon_uri[uri->canon_len] = ':';
            ++uri->canon_len;
 
            if(data->port) {
                /* Copy the original port over. */
                if(!computeOnly)
                    memcpy(uri->canon_uri+uri->canon_len, data->port, data->port_len*sizeof(WCHAR));
                uri->canon_len += data->port_len;
            } else {
                if(!computeOnly)
                    uri->canon_len += ui2str(uri->canon_uri+uri->canon_len, data->port_value);
                else
                    uri->canon_len += ui2str(NULL, data->port_value);
            }
        }
 
        uri->port = default_port;
    } else if(data->has_port) {
        uri->port_offset = uri->canon_len-uri->authority_start;
        if(!computeOnly)
            uri->canon_uri[uri->canon_len] = ':';
        ++uri->canon_len;
 
        if(flags & Uri_CREATE_NO_CANONICALIZE && data->port) {
            /* Copy the original over without changes. */
            if(!computeOnly)
                memcpy(uri->canon_uri+uri->canon_len, data->port, data->port_len*sizeof(WCHAR));
            uri->canon_len += data->port_len;
        } else {
            if(!computeOnly)
                uri->canon_len += ui2str(uri->canon_uri+uri->canon_len, data->port_value);
            else
                uri->canon_len += ui2str(NULL, data->port_value);
        }
 
        uri->port = data->port_value;
    } else if(has_default_port)
        uri->port = default_port;
 
    return TRUE;
}

Referenced by canonicalize_authority().

canonicalize_query()

static BOOL canonicalize_query ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 3188 of file uri.c.

                                                                                                {
    const WCHAR *ptr, *end;
    const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
 
    if(!data->query) {
        uri->query_start = -1;
        uri->query_len = 0;
        return TRUE;
    }
 
    uri->query_start = uri->canon_len;
 
    end = data->query+data->query_len;
    for(ptr = data->query; ptr < end; ++ptr) {
        if(*ptr == '%') {
            if(known_scheme && !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
                WCHAR val = decode_pct_val(ptr);
                if(is_unreserved(val)) {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = val;
                    ++uri->canon_len;
 
                    ptr += 2;
                    continue;
                }
            }
        } else if(known_scheme && is_ascii(*ptr) && !is_unreserved(*ptr) && !is_reserved(*ptr)) {
            if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) &&
               !(flags & Uri_CREATE_NO_DECODE_EXTRA_INFO)) {
                if(!computeOnly)
                    pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
                uri->canon_len += 3;
                continue;
            }
        }
 
        if(!computeOnly)
            uri->canon_uri[uri->canon_len] = *ptr;
        ++uri->canon_len;
    }
 
    uri->query_len = uri->canon_len - uri->query_start;
 
    if(!computeOnly)
        TRACE("(%p %p %x %d): Canonicalized query string %s len=%d\n", data, uri, flags,
            computeOnly, debugstr_wn(uri->canon_uri+uri->query_start, uri->query_len),
            uri->query_len);
    return TRUE;
}

Referenced by canonicalize_uri(), and compute_canonicalized_length().

canonicalize_reg_name()

static BOOL canonicalize_reg_name ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2306 of file uri.c.

                                                                 {
    static const WCHAR localhostW[] =
            {'l','o','c','a','l','h','o','s','t',0};
    const WCHAR *ptr;
    const BOOL known_scheme = data->scheme_type != URL_SCHEME_UNKNOWN;
 
    if(data->scheme_type == URL_SCHEME_FILE &&
       data->host_len == lstrlenW(localhostW)) {
        if(!StrCmpNIW(data->host, localhostW, data->host_len)) {
            uri->host_start = -1;
            uri->host_len = 0;
            uri->host_type = Uri_HOST_UNKNOWN;
            return TRUE;
        }
    }
 
    if(data->scheme_type == URL_SCHEME_FILE && flags & Uri_CREATE_FILE_USE_DOS_PATH) {
        if(!computeOnly) {
            uri->canon_uri[uri->canon_len] = '\\';
            uri->canon_uri[uri->canon_len+1] = '\\';
        }
        uri->canon_len += 2;
        uri->authority_start = uri->canon_len;
    }
 
    uri->host_start = uri->canon_len;
 
    for(ptr = data->host; ptr < data->host+data->host_len; ++ptr) {
        if(*ptr == '%' && known_scheme) {
            WCHAR val = decode_pct_val(ptr);
            if(is_unreserved(val)) {
                /* If NO_CANONICALIZE is not set, then windows lower cases the
                 * decoded value.
                 */
                if(!(flags & Uri_CREATE_NO_CANONICALIZE) && iswupper(val)) {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = towlower(val);
                } else {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = val;
                }
                ++uri->canon_len;
 
                /* Skip past the % encoded character. */
                ptr += 2;
                continue;
            } else {
                /* Just copy the % over. */
                if(!computeOnly)
                    uri->canon_uri[uri->canon_len] = *ptr;
                ++uri->canon_len;
            }
        } else if(*ptr == '\\') {
            /* Only unknown scheme types could have made it here with a '\\' in the host name. */
            if(!computeOnly)
                uri->canon_uri[uri->canon_len] = *ptr;
            ++uri->canon_len;
        } else if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS) && is_ascii(*ptr) &&
                  !is_unreserved(*ptr) && !is_reserved(*ptr) && known_scheme) {
            if(!computeOnly) {
                pct_encode_val(*ptr, uri->canon_uri+uri->canon_len);
 
                /* The percent encoded value gets lower cased also. */
                if(!(flags & Uri_CREATE_NO_CANONICALIZE)) {
                    uri->canon_uri[uri->canon_len+1] = towlower(uri->canon_uri[uri->canon_len+1]);
                    uri->canon_uri[uri->canon_len+2] = towlower(uri->canon_uri[uri->canon_len+2]);
                }
            }
 
            uri->canon_len += 3;
        } else {
            if(!computeOnly) {
                if(!(flags & Uri_CREATE_NO_CANONICALIZE) && known_scheme)
                    uri->canon_uri[uri->canon_len] = towlower(*ptr);
                else
                    uri->canon_uri[uri->canon_len] = *ptr;
            }
 
            ++uri->canon_len;
        }
    }
 
    uri->host_len = uri->canon_len - uri->host_start;
 
    if(!computeOnly)
        TRACE("(%p %p %x %d): Canonicalize reg_name=%s len=%d\n", data, uri, flags,
            computeOnly, debugstr_wn(uri->canon_uri+uri->host_start, uri->host_len),
            uri->host_len);
 
    if(!computeOnly)
        find_domain_name(uri->canon_uri+uri->host_start, uri->host_len,
            &(uri->domain_offset));
 
    return TRUE;
}

Referenced by canonicalize_host().

canonicalize_scheme()

static BOOL canonicalize_scheme ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 3289 of file uri.c.

                                                                                                 {
    uri->scheme_start = -1;
    uri->scheme_len = 0;
 
    if(!data->scheme) {
        /* The only type of URI that doesn't have to have a scheme is a relative
         * URI.
         */
        if(!data->is_relative) {
            FIXME("(%p %p %x): Unable to determine the scheme type of %s.\n", data,
                    uri, flags, debugstr_w(data->uri));
            return FALSE;
        }
    } else {
        if(!computeOnly) {
            DWORD i;
            INT pos = uri->canon_len;
 
            for(i = 0; i < data->scheme_len; ++i) {
                /* Scheme name must be lower case after canonicalization. */
                uri->canon_uri[i + pos] = towlower(data->scheme[i]);
            }
 
            uri->canon_uri[i + pos] = ':';
            uri->scheme_start = pos;
 
            TRACE("(%p %p %x): Canonicalized scheme=%s, len=%d.\n", data, uri, flags,
                    debugstr_wn(uri->canon_uri+uri->scheme_start,  data->scheme_len), data->scheme_len);
        }
 
        /* This happens in both computation modes. */
        uri->canon_len += data->scheme_len + 1;
        uri->scheme_len = data->scheme_len;
    }
    return TRUE;
}

Referenced by canonicalize_uri(), and compute_canonicalized_length().

canonicalize_uri()

static HRESULT canonicalize_uri ( const parse_data *  data, Uri *  uri, DWORD  flags  )

static

Definition at line 3373 of file uri.c.

                                                                               {
    INT len;
 
    uri->canon_uri = NULL;
    uri->canon_size = uri->canon_len = 0;
 
    TRACE("(%p %p %x): beginning to canonicalize URI %s.\n", data, uri, flags, debugstr_w(data->uri));
 
    /* First try to compute the length of the URI. */
    len = compute_canonicalized_length(data, flags);
    if(len == -1) {
        ERR("(%p %p %x): Could not compute the canonicalized length of %s.\n", data, uri, flags,
                debugstr_w(data->uri));
        return E_INVALIDARG;
    }
 
    uri->canon_uri = heap_alloc((len+1)*sizeof(WCHAR));
    if(!uri->canon_uri)
        return E_OUTOFMEMORY;
 
    uri->canon_size = len;
    if(!canonicalize_scheme(data, uri, flags, FALSE)) {
        ERR("(%p %p %x): Unable to canonicalize the scheme of the URI.\n", data, uri, flags);
        return E_INVALIDARG;
    }
    uri->scheme_type = data->scheme_type;
 
    if(!canonicalize_hierpart(data, uri, flags, FALSE)) {
        ERR("(%p %p %x): Unable to canonicalize the heirpart of the URI\n", data, uri, flags);
        return E_INVALIDARG;
    }
 
    if(!canonicalize_query(data, uri, flags, FALSE)) {
        ERR("(%p %p %x): Unable to canonicalize query string of the URI.\n",
            data, uri, flags);
        return E_INVALIDARG;
    }
 
    if(!canonicalize_fragment(data, uri, flags, FALSE)) {
        ERR("(%p %p %x): Unable to canonicalize fragment of the URI.\n",
            data, uri, flags);
        return E_INVALIDARG;
    }
 
    /* There's a possibility we didn't use all the space we allocated
     * earlier.
     */
    if(uri->canon_len < uri->canon_size) {
        /* This happens if the URI is hierarchical and dot
         * segments were removed from its path.
         */
        WCHAR *tmp = heap_realloc(uri->canon_uri, (uri->canon_len+1)*sizeof(WCHAR));
        if(!tmp)
            return E_OUTOFMEMORY;
 
        uri->canon_uri = tmp;
        uri->canon_size = uri->canon_len;
    }
 
    uri->canon_uri[uri->canon_len] = '\0';
    TRACE("(%p %p %x): finished canonicalizing the URI. uri=%s\n", data, uri, flags, debugstr_w(uri->canon_uri));
 
    return S_OK;
}

Referenced by combine_uri(), CreateUri(), generate_uri(), Marshal_UnmarshalInterface(), and PersistStream_Load().

canonicalize_userinfo()

static BOOL canonicalize_userinfo ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2259 of file uri.c.

                                                                                                   {
    uri->userinfo_start = uri->userinfo_split = -1;
    uri->userinfo_len = 0;
 
    if(!data->username && !data->password)
        /* URI doesn't have userinfo, so nothing to do here. */
        return TRUE;
 
    if(!canonicalize_username(data, uri, flags, computeOnly))
        return FALSE;
 
    if(!canonicalize_password(data, uri, flags, computeOnly))
        return FALSE;
 
    uri->userinfo_len = uri->canon_len - uri->userinfo_start;
    if(!computeOnly)
        TRACE("(%p %p %x %d): Canonicalized userinfo, userinfo_start=%d, userinfo=%s, userinfo_split=%d userinfo_len=%d.\n",
                data, uri, flags, computeOnly, uri->userinfo_start, debugstr_wn(uri->canon_uri + uri->userinfo_start, uri->userinfo_len),
                uri->userinfo_split, uri->userinfo_len);
 
    /* Now insert the '@' after the userinfo. */
    if(!computeOnly)
        uri->canon_uri[uri->canon_len] = '@';
    ++uri->canon_len;
 
    return TRUE;
}

Referenced by canonicalize_authority().

canonicalize_username()

static BOOL canonicalize_username ( const parse_data *  data, Uri *  uri, DWORD  flags, BOOL  computeOnly  )

static

Definition at line 2145 of file uri.c.

                                                                                                   {
    const WCHAR *ptr;
 
    if(!data->username) {
        uri->userinfo_start = -1;
        return TRUE;
    }
 
    uri->userinfo_start = uri->canon_len;
    for(ptr = data->username; ptr < data->username+data->username_len; ++ptr) {
        if(*ptr == '%') {
            /* Only decode % encoded values for known scheme types. */
            if(data->scheme_type != URL_SCHEME_UNKNOWN) {
                /* See if the value really needs decoding. */
                WCHAR val = decode_pct_val(ptr);
                if(is_unreserved(val)) {
                    if(!computeOnly)
                        uri->canon_uri[uri->canon_len] = val;
 
                    ++uri->canon_len;
 
                    /* Move pass the hex characters. */
                    ptr += 2;
                    continue;
                }
            }
        } else if(is_ascii(*ptr) && !is_reserved(*ptr) && !is_unreserved(*ptr) && *ptr != '\\') {
            /* Only percent encode forbidden characters if the NO_ENCODE_FORBIDDEN_CHARACTERS flag
             * is NOT set.
             */
            if(!(flags & Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS)) {
                if(!computeOnly)
                    pct_encode_val(*ptr, uri->canon_uri + uri->canon_len);
 
                uri->canon_len += 3;
                continue;
            }
        }
 
        if(!computeOnly)
            /* Nothing special, so just copy the character over. */
            uri->canon_uri[uri->canon_len] = *ptr;
        ++uri->canon_len;
    }
 
    return TRUE;
}

Referenced by canonicalize_userinfo().

check_dec_octet()

static BOOL check_dec_octet ( const WCHAR **  ptr )

static

Definition at line 964 of file uri.c.

                                               {
    const WCHAR *c1, *c2, *c3;
 
    c1 = *ptr;
    /* A dec-octet must be at least 1 digit long. */
    if(*c1 < '0' || *c1 > '9')
        return FALSE;
 
    ++(*ptr);
 
    c2 = *ptr;
    /* Since the 1-digit requirement was met, it doesn't
     * matter if this is a DIGIT value, it's considered a
     * dec-octet.
     */
    if(*c2 < '0' || *c2 > '9')
        return TRUE;
 
    ++(*ptr);
 
    c3 = *ptr;
    /* Same explanation as above. */
    if(*c3 < '0' || *c3 > '9')
        return TRUE;
 
    /* Anything > 255 isn't a valid IP dec-octet. */
    if(*c1 >= '2' && *c2 >= '5' && *c3 >= '5') {
        *ptr = c1;
        return FALSE;
    }
 
    ++(*ptr);
    return TRUE;
}

Referenced by check_ipv4address().

check_hierarchical()

static BOOL check_hierarchical ( const WCHAR **  ptr )

static

Definition at line 293 of file uri.c.

                                                  {
    const WCHAR *start = *ptr;
 
    if(**ptr != '/')
        return FALSE;
 
    ++(*ptr);
    if(**ptr != '/') {
        *ptr = start;
        return FALSE;
    }
 
    ++(*ptr);
    return TRUE;
}

Referenced by is_hierarchical_uri(), and parse_canonicalize().

check_implicit_ipv4()

static BOOL check_implicit_ipv4 ( const WCHAR **  ptr, UINT *  val  )

static

Definition at line 1005 of file uri.c.

                                                              {
    const WCHAR *start = *ptr;
    ULONGLONG ret = 0;
    *val = 0;
 
    while(is_num(**ptr)) {
        ret = ret*10 + (**ptr - '0');
 
        if(ret > UINT_MAX) {
            *ptr = start;
            return FALSE;
        }
        ++(*ptr);
    }
 
    if(*ptr == start)
        return FALSE;
 
    *val = ret;
    return TRUE;
}

Referenced by parse_ipv4address().

check_ipv4address()

static BOOL check_ipv4address ( const WCHAR **  ptr, BOOL  strict  )

static

Definition at line 1037 of file uri.c.

                                                              {
    const WCHAR *start = *ptr;
 
    if(!check_dec_octet(ptr)) {
        *ptr = start;
        return FALSE;
    }
 
    if(**ptr != '.') {
        *ptr = start;
        return FALSE;
    }
 
    ++(*ptr);
    if(!check_dec_octet(ptr)) {
        *ptr = start;
        return FALSE;
    }
 
    if(**ptr != '.') {
        if(strict) {
            *ptr = start;
            return FALSE;
        } else
            return TRUE;
    }
 
    ++(*ptr);
    if(!check_dec_octet(ptr)) {
        *ptr = start;
        return FALSE;
    }
 
    if(**ptr != '.') {
        if(strict) {
            *ptr = start;
            return FALSE;
        } else
            return TRUE;
    }
 
    ++(*ptr);
    if(!check_dec_octet(ptr)) {
        *ptr = start;
        return FALSE;
    }
 
    /* Found a four digit ip address. */
    return TRUE;
}

Referenced by parse_ipv4address(), and parse_ipv6address().

check_pct_encoded()

static BOOL check_pct_encoded ( const WCHAR **  ptr )

static

Definition at line 936 of file uri.c.

                                                 {
    const WCHAR *start = *ptr;
 
    if(**ptr != '%')
        return FALSE;
 
    ++(*ptr);
    if(!is_hexdigit(**ptr)) {
        *ptr = start;
        return FALSE;
    }
 
    ++(*ptr);
    if(!is_hexdigit(**ptr)) {
        *ptr = start;
        return FALSE;
    }
 
    ++(*ptr);
    return TRUE;
}

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.

{
    HRESULT hr;
    IInternetProtocolInfo *info;
    Uri *relative, *base;
    TRACE("(%p %p %x %p %x)\n", pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
 
    if(!ppCombinedUri)
        return E_INVALIDARG;
 
    if(!pBaseUri || !pRelativeUri) {
        *ppCombinedUri = NULL;
        return E_INVALIDARG;
    }
 
    relative = get_uri_obj(pRelativeUri);
    base = get_uri_obj(pBaseUri);
    if(!relative || !base) {
        *ppCombinedUri = NULL;
        FIXME("(%p %p %x %p %x) Unknown IUri types not supported yet.\n",
            pBaseUri, pRelativeUri, dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
        return E_NOTIMPL;
    }
 
    info = get_protocol_info(base->canon_uri);
    if(info) {
        WCHAR result[INTERNET_MAX_URL_LENGTH+1];
        DWORD result_len = 0;
 
        hr = IInternetProtocolInfo_CombineUrl(info, base->canon_uri, relative->canon_uri, dwCombineFlags,
                                              result, INTERNET_MAX_URL_LENGTH+1, &result_len, 0);
        IInternetProtocolInfo_Release(info);
        if(SUCCEEDED(hr)) {
            hr = CreateUri(result, Uri_CREATE_ALLOW_RELATIVE, 0, ppCombinedUri);
            if(SUCCEEDED(hr))
                return hr;
        }
    }
 
    return combine_uri(base, relative, dwCombineFlags, ppCombinedUri, 0);
}

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.

{
    IUri *relative;
    Uri *base;
    HRESULT hr;
    IInternetProtocolInfo *info;
 
    TRACE("(%p %s %x %p %x)\n", pBaseUri, debugstr_w(pwzRelativeUrl), dwCombineFlags,
        ppCombinedUri, (DWORD)dwReserved);
 
    if(!ppCombinedUri)
        return E_POINTER;
 
    if(!pwzRelativeUrl) {
        *ppCombinedUri = NULL;
        return E_UNEXPECTED;
    }
 
    if(!pBaseUri) {
        *ppCombinedUri = NULL;
        return E_INVALIDARG;
    }
 
    base = get_uri_obj(pBaseUri);
    if(!base) {
        *ppCombinedUri = NULL;
        FIXME("(%p %s %x %p %x) Unknown IUri's not supported yet.\n", pBaseUri, debugstr_w(pwzRelativeUrl),
            dwCombineFlags, ppCombinedUri, (DWORD)dwReserved);
        return E_NOTIMPL;
    }
 
    info = get_protocol_info(base->canon_uri);
    if(info) {
        WCHAR result[INTERNET_MAX_URL_LENGTH+1];
        DWORD result_len = 0;
 
        hr = IInternetProtocolInfo_CombineUrl(info, base->canon_uri, pwzRelativeUrl, dwCombineFlags,
                                              result, INTERNET_MAX_URL_LENGTH+1, &result_len, 0);
        IInternetProtocolInfo_Release(info);
        if(SUCCEEDED(hr)) {
            hr = CreateUri(result, Uri_CREATE_ALLOW_RELATIVE, 0, ppCombinedUri);
            if(SUCCEEDED(hr))
                return hr;
        }
    }
 
    hr = CreateUri(pwzRelativeUrl, Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, &relative);
    if(FAILED(hr)) {
        *ppCombinedUri = NULL;
        return hr;
    }
 
    hr = combine_uri(base, get_uri_obj(relative), dwCombineFlags, ppCombinedUri, COMBINE_URI_FORCE_FLAG_USE);
 
    IUri_Release(relative);
    return hr;
}

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.

{
    HRESULT hr;
    Uri *uri;
    IInternetProtocolInfo *info;
 
    TRACE("(%p %d %x %p %d %p %x)\n", pIUri, ParseAction, dwFlags, pwzResult,
        cchResult, pcchResult, (DWORD)dwReserved);
 
    if(!pcchResult)
        return E_POINTER;
 
    if(!pwzResult || !pIUri) {
        *pcchResult = 0;
        return E_INVALIDARG;
    }
 
    if(!(uri = get_uri_obj(pIUri))) {
        *pcchResult = 0;
        FIXME("(%p %d %x %p %d %p %x) Unknown IUri's not supported for this action.\n",
            pIUri, ParseAction, dwFlags, pwzResult, cchResult, pcchResult, (DWORD)dwReserved);
        return E_NOTIMPL;
    }
 
    info = get_protocol_info(uri->canon_uri);
    if(info) {
        hr = IInternetProtocolInfo_ParseUrl(info, uri->canon_uri, ParseAction, dwFlags,
                                            pwzResult, cchResult, pcchResult, 0);
        IInternetProtocolInfo_Release(info);
        if(SUCCEEDED(hr)) return hr;
    }
 
    switch(ParseAction) {
    case PARSE_CANONICALIZE:
        hr = parse_canonicalize(uri, dwFlags, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_FRIENDLY:
        hr = parse_friendly(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_ROOTDOCUMENT:
        hr = parse_rootdocument(uri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_DOCUMENT:
        hr = parse_document(uri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_PATH_FROM_URL:
        hr = parse_path_from_url(uri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_URL_FROM_PATH:
        hr = parse_url_from_path(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_SCHEMA:
        hr = parse_schema(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_SITE:
        hr = parse_site(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_DOMAIN:
        hr = parse_domain(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_LOCATION:
    case PARSE_ANCHOR:
        hr = parse_anchor(pIUri, pwzResult, cchResult, pcchResult);
        break;
    case PARSE_SECURITY_URL:
    case PARSE_MIME:
    case PARSE_SERVER:
    case PARSE_SECURITY_DOMAIN:
        *pcchResult = 0;
        hr = E_FAIL;
        break;
    default:
        *pcchResult = 0;
        hr = E_NOTIMPL;
        FIXME("(%p %d %x %p %d %p %x) Partial stub.\n", pIUri, ParseAction, dwFlags,
            pwzResult, cchResult, pcchResult, (DWORD)dwReserved);
    }
 
    return hr;
}

Referenced by FileProtocol_StartEx(), and nsFileURL_GetFile().

combine_uri()

static HRESULT combine_uri ( Uri *  base, Uri *  relative, DWORD  flags, IUri **  result, DWORD  extras  )

static

Definition at line 6450 of file uri.c.

                                                                                               {
    Uri *ret;
    HRESULT hr;
    parse_data data;
    Uri *proc_uri = base;
    DWORD create_flags = 0, len = 0;
 
    memset(&data, 0, sizeof(parse_data));
 
    /* Base case is when the relative Uri has a scheme name,
     * if it does, then 'result' will contain the same data
     * as the relative Uri.
     */
    if(relative->scheme_start > -1) {
        data.uri = SysAllocString(relative->raw_uri);
        if(!data.uri) {
            *result = NULL;
            return E_OUTOFMEMORY;
        }
 
        parse_uri(&data, Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME);
 
        hr = Uri_Construct(NULL, (void**)&ret);
        if(FAILED(hr)) {
            *result = NULL;
            return hr;
        }
 
        if(extras & COMBINE_URI_FORCE_FLAG_USE) {
            if(flags & URL_DONT_SIMPLIFY)
                create_flags |= Uri_CREATE_NO_CANONICALIZE;
            if(flags & URL_DONT_UNESCAPE_EXTRA_INFO)
                create_flags |= Uri_CREATE_NO_DECODE_EXTRA_INFO;
        }
 
        ret->raw_uri = data.uri;
        hr = canonicalize_uri(&data, ret, create_flags);
        if(FAILED(hr)) {
            IUri_Release(&ret->IUri_iface);
            *result = NULL;
            return hr;
        }
 
        apply_default_flags(&create_flags);
        ret->create_flags = create_flags;
 
        *result = &ret->IUri_iface;
    } else {
        WCHAR *path = NULL;
        DWORD raw_flags = 0;
 
        if(base->scheme_start > -1) {
            data.scheme = base->canon_uri+base->scheme_start;
            data.scheme_len = base->scheme_len;
            data.scheme_type = base->scheme_type;
        } else {
            data.is_relative = TRUE;
            data.scheme_type = URL_SCHEME_UNKNOWN;
            create_flags |= Uri_CREATE_ALLOW_RELATIVE;
        }
 
        if(relative->authority_start > -1)
            proc_uri = relative;
 
        if(proc_uri->authority_start > -1) {
            if(proc_uri->userinfo_start > -1 && proc_uri->userinfo_split != 0) {
                data.username = proc_uri->canon_uri+proc_uri->userinfo_start;
                data.username_len = (proc_uri->userinfo_split > -1) ? proc_uri->userinfo_split : proc_uri->userinfo_len;
            }
 
            if(proc_uri->userinfo_split > -1) {
                data.password = proc_uri->canon_uri+proc_uri->userinfo_start+proc_uri->userinfo_split+1;
                data.password_len = proc_uri->userinfo_len-proc_uri->userinfo_split-1;
            }
 
            if(proc_uri->host_start > -1) {
                data.host = proc_uri->canon_uri+proc_uri->host_start;
                data.host_len = proc_uri->host_len;
                data.host_type = proc_uri->host_type;
            }
 
            if(proc_uri->has_port) {
                data.has_port = TRUE;
                data.port_value = proc_uri->port;
            }
        } else if(base->scheme_type != URL_SCHEME_FILE)
            data.is_opaque = TRUE;
 
        if(proc_uri == relative || relative->path_start == -1 || !relative->path_len) {
            if(proc_uri->path_start > -1) {
                data.path = proc_uri->canon_uri+proc_uri->path_start;
                data.path_len = proc_uri->path_len;
            } else if(!data.is_opaque) {
                /* Just set the path as a '/' if the base didn't have
                 * one and if it's a hierarchical URI.
                 */
                static const WCHAR slashW[] = {'/',0};
                data.path = slashW;
                data.path_len = 1;
            }
 
            if(relative->query_start > -1)
                proc_uri = relative;
 
            if(proc_uri->query_start > -1) {
                data.query = proc_uri->canon_uri+proc_uri->query_start;
                data.query_len = proc_uri->query_len;
            }
        } else {
            const WCHAR *ptr, **pptr;
            DWORD path_offset = 0, path_len = 0;
 
            /* There's two possibilities on what will happen to the path component
             * of the result IUri. First, if the relative path begins with a '/'
             * then the resulting path will just be the relative path. Second, if
             * relative path doesn't begin with a '/' then the base path and relative
             * path are merged together.
             */
            if(relative->path_len && *(relative->canon_uri+relative->path_start) == '/' && data.scheme_type != URL_SCHEME_MK) {
                WCHAR *tmp = NULL;
                BOOL copy_drive_path = FALSE;
 
                /* If the relative IUri's path starts with a '/', then we
                 * don't use the base IUri's path. Unless the base IUri
                 * is a file URI, in which case it uses the drive path of
                 * the base IUri (if it has any) in the new path.
                 */
                if(base->scheme_type == URL_SCHEME_FILE) {
                    if(base->path_len > 3 && *(base->canon_uri+base->path_start) == '/' &&
                       is_drive_path(base->canon_uri+base->path_start+1)) {
                        path_len += 3;
                        copy_drive_path = TRUE;
                    }
                }
 
                path_len += relative->path_len;
 
                path = heap_alloc((path_len+1)*sizeof(WCHAR));
                if(!path) {
                    *result = NULL;
                    return E_OUTOFMEMORY;
                }
 
                tmp = path;
 
                /* Copy the base paths, drive path over. */
                if(copy_drive_path) {
                    memcpy(tmp, base->canon_uri+base->path_start, 3*sizeof(WCHAR));
                    tmp += 3;
                }
 
                memcpy(tmp, relative->canon_uri+relative->path_start, relative->path_len*sizeof(WCHAR));
                path[path_len] = '\0';
            } else {
                /* Merge the base path with the relative path. */
                hr = merge_paths(&data, base->canon_uri+base->path_start, base->path_len,
                                 relative->canon_uri+relative->path_start, relative->path_len,
                                 &path, &path_len, flags);
                if(FAILED(hr)) {
                    *result = NULL;
                    return hr;
                }
 
                /* If the resulting IUri is a file URI, the drive path isn't
                 * reduced out when the dot segments are removed.
                 */
                if(path_len >= 3 && data.scheme_type == URL_SCHEME_FILE && !data.host) {
                    if(*path == '/' && is_drive_path(path+1))
                        path_offset = 2;
                    else if(is_drive_path(path))
                        path_offset = 1;
                }
            }
 
            /* Check if the dot segments need to be removed from the path. */
            if(!(flags & URL_DONT_SIMPLIFY) && !data.is_opaque) {
                DWORD offset = (path_offset > 0) ? path_offset+1 : 0;
                DWORD new_len = remove_dot_segments(path+offset,path_len-offset);
 
                if(new_len != path_len) {
                    WCHAR *tmp = heap_realloc(path, (offset+new_len+1)*sizeof(WCHAR));
                    if(!tmp) {
                        heap_free(path);
                        *result = NULL;
                        return E_OUTOFMEMORY;
                    }
 
                    tmp[new_len+offset] = '\0';
                    path = tmp;
                    path_len = new_len+offset;
                }
            }
 
            if(relative->query_start > -1) {
                data.query = relative->canon_uri+relative->query_start;
                data.query_len = relative->query_len;
            }
 
            /* Make sure the path component is valid. */
            ptr = path;
            pptr = &ptr;
            if((data.is_opaque && !parse_path_opaque(pptr, &data, 0)) ||
               (!data.is_opaque && !parse_path_hierarchical(pptr, &data, 0))) {
                heap_free(path);
                *result = NULL;
                return E_INVALIDARG;
            }
        }
 
        if(relative->fragment_start > -1) {
            data.fragment = relative->canon_uri+relative->fragment_start;
            data.fragment_len = relative->fragment_len;
        }
 
        if(flags & URL_DONT_SIMPLIFY)
            raw_flags |= RAW_URI_FORCE_PORT_DISP;
        if(flags & URL_FILE_USE_PATHURL)
            raw_flags |= RAW_URI_CONVERT_TO_DOS_PATH;
 
        len = generate_raw_uri(&data, data.uri, raw_flags);
        data.uri = SysAllocStringLen(NULL, len);
        if(!data.uri) {
            heap_free(path);
            *result = NULL;
            return E_OUTOFMEMORY;
        }
 
        generate_raw_uri(&data, data.uri, raw_flags);
 
        hr = Uri_Construct(NULL, (void**)&ret);
        if(FAILED(hr)) {
            SysFreeString(data.uri);
            heap_free(path);
            *result = NULL;
            return hr;
        }
 
        if(flags & URL_DONT_SIMPLIFY)
            create_flags |= Uri_CREATE_NO_CANONICALIZE;
        if(flags & URL_FILE_USE_PATHURL)
            create_flags |= Uri_CREATE_FILE_USE_DOS_PATH;
 
        ret->raw_uri = data.uri;
        hr = canonicalize_uri(&data, ret, create_flags);
        if(FAILED(hr)) {
            IUri_Release(&ret->IUri_iface);
            *result = NULL;
            return hr;
        }
 
        if(flags & URL_DONT_SIMPLIFY)
            ret->display_modifiers |= URI_DISPLAY_NO_DEFAULT_PORT_AUTH;
 
        apply_default_flags(&create_flags);
        ret->create_flags = create_flags;
        *result = &ret->IUri_iface;
 
        heap_free(path);
    }
 
    return S_OK;
}

Referenced by CoInternetCombineIUri(), and CoInternetCombineUrlEx().

compare_file_paths()

static HRESULT compare_file_paths ( const Uri *  a, const Uri *  b, BOOL *  ret  )

static

Definition at line 3875 of file uri.c.

{
    WCHAR *canon_path_a, *canon_path_b;
    DWORD len_a, len_b;
 
    if(!a->path_len) {
        *ret = !b->path_len;
        return S_OK;
    }
 
    if(!b->path_len) {
        *ret = FALSE;
        return S_OK;
    }
 
    /* Fast path */
    if(a->path_len == b->path_len && !_wcsnicmp(a->canon_uri+a->path_start, b->canon_uri+b->path_start, a->path_len)) {
        *ret = TRUE;
        return S_OK;
    }
 
    len_a = canonicalize_path_hierarchical(a->canon_uri+a->path_start, a->path_len, a->scheme_type, FALSE, 0, FALSE, NULL);
    len_b = canonicalize_path_hierarchical(b->canon_uri+b->path_start, b->path_len, b->scheme_type, FALSE, 0, FALSE, NULL);
 
    canon_path_a = heap_alloc(len_a*sizeof(WCHAR));
    if(!canon_path_a)
        return E_OUTOFMEMORY;
    canon_path_b = heap_alloc(len_b*sizeof(WCHAR));
    if(!canon_path_b) {
        heap_free(canon_path_a);
        return E_OUTOFMEMORY;
    }
 
    len_a = canonicalize_path_hierarchical(a->canon_uri+a->path_start, a->path_len, a->scheme_type, FALSE, 0, FALSE, canon_path_a);
    len_b = canonicalize_path_hierarchical(b->canon_uri+b->path_start, b->path_len, b->scheme_type, FALSE, 0, FALSE, canon_path_b);
 
    *ret = len_a == len_b && !_wcsnicmp(canon_path_a, canon_path_b, len_a);
 
    heap_free(canon_path_a);
    heap_free(canon_path_b);
    return S_OK;
}

Referenced by compare_uris().

compare_uris()

static HRESULT compare_uris ( const Uri *  a, const Uri *  b, BOOL *  ret  )

static

Definition at line 3923 of file uri.c.

                                                                   {
    const BOOL known_scheme = a->scheme_type != URL_SCHEME_UNKNOWN;
    const BOOL are_hierarchical = a->authority_start > -1 && b->authority_start > -1;
    HRESULT hres;
 
    *ret = FALSE;
 
    if(a->scheme_type != b->scheme_type)
        return S_OK;
 
    /* Only compare the scheme names (if any) if their unknown scheme types. */
    if(!known_scheme) {
        if((a->scheme_start > -1 && b->scheme_start > -1) &&
           (a->scheme_len == b->scheme_len)) {
            /* Make sure the schemes are the same. */
            if(StrCmpNW(a->canon_uri+a->scheme_start, b->canon_uri+b->scheme_start, a->scheme_len))
                return S_OK;
        } else if(a->scheme_len != b->scheme_len)
            /* One of the Uri's has a scheme name, while the other doesn't. */
            return S_OK;
    }
 
    /* If they have a userinfo component, perform case sensitive compare. */
    if((a->userinfo_start > -1 && b->userinfo_start > -1) &&
       (a->userinfo_len == b->userinfo_len)) {
        if(StrCmpNW(a->canon_uri+a->userinfo_start, b->canon_uri+b->userinfo_start, a->userinfo_len))
            return S_OK;
    } else if(a->userinfo_len != b->userinfo_len)
        /* One of the Uri's had a userinfo, while the other one doesn't. */
        return S_OK;
 
    /* Check if they have a host name. */
    if((a->host_start > -1 && b->host_start > -1) &&
       (a->host_len == b->host_len)) {
        /* Perform a case insensitive compare if they are a known scheme type. */
        if(known_scheme) {
            if(StrCmpNIW(a->canon_uri+a->host_start, b->canon_uri+b->host_start, a->host_len))
                return S_OK;
        } else if(StrCmpNW(a->canon_uri+a->host_start, b->canon_uri+b->host_start, a->host_len))
            return S_OK;
    } else if(a->host_len != b->host_len)
        /* One of the Uri's had a host, while the other one didn't. */
        return S_OK;
 
    if(a->has_port && b->has_port) {
        if(a->port != b->port)
            return S_OK;
    } else if(a->has_port || b->has_port)
        /* One had a port, while the other one didn't. */
        return S_OK;
 
    /* Windows is weird with how it handles paths. For example
     * One URI could be "http://google.com" (after canonicalization)
     * and one could be "http://google.com/" and the IsEqual function
     * would still evaluate to TRUE, but, only if they are both hierarchical
     * URIs.
     */
    if(a->scheme_type == URL_SCHEME_FILE) {
        BOOL cmp;
 
        hres = compare_file_paths(a, b, &cmp);
        if(FAILED(hres) || !cmp)
            return hres;
    } else if((a->path_start > -1 && b->path_start > -1) &&
       (a->path_len == b->path_len)) {
        if(StrCmpNW(a->canon_uri+a->path_start, b->canon_uri+b->path_start, a->path_len))
            return S_OK;
    } else if(are_hierarchical && a->path_len == -1 && b->path_len == 0) {
        if(*(a->canon_uri+a->path_start) != '/')
            return S_OK;
    } else if(are_hierarchical && b->path_len == 1 && a->path_len == 0) {
        if(*(b->canon_uri+b->path_start) != '/')
            return S_OK;
    } else if(a->path_len != b->path_len)
        return S_OK;
 
    /* Compare the query strings of the two URIs. */
    if((a->query_start > -1 && b->query_start > -1) &&
       (a->query_len == b->query_len)) {
        if(StrCmpNW(a->canon_uri+a->query_start, b->canon_uri+b->query_start, a->query_len))
            return S_OK;
    } else if(a->query_len != b->query_len)
        return S_OK;
 
    if((a->fragment_start > -1 && b->fragment_start > -1) &&
       (a->fragment_len == b->fragment_len)) {
        if(StrCmpNW(a->canon_uri+a->fragment_start, b->canon_uri+b->fragment_start, a->fragment_len))
            return S_OK;
    } else if(a->fragment_len != b->fragment_len)
        return S_OK;
 
    /* If we get here, the two URIs are equivalent. */
    *ret = TRUE;
    return S_OK;
}

Referenced by Uri_IsEqual().

compute_canonicalized_length()

static int compute_canonicalized_length ( const parse_data *  data, DWORD  flags  )

static

Definition at line 3332 of file uri.c.

                                                                             {
    Uri uri;
 
    memset(&uri, 0, sizeof(Uri));
 
    TRACE("(%p %x): Beginning to compute canonicalized length for URI %s\n", data, flags,
            debugstr_w(data->uri));
 
    if(!canonicalize_scheme(data, &uri, flags, TRUE)) {
        ERR("(%p %x): Failed to compute URI scheme length.\n", data, flags);
        return -1;
    }
 
    if(!canonicalize_hierpart(data, &uri, flags, TRUE)) {
        ERR("(%p %x): Failed to compute URI hierpart length.\n", data, flags);
        return -1;
    }
 
    if(!canonicalize_query(data, &uri, flags, TRUE)) {
        ERR("(%p %x): Failed to compute query string length.\n", data, flags);
        return -1;
    }
 
    if(!canonicalize_fragment(data, &uri, flags, TRUE)) {
        ERR("(%p %x): Failed to compute fragment length.\n", data, flags);
        return -1;
    }
 
    TRACE("(%p %x): Finished computing canonicalized URI length. length=%d\n", data, flags, uri.canon_len);
 
    return uri.canon_len;
}

Referenced by canonicalize_uri().

compute_elision_location()

static void compute_elision_location ( const ipv6_address *  address, const USHORT  values[8], INT *  index, DWORD *  count  )

static

Definition at line 716 of file uri.c.

                                                               {
    DWORD i, max_len, cur_len;
    INT max_index, cur_index;
 
    max_len = cur_len = 0;
    max_index = cur_index = -1;
    for(i = 0; i < 8; ++i) {
        BOOL check_ipv4 = (address->ipv4 && i == 6);
        BOOL is_end = (check_ipv4 || i == 7);
 
        if(check_ipv4) {
            /* Check if the IPv4 address contains only zeros. */
            if(values[i] == 0 && values[i+1] == 0) {
                if(cur_index == -1)
                    cur_index = i;
 
                cur_len += 2;
                ++i;
            }
        } else if(values[i] == 0) {
            if(cur_index == -1)
                cur_index = i;
 
            ++cur_len;
        }
 
        if(is_end || values[i] != 0) {
            /* We only consider it for an elision if it's
             * more than 1 component long.
             */
            if(cur_len > 1 && cur_len > max_len) {
                /* Found the new elision location. */
                max_len = cur_len;
                max_index = cur_index;
            }
 
            /* Reset the current range for the next range of zeros. */
            cur_index = -1;
            cur_len = 0;
        }
    }
 
    *index = max_index;
    *count = max_len;
}

Referenced by canonicalize_ipv6address().

compute_ipv6_comps_size()

static void compute_ipv6_comps_size ( ipv6_address *  address )

static

Definition at line 445 of file uri.c.

                                                           {
    address->components_size = address->h16_count * 2;
 
    if(address->ipv4)
        /* IPv4 address is 4 bytes. */
        address->components_size += 4;
 
    if(address->elision) {
        /* An elision can be anywhere from 2 bytes up to 16 bytes.
         * Its size depends on the size of the h16 and IPv4 components.
         */
        address->elision_size = 16 - address->components_size;
        if(address->elision_size < 2)
            address->elision_size = 2;
    } else
        address->elision_size = 0;
}

Referenced by parse_ipv6address().

convert_to_dos_path()

static void convert_to_dos_path ( const WCHAR *  path, DWORD  path_len, WCHAR *  output, DWORD *  output_len  )

static

Definition at line 4019 of file uri.c.

{
    const WCHAR *ptr = path;
 
    if(path_len > 3 && *ptr == '/' && is_drive_path(path+1))
        /* Skip over the leading / before the drive path. */
        ++ptr;
 
    for(; ptr < path+path_len; ++ptr) {
        if(*ptr == '/') {
            if(output)
                *output++ = '\\';
            (*output_len)++;
        } else {
            if(output)
                *output++ = *ptr;
            (*output_len)++;
        }
    }
}

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.

{
    UriBuilder *ret;
 
    TRACE("(%p %x %x %p)\n", pIUri, dwFlags, (DWORD)dwReserved, ppIUriBuilder);
 
    if(!ppIUriBuilder)
        return E_POINTER;
 
    ret = heap_alloc_zero(sizeof(UriBuilder));
    if(!ret)
        return E_OUTOFMEMORY;
 
    ret->IUriBuilder_iface.lpVtbl = &UriBuilderVtbl;
    ret->ref = 1;
 
    if(pIUri) {
        Uri *uri;
 
        if((uri = get_uri_obj(pIUri))) {
            if(!uri->create_flags) {
                heap_free(ret);
                return E_UNEXPECTED;
            }
            IUri_AddRef(pIUri);
            ret->uri = uri;
 
            if(uri->has_port)
                /* Windows doesn't set 'has_port' to TRUE in this case. */
                ret->port = uri->port;
 
        } else {
            heap_free(ret);
            *ppIUriBuilder = NULL;
            FIXME("(%p %x %x %p): Unknown IUri types not supported yet.\n", pIUri, dwFlags,
                (DWORD)dwReserved, ppIUriBuilder);
            return E_NOTIMPL;
        }
    }
 
    *ppIUriBuilder = &ret->IUriBuilder_iface;
    return S_OK;
}

Referenced by ensure_uri_builder(), get_uri_nofrag(), nsURI_GetPrePath(), UriBuilderFactory_CreateInitializedIUriBuilder(), and UriBuilderFactory_CreateIUriBuilder().

CreateUri()

HRESULT WINAPI CreateUri	(	LPCWSTR	pwzURI,
		DWORD	dwFlags,
		DWORD_PTR	dwReserved,
		IUri **	ppURI
	)

Definition at line 5700 of file uri.c.

{
    const DWORD supported_flags = Uri_CREATE_ALLOW_RELATIVE|Uri_CREATE_ALLOW_IMPLICIT_WILDCARD_SCHEME|
        Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME|Uri_CREATE_NO_CANONICALIZE|Uri_CREATE_CANONICALIZE|
        Uri_CREATE_DECODE_EXTRA_INFO|Uri_CREATE_NO_DECODE_EXTRA_INFO|Uri_CREATE_CRACK_UNKNOWN_SCHEMES|
        Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES|Uri_CREATE_PRE_PROCESS_HTML_URI|Uri_CREATE_NO_PRE_PROCESS_HTML_URI|
        Uri_CREATE_NO_IE_SETTINGS|Uri_CREATE_NO_ENCODE_FORBIDDEN_CHARACTERS|Uri_CREATE_FILE_USE_DOS_PATH;
    Uri *ret;
    HRESULT hr;
    parse_data data;
 
    TRACE("(%s %x %x %p)\n", debugstr_w(pwzURI), dwFlags, (DWORD)dwReserved, ppURI);
 
    if(!ppURI)
        return E_INVALIDARG;
 
    if(!pwzURI) {
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Check for invalid flags. */
    if(has_invalid_flag_combination(dwFlags)) {
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Currently unsupported. */
    if(dwFlags & ~supported_flags)
        FIXME("Ignoring unsupported flag(s) %x\n", dwFlags & ~supported_flags);
 
    hr = Uri_Construct(NULL, (void**)&ret);
    if(FAILED(hr)) {
        *ppURI = NULL;
        return hr;
    }
 
    /* Explicitly set the default flags if it doesn't cause a flag conflict. */
    apply_default_flags(&dwFlags);
 
    /* Pre process the URI, unless told otherwise. */
    if(!(dwFlags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI))
        ret->raw_uri = pre_process_uri(pwzURI);
    else
        ret->raw_uri = SysAllocString(pwzURI);
 
    if(!ret->raw_uri) {
        heap_free(ret);
        return E_OUTOFMEMORY;
    }
 
    memset(&data, 0, sizeof(parse_data));
    data.uri = ret->raw_uri;
 
    /* Validate and parse the URI into its components. */
    if(!parse_uri(&data, dwFlags)) {
        /* Encountered an unsupported or invalid URI */
        IUri_Release(&ret->IUri_iface);
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Canonicalize the URI. */
    hr = canonicalize_uri(&data, ret, dwFlags);
    if(FAILED(hr)) {
        IUri_Release(&ret->IUri_iface);
        *ppURI = NULL;
        return hr;
    }
 
    ret->create_flags = dwFlags;
 
    *ppURI = &ret->IUri_iface;
    return S_OK;
}

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.

{
    HRESULT hres;
    TRACE("(%s %s %x %x %p)\n", debugstr_w(pwzURI), debugstr_w(pwzFragment), dwFlags, (DWORD)dwReserved, ppURI);
 
    if(!ppURI)
        return E_INVALIDARG;
 
    if(!pwzURI) {
        *ppURI = NULL;
        return E_INVALIDARG;
    }
 
    /* Check if a fragment should be appended to the URI string. */
    if(pwzFragment) {
        WCHAR *uriW;
        DWORD uri_len, frag_len;
        BOOL add_pound;
 
        /* Check if the original URI already has a fragment component. */
        if(StrChrW(pwzURI, '#')) {
            *ppURI = NULL;
            return E_INVALIDARG;
        }
 
        uri_len = lstrlenW(pwzURI);
        frag_len = lstrlenW(pwzFragment);
 
        /* If the fragment doesn't start with a '#', one will be added. */
        add_pound = *pwzFragment != '#';
 
        if(add_pound)
            uriW = heap_alloc((uri_len+frag_len+2)*sizeof(WCHAR));
        else
            uriW = heap_alloc((uri_len+frag_len+1)*sizeof(WCHAR));
 
        if(!uriW)
            return E_OUTOFMEMORY;
 
        memcpy(uriW, pwzURI, uri_len*sizeof(WCHAR));
        if(add_pound)
            uriW[uri_len++] = '#';
        memcpy(uriW+uri_len, pwzFragment, (frag_len+1)*sizeof(WCHAR));
 
        hres = CreateUri(uriW, dwFlags, 0, ppURI);
 
        heap_free(uriW);
    } else
        /* A fragment string wasn't specified, so just forward the call. */
        hres = CreateUri(pwzURI, dwFlags, 0, ppURI);
 
    return hres;
}

decode_pct_val()

static WCHAR decode_pct_val ( const WCHAR *  ptr )

static

Definition at line 483 of file uri.c.

                                              {
    WCHAR ret = '\0';
 
    if(*ptr == '%' && is_hexdigit(*(ptr + 1)) && is_hexdigit(*(ptr + 2))) {
        INT a = hex_to_int(*(ptr + 1));
        INT b = hex_to_int(*(ptr + 2));
 
        ret = a << 4;
        ret += b;
    }
 
    return ret;
}

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()

static void destroy_uri_obj ( Uri *  This )

inlinestatic

Definition at line 4211 of file uri.c.

{
    SysFreeString(This->raw_uri);
    heap_free(This->canon_uri);
    heap_free(This);
}

Referenced by Uri_Release().

find_domain_name()

void find_domain_name	(	const WCHAR *	host,
		DWORD	host_len,
		INT *	domain_start
	)

Definition at line 520 of file uri.c.

                                                {
    const WCHAR *last_tld, *sec_last_tld, *end, *p;
 
    end = host+host_len-1;
 
    *domain_start = -1;
 
    /* There has to be at least enough room for a '.' followed by a
     * 3-character TLD for a domain to even exist in the host name.
     */
    if(host_len < 4)
        return;
 
    for (last_tld = sec_last_tld = NULL, p = host; p <= end; p++)
    {
        if (*p == '.')
        {
            sec_last_tld = last_tld;
            last_tld = p;
        }
    }
    if(!last_tld)
        /* http://hostname -> has no domain name. */
        return;
 
    if(!sec_last_tld) {
        /* If the '.' is at the beginning of the host there
         * has to be at least 3 characters in the TLD for it
         * to be valid.
         *  Ex: .com -> .com as the domain name.
         *      .co  -> has no domain name.
         */
        if(last_tld-host == 0) {
            if(end-(last_tld-1) < 3)
                return;
        } else if(last_tld-host == 3) {
            DWORD i;
 
            /* If there are three characters in front of last_tld and
             * they are on the list of recognized TLDs, then this
             * host doesn't have a domain (since the host only contains
             * a TLD name.
             *  Ex: edu.uk -> has no domain name.
             *      foo.uk -> foo.uk as the domain name.
             */
            for(i = 0; i < ARRAY_SIZE(recognized_tlds); ++i) {
                if(!StrCmpNIW(host, recognized_tlds[i].tld_name, 3))
                    return;
            }
        } else if(last_tld-host < 3)
            /* Anything less than 3 characters is considered part
             * of the TLD name.
             *  Ex: ak.uk -> Has no domain name.
             */
            return;
 
        /* Otherwise the domain name is the whole host name. */
        *domain_start = 0;
    } else if(end+1-last_tld > 3) {
        /* If the last_tld has more than 3 characters, then it's automatically
         * considered the TLD of the domain name.
         *  Ex: www.winehq.org.uk.test -> uk.test as the domain name.
         */
        *domain_start = (sec_last_tld+1)-host;
    } else if(last_tld - (sec_last_tld+1) < 4) {
        DWORD i;
        /* If the sec_last_tld is 3 characters long it HAS to be on the list of
         * recognized to still be considered part of the TLD name, otherwise
         * it's considered the domain name.
         *  Ex: www.google.com.uk -> google.com.uk as the domain name.
         *      www.google.foo.uk -> foo.uk as the domain name.
         */
        if(last_tld - (sec_last_tld+1) == 3) {
            for(i = 0; i < ARRAY_SIZE(recognized_tlds); ++i) {
                if(!StrCmpNIW(sec_last_tld+1, recognized_tlds[i].tld_name, 3)) {
                    for (p = sec_last_tld; p > host; p--) if (p[-1] == '.') break;
                    *domain_start = p - host;
                    TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start,
                                                        (host+host_len)-(host+*domain_start)));
                    return;
                }
            }
 
            *domain_start = (sec_last_tld+1)-host;
        } else {
            /* Since the sec_last_tld is less than 3 characters it's considered
             * part of the TLD.
             *  Ex: www.google.fo.uk -> google.fo.uk as the domain name.
             */
            for (p = sec_last_tld; p > host; p--) if (p[-1] == '.') break;
            *domain_start = p - host;
        }
    } else {
        /* The second to last TLD has more than 3 characters making it
         * the domain name.
         *  Ex: www.google.test.us -> test.us as the domain name.
         */
        *domain_start = (sec_last_tld+1)-host;
    }
 
    TRACE("Found domain name %s\n", debugstr_wn(host+*domain_start,
                                        (host+host_len)-(host+*domain_start)));
}

Referenced by canonicalize_reg_name(), and search_domain_for_zone().

find_file_extension()

static INT find_file_extension ( const WCHAR *  path, DWORD  path_len  )

static

Definition at line 686 of file uri.c.

                                                                  {
    const WCHAR *end;
 
    for(end = path+path_len-1; end >= path && *end != '/' && *end != '\\'; --end) {
        if(*end == '.')
            return end-path;
    }
 
    return -1;
}

Referenced by canonicalize_hierpart().

generate_raw_uri()

static DWORD generate_raw_uri ( const parse_data *  data, BSTR  uri, DWORD  flags  )

static

Definition at line 4042 of file uri.c.

                                                                             {
    DWORD length = 0;
 
    if(data->scheme) {
        if(uri) {
            memcpy(uri, data->scheme, data->scheme_len*sizeof(WCHAR));
            uri[data->scheme_len] = ':';
        }
        length += data->scheme_len+1;
    }
 
    if(!data->is_opaque) {
        /* For the "//" which appears before the authority component. */
        if(uri) {
            uri[length] = '/';
            uri[length+1] = '/';
        }
        length += 2;
 
        /* Check if we need to add the "\\" before the host name
         * of a UNC server name in a DOS path.
         */
        if(flags & RAW_URI_CONVERT_TO_DOS_PATH &&
           data->scheme_type == URL_SCHEME_FILE && data->host) {
            if(uri) {
                uri[length] = '\\';
                uri[length+1] = '\\';
            }
            length += 2;
        }
    }
 
    if(data->username) {
        if(uri)
            memcpy(uri+length, data->username, data->username_len*sizeof(WCHAR));
        length += data->username_len;
    }
 
    if(data->password) {
        if(uri) {
            uri[length] = ':';
            memcpy(uri+length+1, data->password, data->password_len*sizeof(WCHAR));
        }
        length += data->password_len+1;
    }
 
    if(data->password || data->username) {
        if(uri)
            uri[length] = '@';
        ++length;
    }
 
    if(data->host) {
        /* IPv6 addresses get the brackets added around them if they don't already
         * have them.
         */
        const BOOL add_brackets = data->host_type == Uri_HOST_IPV6 && *(data->host) != '[';
        if(add_brackets) {
            if(uri)
                uri[length] = '[';
            ++length;
        }
 
        if(uri)
            memcpy(uri+length, data->host, data->host_len*sizeof(WCHAR));
        length += data->host_len;
 
        if(add_brackets) {
            if(uri)
                uri[length] = ']';
            length++;
        }
    }
 
    if(data->has_port) {
        /* The port isn't included in the raw uri if it's the default
         * port for the scheme type.
         */
        DWORD i;
        BOOL is_default = FALSE;
 
        for(i = 0; i < ARRAY_SIZE(default_ports); ++i) {
            if(data->scheme_type == default_ports[i].scheme &&
               data->port_value == default_ports[i].port)
                is_default = TRUE;
        }
 
        if(!is_default || flags & RAW_URI_FORCE_PORT_DISP) {
            if(uri)
                uri[length] = ':';
            ++length;
 
            if(uri)
                length += ui2str(uri+length, data->port_value);
            else
                length += ui2str(NULL, data->port_value);
        }
    }
 
    /* Check if a '/' should be added before the path for hierarchical URIs. */
    if(!data->is_opaque && data->path && *(data->path) != '/') {
        if(uri)
            uri[length] = '/';
        ++length;
    }
 
    if(data->path) {
        if(!data->is_opaque && data->scheme_type == URL_SCHEME_FILE &&
           flags & RAW_URI_CONVERT_TO_DOS_PATH) {
            DWORD len = 0;
 
            if(uri)
                convert_to_dos_path(data->path, data->path_len, uri+length, &len);
            else
                convert_to_dos_path(data->path, data->path_len, NULL, &len);
 
            length += len;
        } else {
            if(uri)
                memcpy(uri+length, data->path, data->path_len*sizeof(WCHAR));
            length += data->path_len;
        }
    }
 
    if(data->query) {
        if(uri)
            memcpy(uri+length, data->query, data->query_len*sizeof(WCHAR));
        length += data->query_len;
    }
 
    if(data->fragment) {
        if(uri)
            memcpy(uri+length, data->fragment, data->fragment_len*sizeof(WCHAR));
        length += data->fragment_len;
    }
 
    if(uri)
        TRACE("(%p %p): Generated raw uri=%s len=%d\n", data, uri, debugstr_wn(uri, length), length);
    else
        TRACE("(%p %p): Computed raw uri len=%d\n", data, uri, length);
 
    return length;
}

Referenced by combine_uri(), and generate_uri().

generate_uri()

static HRESULT generate_uri ( const UriBuilder *  builder, const parse_data *  data, Uri *  uri, DWORD  flags  )

static

Definition at line 4186 of file uri.c.

                                                                                                      {
    HRESULT hr;
    DWORD length = generate_raw_uri(data, NULL, 0);
    uri->raw_uri = SysAllocStringLen(NULL, length);
    if(!uri->raw_uri)
        return E_OUTOFMEMORY;
 
    generate_raw_uri(data, uri->raw_uri, 0);
 
    hr = canonicalize_uri(data, uri, flags);
    if(FAILED(hr)) {
        if(hr == E_INVALIDARG)
            return INET_E_INVALID_URL;
        return hr;
    }
 
    uri->create_flags = flags;
    return S_OK;
}

Referenced by build_uri().

get_builder_component()

static HRESULT get_builder_component ( LPWSTR *  component, DWORD *  component_len, LPCWSTR  source, DWORD  source_len, LPCWSTR *  output, DWORD *  output_len  )

static

Definition at line 3438 of file uri.c.

{
    if(!output_len) {
        if(output)
            *output = NULL;
        return E_POINTER;
    }
 
    if(!output) {
        *output_len = 0;
        return E_POINTER;
    }
 
    if(!(*component) && source) {
        /* Allocate 'component', and copy the contents from 'source'
         * into the new allocation.
         */
        *component = heap_alloc((source_len+1)*sizeof(WCHAR));
        if(!(*component))
            return E_OUTOFMEMORY;
 
        memcpy(*component, source, source_len*sizeof(WCHAR));
        (*component)[source_len] = '\0';
        *component_len = source_len;
    }
 
    *output = *component;
    *output_len = *component_len;
    return *output ? S_OK : S_FALSE;
}

Referenced by UriBuilder_GetFragment(), UriBuilder_GetHost(), UriBuilder_GetPassword(), UriBuilder_GetPath(), UriBuilder_GetQuery(), UriBuilder_GetSchemeName(), and UriBuilder_GetUserName().

get_uri_obj()

static Uri * get_uri_obj ( IUri *  uri )

static

Definition at line 254 of file uri.c.

{
    Uri *ret;
    HRESULT hres;
 
    hres = IUri_QueryInterface(uri, &IID_IUriObj, (void**)&ret);
    return SUCCEEDED(hres) ? ret : NULL;
}

Referenced by CoInternetCombineIUri(), CoInternetCombineUrlEx(), CoInternetParseIUri(), CreateIUriBuilder(), Uri_IsEqual(), and UriBuilder_SetIUri().

h16tous()

static USHORT h16tous ( h16  component )

static

Definition at line 872 of file uri.c.

                                     {
    DWORD i;
    USHORT ret = 0;
 
    for(i = 0; i < component.len; ++i) {
        ret <<= 4;
        ret += hex_to_int(component.str[i]);
    }
 
    return ret;
}

Referenced by ipv6_to_number().

has_invalid_flag_combination()

static BOOL has_invalid_flag_combination ( DWORD  flags )

inlinestatic

Definition at line 387 of file uri.c.

                                                             {
    return((flags & Uri_CREATE_DECODE_EXTRA_INFO && flags & Uri_CREATE_NO_DECODE_EXTRA_INFO) ||
           (flags & Uri_CREATE_CANONICALIZE && flags & Uri_CREATE_NO_CANONICALIZE) ||
           (flags & Uri_CREATE_CRACK_UNKNOWN_SCHEMES && flags & Uri_CREATE_NO_CRACK_UNKNOWN_SCHEMES) ||
           (flags & Uri_CREATE_PRE_PROCESS_HTML_URI && flags & Uri_CREATE_NO_PRE_PROCESS_HTML_URI) ||
           (flags & Uri_CREATE_IE_SETTINGS && flags & Uri_CREATE_NO_IE_SETTINGS));
}

Referenced by build_uri(), and CreateUri().

hex_to_int()

static int hex_to_int ( WCHAR  val )

static

Definition at line 464 of file uri.c.

                                 {
    if(val >= '0' && val <= '9')
        return val - '0';
    else if(val >= 'a' && val <= 'f')
        return val - 'a' + 10;
    else if(val >= 'A' && val <= 'F')
        return val - 'A' + 10;
 
    return -1;
}

Referenced by decode_pct_val(), and h16tous().

impl_from_IMarshal()

static Uri * impl_from_IMarshal ( IMarshal *  iface )

inlinestatic

Definition at line 5420 of file uri.c.

{
    return CONTAINING_RECORD(iface, Uri, IMarshal_iface);
}

Referenced by Marshal_AddRef(), Marshal_DisconnectObject(), Marshal_GetMarshalSizeMax(), Marshal_GetUnmarshalClass(), Marshal_MarshalInterface(), Marshal_QueryInterface(), Marshal_Release(), Marshal_ReleaseMarshalData(), and Marshal_UnmarshalInterface().

impl_from_IPersistStream()

static Uri * impl_from_IPersistStream ( IPersistStream *  iface )

inlinestatic

Definition at line 5127 of file uri.c.

{
    return CONTAINING_RECORD(iface, Uri, IPersistStream_iface);
}

Referenced by PersistStream_AddRef(), PersistStream_GetClassID(), PersistStream_GetSizeMax(), PersistStream_IsDirty(), PersistStream_Load(), PersistStream_QueryInterface(), PersistStream_Release(), and PersistStream_Save().

impl_from_IUri()

static Uri * impl_from_IUri ( IUri *  iface )

inlinestatic

Definition at line 4206 of file uri.c.

{
    return CONTAINING_RECORD(iface, Uri, IUri_iface);
}

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()

static UriBuilder * impl_from_IUriBuilder ( IUriBuilder *  iface )

inlinestatic

Definition at line 5908 of file uri.c.

{
    return CONTAINING_RECORD(iface, UriBuilder, IUriBuilder_iface);
}

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()

static Uri * impl_from_IUriBuilderFactory ( IUriBuilderFactory *  iface )

inlinestatic

Definition at line 5058 of file uri.c.

{
    return CONTAINING_RECORD(iface, Uri, IUriBuilderFactory_iface);
}

Referenced by UriBuilderFactory_AddRef(), UriBuilderFactory_CreateInitializedIUriBuilder(), UriBuilderFactory_CreateIUriBuilder(), UriBuilderFactory_QueryInterface(), and UriBuilderFactory_Release().

ipv4toui()

static UINT ipv4toui ( const WCHAR *  ip, DWORD  len  )

static

Definition at line 806 of file uri.c.

                                                 {
    UINT ret = 0;
    DWORD comp_value = 0;
    const WCHAR *ptr;
 
    for(ptr = ip; ptr < ip+len; ++ptr) {
        if(*ptr == '.') {
            ret <<= 8;
            ret += comp_value;
            comp_value = 0;
        } else
            comp_value = comp_value*10 + (*ptr-'0');
    }
 
    ret <<= 8;
    ret += comp_value;
 
    return ret;
}

Referenced by ipv6_to_number().

ipv6_to_number()

static BOOL ipv6_to_number ( const ipv6_address *  address, USHORT  number[8]  )

static

Definition at line 888 of file uri.c.

                                                                          {
    DWORD i, cur_component = 0;
    BOOL already_passed_elision = FALSE;
 
    for(i = 0; i < address->h16_count; ++i) {
        if(address->elision) {
            if(address->components[i].str > address->elision && !already_passed_elision) {
                /* Means we just passed the elision and need to add its values to
                 * 'number' before we do anything else.
                 */
                INT j;
                for(j = 0; j < address->elision_size; j+=2)
                    number[cur_component++] = 0;
 
                already_passed_elision = TRUE;
            }
        }
 
        number[cur_component++] = h16tous(address->components[i]);
    }
 
    /* Case when the elision appears after the h16 components. */
    if(!already_passed_elision && address->elision) {
        INT j;
        for(j = 0; j < address->elision_size; j+=2)
            number[cur_component++] = 0;
    }
 
    if(address->ipv4) {
        UINT value = ipv4toui(address->ipv4, address->ipv4_len);
 
        if(cur_component != 6) {
            ERR("(%p %p): Failed sanity check with %d\n", address, number, cur_component);
            return FALSE;
        }
 
        number[cur_component++] = (value >> 16) & 0xffff;
        number[cur_component] = value & 0xffff;
    }
 
    return TRUE;
}

Referenced by canonicalize_ipv6address().

is_alpha()

static BOOL is_alpha ( WCHAR  val )

inlinestatic

Definition at line 263 of file uri.c.

                                       {
    return ((val >= 'a' && val <= 'z') || (val >= 'A' && val <= 'Z'));
}

is_ascii()

static BOOL is_ascii ( WCHAR  c )

inlinestatic

Definition at line 361 of file uri.c.

{
    return c < 0x80;
}

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()

static