diff -r 000000000000 -r 6474c204b198 netwerk/base/src/nsURLHelper.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/netwerk/base/src/nsURLHelper.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,230 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef nsURLHelper_h__ +#define nsURLHelper_h__ + +#include "nsString.h" + +class nsIFile; +class nsIURLParser; + +enum netCoalesceFlags +{ + NET_COALESCE_NORMAL = 0, + + /** + * retains /../ that reach above dir root (useful for FTP + * servers in which the root of the FTP URL is not necessarily + * the root of the FTP filesystem). + */ + NET_COALESCE_ALLOW_RELATIVE_ROOT = 1<<0, + + /** + * recognizes /%2F and // as markers for the root directory + * and handles them properly. + */ + NET_COALESCE_DOUBLE_SLASH_IS_ROOT = 1<<1 +}; + +//---------------------------------------------------------------------------- +// This module contains some private helper functions related to URL parsing. +//---------------------------------------------------------------------------- + +/* shutdown frees URL parser */ +NS_HIDDEN_(void) net_ShutdownURLHelper(); +#ifdef XP_MACOSX +NS_HIDDEN_(void) net_ShutdownURLHelperOSX(); +#endif + +/* access URL parsers */ +NS_HIDDEN_(nsIURLParser *) net_GetAuthURLParser(); +NS_HIDDEN_(nsIURLParser *) net_GetNoAuthURLParser(); +NS_HIDDEN_(nsIURLParser *) net_GetStdURLParser(); + +/* convert between nsIFile and file:// URL spec + * net_GetURLSpecFromFile does an extra stat, so callers should + * avoid it if possible in favor of net_GetURLSpecFromActualFile + * and net_GetURLSpecFromDir */ +NS_HIDDEN_(nsresult) net_GetURLSpecFromFile(nsIFile *, nsACString &); +NS_HIDDEN_(nsresult) net_GetURLSpecFromDir(nsIFile *, nsACString &); +NS_HIDDEN_(nsresult) net_GetURLSpecFromActualFile(nsIFile *, nsACString &); +NS_HIDDEN_(nsresult) net_GetFileFromURLSpec(const nsACString &, nsIFile **); + +/* extract file path components from file:// URL */ +NS_HIDDEN_(nsresult) net_ParseFileURL(const nsACString &inURL, + nsACString &outDirectory, + nsACString &outFileBaseName, + nsACString &outFileExtension); + +/* handle .. in dirs while resolving URLs (path is UTF-8) */ +NS_HIDDEN_(void) net_CoalesceDirs(netCoalesceFlags flags, char* path); + +/** + * Resolves a relative path string containing "." and ".." + * with respect to a base path (assumed to already be resolved). + * For example, resolving "../../foo/./bar/../baz.html" w.r.t. + * "/a/b/c/d/e/" yields "/a/b/c/foo/baz.html". Attempting to + * ascend above the base results in the NS_ERROR_MALFORMED_URI + * exception. If basePath is null, it treats it as "/". + * + * @param relativePath a relative URI + * @param basePath a base URI + * + * @return a new string, representing canonical uri + */ +NS_HIDDEN_(nsresult) net_ResolveRelativePath(const nsACString &relativePath, + const nsACString &basePath, + nsACString &result); + +/** + * Extract URI-Scheme if possible + * + * @param inURI URI spec + * @param startPos start of scheme (may be null) + * @param endPos end of scheme; index of colon (may be null) + * @param scheme scheme copied to this buffer on return (may be null) + */ +NS_HIDDEN_(nsresult) net_ExtractURLScheme(const nsACString &inURI, + uint32_t *startPos, + uint32_t *endPos, + nsACString *scheme = nullptr); + +/* check that the given scheme conforms to RFC 2396 */ +NS_HIDDEN_(bool) net_IsValidScheme(const char *scheme, uint32_t schemeLen); + +inline bool net_IsValidScheme(const nsAFlatCString &scheme) +{ + return net_IsValidScheme(scheme.get(), scheme.Length()); +} + +/** + * Filter out whitespace from a URI string. The input is the |str| + * pointer. |result| is written to if and only if there is whitespace that has + * to be filtered out. The return value is true if and only if |result| is + * written to. + * + * This function strips out all whitespace at the beginning and end of the URL + * and strips out \r, \n, \t from the middle of the URL. This makes it safe to + * call on things like javascript: urls or data: urls, where we may in fact run + * into whitespace that is not properly encoded. Note that stripping does not + * occur in the scheme portion itself. + * + * @param str the pointer to the string to filter. Must be non-null. + * @param result the out param to write to if filtering happens + * @return whether result was written to + */ +NS_HIDDEN_(bool) net_FilterURIString(const char *str, nsACString& result); + +#if defined(XP_WIN) +/** + * On Win32 and OS/2 system's a back-slash in a file:// URL is equivalent to a + * forward-slash. This function maps any back-slashes to forward-slashes. + * + * @param aURL + * The URL string to normalize (UTF-8 encoded). This can be a + * relative URL segment. + * @param aResultBuf + * The resulting string is appended to this string. If the input URL + * is already normalized, then aResultBuf is unchanged. + * + * @returns false if aURL is already normalized. Otherwise, returns true. + */ +NS_HIDDEN_(bool) net_NormalizeFileURL(const nsACString &aURL, + nsCString &aResultBuf); +#endif + +/***************************************************************************** + * generic string routines follow (XXX move to someplace more generic). + */ + +/* convert to lower case */ +NS_HIDDEN_(void) net_ToLowerCase(char* str, uint32_t length); +NS_HIDDEN_(void) net_ToLowerCase(char* str); + +/** + * returns pointer to first character of |str| in the given set. if not found, + * then |end| is returned. stops prematurely if a null byte is encountered, + * and returns the address of the null byte. + */ +NS_HIDDEN_(char *) net_FindCharInSet(const char *str, const char *end, const char *set); + +/** + * returns pointer to first character of |str| NOT in the given set. if all + * characters are in the given set, then |end| is returned. if '\0' is not + * included in |set|, then stops prematurely if a null byte is encountered, + * and returns the address of the null byte. + */ +NS_HIDDEN_(char *) net_FindCharNotInSet(const char *str, const char *end, const char *set); + +/** + * returns pointer to last character of |str| NOT in the given set. if all + * characters are in the given set, then |str - 1| is returned. + */ +NS_HIDDEN_(char *) net_RFindCharNotInSet(const char *str, const char *end, const char *set); + +/** + * Parses a content-type header and returns the content type and + * charset (if any). aCharset is not modified if no charset is + * specified in anywhere in aHeaderStr. In that case (no charset + * specified), aHadCharset is set to false. Otherwise, it's set to + * true. Note that aContentCharset can be empty even if aHadCharset + * is true. + */ +NS_HIDDEN_(void) net_ParseContentType(const nsACString &aHeaderStr, + nsACString &aContentType, + nsACString &aContentCharset, + bool* aHadCharset); +/** + * As above, but also returns the start and end indexes for the charset + * parameter in aHeaderStr. These are indices for the entire parameter, NOT + * just the value. If there is "effectively" no charset parameter (e.g. if an + * earlier type with one is overridden by a later type without one), + * *aHadCharset will be true but *aCharsetStart will be set to -1. Note that + * it's possible to have aContentCharset empty and *aHadCharset true when + * *aCharsetStart is nonnegative; this corresponds to charset="". + */ +NS_HIDDEN_(void) net_ParseContentType(const nsACString &aHeaderStr, + nsACString &aContentType, + nsACString &aContentCharset, + bool *aHadCharset, + int32_t *aCharsetStart, + int32_t *aCharsetEnd); + +/* inline versions */ + +/* remember the 64-bit platforms ;-) */ +#define NET_MAX_ADDRESS (((char*)0)-1) + +inline char *net_FindCharInSet(const char *str, const char *set) +{ + return net_FindCharInSet(str, NET_MAX_ADDRESS, set); +} +inline char *net_FindCharNotInSet(const char *str, const char *set) +{ + return net_FindCharNotInSet(str, NET_MAX_ADDRESS, set); +} +inline char *net_RFindCharNotInSet(const char *str, const char *set) +{ + return net_RFindCharNotInSet(str, str + strlen(str), set); +} + +/** + * This function returns true if the given hostname does not include any + * restricted characters. Otherwise, false is returned. + */ +NS_HIDDEN_(bool) net_IsValidHostName(const nsCSubstring &host); + +/** + * Checks whether the IPv4 address is valid according to RFC 3986 section 3.2.2. + */ +NS_HIDDEN_(bool) net_IsValidIPv4Addr(const char *addr, int32_t addrLen); + +/** + * Checks whether the IPv6 address is valid according to RFC 3986 section 3.2.2. + */ +NS_HIDDEN_(bool) net_IsValidIPv6Addr(const char *addr, int32_t addrLen); + +#endif // !nsURLHelper_h__