| /* CFURL.inc.h |
| Copyright (c) 2012-2016, Apple Inc. and the Swift project authors |
| |
| Portions Copyright (c) 2014-2016 Apple Inc. and the Swift project authors |
| Licensed under Apache License v2.0 with Runtime Library Exception |
| See http://swift.org/LICENSE.txt for license information |
| See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| Responsibility: Jim Luther/Chris Linn |
| */ |
| |
| |
| /* |
| |
| What's this file for? |
| |
| CFURL's URL string parser needs to be able to parse either an array of char or an array of UniChar. |
| |
| The code in CFURL.c used to use this macro "#define STRING_CHAR(x) (useCString ? cstring[(x)] : ustring[(x)])" to determine which array to get a character from for every character looked at in the URL string. That macro added one or more compare and branch instructins to the parser's execution for *every* character in the URL string. Those extra compares and branches added up to 10% of the time (for long URL strings) it takes to create a URL object. |
| |
| To ensure the exact same parser code is run over a char or a UniChar string, the source code was move to this .h file and is included multiple times by CFURL.c as needed. "STRING_CHAR(x)" was replaced by "characterArray[x]", and characterArray is defined as either an "const char *" or a "const UniChar *" for the two sets of function headers that are either parsing an array of char or an array of UniChar. |
| |
| Any changes made to the parser are made in this file so that both char and the UniChar strings are parsed exactly the same way. |
| |
| */ |
| |
| /* |
| static void _parseComponentsCString(CFAllocatorRef alloc, CFURLRef baseURL, CFIndex cfStringLength, const char *characterArray, UInt32 *theFlags, CFRange *packedRanges, uint8_t *numberOfRanges) |
| or |
| static void _parseComponentsUString(CFAllocatorRef alloc, CFURLRef baseURL, CFIndex cfStringLength, const UniChar *characterArray, UInt32 *theFlags, CFRange *packedRanges, uint8_t *numberOfRanges) |
| */ |
| #ifdef CFURL_INCLUDE_PARSE_COMPONENTS // defined when we want this block of code included |
| { |
| /* index gives the URL part involved; to calculate the correct range index, use the number of the bit of the equivalent flag (i.e. the host flag is HAS_HOST, which is 0x8. so the range index for the host is 3.) Note that this is true in this function ONLY, since the ranges stored in (*range) are actually packed, skipping those URL components that don't exist. This is why the indices are hard-coded in this function. */ |
| enum { |
| scheme_index = 0, |
| user_index = 1, |
| password_index = 2, |
| host_index = 3, |
| port_index = 4, |
| path_index = 5, |
| parameters_index = 6, |
| query_index = 7, |
| fragment_index = 8, |
| }; |
| CFRange unpackedRanges[MAX_COMPONENTS] = {{0}}; |
| |
| CFIndex idx, base_idx = 0; |
| CFIndex string_length; |
| UInt32 flags = *theFlags; |
| Boolean isCompliant; |
| uint8_t numRanges = 0; |
| |
| string_length = cfStringLength; |
| |
| // Algorithm is as described in RFC 1808 |
| // 1: parse the fragment; remainder after left-most "#" is fragment |
| for (idx = base_idx; idx < string_length; idx++) { |
| if ('#' == characterArray[idx]) { |
| flags |= HAS_FRAGMENT; |
| unpackedRanges[fragment_index].location = idx + 1; |
| unpackedRanges[fragment_index].length = string_length - (idx + 1); |
| numRanges ++; |
| string_length = idx; // remove fragment from parse string |
| break; |
| } |
| } |
| // 2: parse the scheme |
| for (idx = base_idx; idx < string_length; idx++) { |
| UniChar ch = characterArray[idx]; |
| if (':' == ch) { |
| flags |= HAS_SCHEME; |
| unpackedRanges[scheme_index].location = base_idx; |
| unpackedRanges[scheme_index].length = idx; |
| numRanges ++; |
| base_idx = idx + 1; |
| // optimization for ftp urls |
| if (idx == 3 && characterArray[0] == 'f' && characterArray[1] == 't' && characterArray[2] == 'p') { |
| _setSchemeTypeInFlags(&flags, kHasFtpScheme); |
| } |
| else if (idx == 4) { |
| // optimization for http urls |
| if (characterArray[0] == 'h' && characterArray[1] == 't' && characterArray[2] == 't' && characterArray[3] == 'p') { |
| _setSchemeTypeInFlags(&flags, kHasHttpScheme); |
| } |
| // optimization for file urls |
| if (characterArray[0] == 'f' && characterArray[1] == 'i' && characterArray[2] == 'l' && characterArray[3] == 'e') { |
| _setSchemeTypeInFlags(&flags, kHasFileScheme); |
| } |
| // optimization for data urls |
| if (characterArray[0] == 'd' && characterArray[1] == 'a' && characterArray[2] == 't' && characterArray[3] == 'a') { |
| _setSchemeTypeInFlags(&flags, kHasDataScheme); |
| } |
| } |
| // optimization for https urls |
| else if (idx == 5 && characterArray[0] == 'h' && characterArray[1] == 't' && characterArray[2] == 't' && characterArray[3] == 'p' && characterArray[4] == 's') { |
| _setSchemeTypeInFlags(&flags, kHasHttpsScheme); |
| } |
| break; |
| } else if (!scheme_valid(ch)) { |
| break; // invalid scheme character -- no scheme |
| } |
| } |
| |
| // Make sure we have an RFC-1808 compliant URL - that's either something without a scheme, or scheme:/(stuff) or scheme://(stuff) |
| // Strictly speaking, RFC 1808 & 2396 bar "scheme:" (with nothing following the colon); however, common usage |
| // expects this to be treated identically to "scheme://" - REW, 12/08/03 |
| if (!(flags & HAS_SCHEME)) { |
| isCompliant = true; |
| } else if (base_idx == string_length) { |
| isCompliant = false; |
| } else if (characterArray[base_idx] != '/') { |
| isCompliant = false; |
| } else { |
| isCompliant = true; |
| } |
| |
| if (!isCompliant) { |
| // Clear the fragment flag if it's been set |
| if (flags & HAS_FRAGMENT) { |
| flags &= (~HAS_FRAGMENT); |
| string_length = cfStringLength; |
| } |
| (*theFlags) = flags; |
| packedRanges[scheme_index].location = unpackedRanges[scheme_index].location; |
| packedRanges[scheme_index].length = unpackedRanges[scheme_index].length; |
| *numberOfRanges = 1; |
| } |
| else { |
| // URL is 1808-compliant |
| flags |= IS_DECOMPOSABLE; |
| |
| // 3: parse the network location and login |
| if (2 <= (string_length - base_idx) && '/' == characterArray[base_idx] && '/' == characterArray[base_idx+1]) { |
| CFIndex base = 2 + base_idx, extent; |
| for (idx = base; idx < string_length; idx++) { |
| if ('/' == characterArray[idx] || '?' == characterArray[idx]) { |
| break; |
| } |
| } |
| extent = idx; |
| |
| // net_loc parts extend from base to extent (but not including), which might be to end of string |
| // net location is "<user>:<password>@<host>:<port>" |
| if (extent != base) { |
| for (idx = base; idx < extent; idx++) { |
| if ('@' == characterArray[idx]) { // there is a user |
| CFIndex idx2; |
| flags |= HAS_USER; |
| numRanges ++; |
| unpackedRanges[user_index].location = base; // base of the user |
| for (idx2 = base; idx2 < idx; idx2++) { |
| if (':' == characterArray[idx2]) { // found a password separator |
| flags |= HAS_PASSWORD; |
| numRanges ++; |
| unpackedRanges[password_index].location = idx2+1; // base of the password |
| unpackedRanges[password_index].length = idx-(idx2+1); // password extent |
| unpackedRanges[user_index].length = idx2 - base; // user extent |
| break; |
| } |
| } |
| if (!(flags & HAS_PASSWORD)) { |
| // user extends to the '@' |
| unpackedRanges[user_index].length = idx - base; // user extent |
| } |
| base = idx + 1; |
| break; |
| } |
| } |
| flags |= HAS_HOST; |
| numRanges ++; |
| unpackedRanges[host_index].location = base; // base of host |
| |
| // base has been advanced past the user and password if they existed |
| for (idx = base; idx < extent; idx++) { |
| // IPV6 support (RFC 2732) DCJ June/10/2002 |
| if ('[' == characterArray[idx]) { // starting IPV6 explicit address |
| // Find the ']' terminator of the IPv6 address, leave idx pointing to ']' or end |
| for ( ; idx < extent; ++ idx ) { |
| if ( ']' == characterArray[idx]) { |
| flags |= IS_IPV6_ENCODED; |
| break; |
| } |
| } |
| } |
| // there is a port if we see a colon. Only the last one is the port, though. |
| else if ( ':' == characterArray[idx]) { |
| flags |= HAS_PORT; |
| numRanges ++; |
| unpackedRanges[port_index].location = idx+1; // base of port |
| unpackedRanges[port_index].length = extent - (idx+1); // port extent |
| unpackedRanges[host_index].length = idx - base; // host extent |
| break; |
| } |
| } |
| if (!(flags & HAS_PORT)) { |
| unpackedRanges[host_index].length = extent - base; // host extent |
| } |
| } |
| base_idx = extent; |
| } |
| |
| // 4: parse the query; remainder after left-most "?" is query |
| for (idx = base_idx; idx < string_length; idx++) { |
| if ('?' == characterArray[idx]) { |
| flags |= HAS_QUERY; |
| numRanges ++; |
| unpackedRanges[query_index].location = idx + 1; |
| unpackedRanges[query_index].length = string_length - (idx+1); |
| string_length = idx; // remove query from parse string |
| break; |
| } |
| } |
| |
| // 5: parse the parameters; remainder after left-most ";" is parameters |
| for (idx = base_idx; idx < string_length; idx++) { |
| if (';' == characterArray[idx]) { |
| flags |= HAS_PARAMETERS; |
| numRanges ++; |
| unpackedRanges[parameters_index].location = idx + 1; |
| unpackedRanges[parameters_index].length = string_length - (idx+1); |
| string_length = idx; // remove parameters from parse string |
| break; |
| } |
| } |
| |
| // 6: parse the path; it's whatever's left between string_length & base_idx |
| if (string_length - base_idx != 0 || (flags & NET_LOCATION_MASK)) |
| { |
| // If we have a net location, we are 1808-compliant, and an empty path substring implies a path of "/" |
| UniChar ch; |
| Boolean isDir; |
| CFRange pathRg; |
| flags |= HAS_PATH; |
| numRanges ++; |
| pathRg.location = base_idx; |
| pathRg.length = string_length - base_idx; |
| unpackedRanges[path_index] = pathRg; |
| |
| if (pathRg.length > 0) { |
| Boolean sawPercent = FALSE; |
| for (idx = pathRg.location; idx < string_length; idx++) { |
| if ('%' == characterArray[idx]) { |
| sawPercent = TRUE; |
| break; |
| } |
| } |
| #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI |
| if (pathRg.length > 6 && characterArray[pathRg.location] == '/' && characterArray[pathRg.location + 1] == '.' && characterArray[pathRg.location + 2] == 'f' && characterArray[pathRg.location + 3] == 'i' && characterArray[pathRg.location + 4] == 'l' && characterArray[pathRg.location + 5] == 'e' && characterArray[pathRg.location + 6] == '/') { |
| flags |= PATH_HAS_FILE_ID; |
| } else if (!sawPercent) { |
| flags |= POSIX_AND_URL_PATHS_MATCH; |
| } |
| #elif DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_WINDOWS |
| if (!sawPercent) { |
| flags |= POSIX_AND_URL_PATHS_MATCH; |
| } |
| #endif |
| |
| ch = characterArray[pathRg.location + pathRg.length - 1]; |
| if (ch == '/') { |
| isDir = true; |
| } else if (ch == '.') { |
| if (pathRg.length == 1) { |
| isDir = true; |
| } else { |
| ch = characterArray[pathRg.location + pathRg.length - 2]; |
| if (ch == '/') { |
| isDir = true; |
| } else if (ch != '.') { |
| isDir = false; |
| } else if (pathRg.length == 2) { |
| isDir = true; |
| } else { |
| isDir = (characterArray[pathRg.location + pathRg.length - 3] == '/'); |
| } |
| } |
| } else { |
| isDir = false; |
| } |
| } else { |
| isDir = (baseURL != NULL) ? CFURLHasDirectoryPath(baseURL) : false; |
| } |
| if (isDir) { |
| flags |= IS_DIRECTORY; |
| } |
| } |
| |
| (*theFlags) = flags; |
| *numberOfRanges = numRanges; |
| numRanges = 0; |
| for (idx = 0, flags = 1; flags != (1<<9); flags = (flags<<1), idx ++) { |
| if ((*theFlags) & flags) { |
| packedRanges[numRanges] = unpackedRanges[idx]; |
| numRanges ++; |
| } |
| } |
| } |
| } |
| #endif // CFURL_INCLUDE_PARSE_COMPONENTS |
| |
| /* |
| static Boolean scanCharactersCString(CFAllocatorRef alloc, CFMutableStringRef *escapedString, UInt32 *flags, const char *characterArray, Boolean useCString, CFIndex base, CFIndex end, CFIndex *mark, UInt32 componentFlag, CFStringEncoding encoding) |
| static Boolean scanCharactersUString(CFAllocatorRef alloc, CFMutableStringRef *escapedString, UInt32 *flags, const UniChar *characterArray, Boolean useCString, CFIndex base, CFIndex end, CFIndex *mark, UInt32 componentFlag, CFStringEncoding encoding) |
| */ |
| #ifdef CFURL_INCLUDE_SCAN_CHARACTERS // defined when we want this block of code included |
| { |
| CFIndex idx; |
| Boolean sawIllegalChar = false; |
| for (idx = base; idx < end; idx ++) { |
| Boolean shouldEscape; |
| UniChar ch = characterArray[idx]; |
| if (isURLLegalCharacter(ch)) { |
| if ((componentFlag == HAS_USER || componentFlag == HAS_PASSWORD) && (ch == '/' || ch == '?' || ch == '@')) { |
| shouldEscape = true; |
| } else { |
| shouldEscape = false; |
| } |
| } else if (ch == '%' && idx + 2 < end && isHexDigit(characterArray[idx + 1]) && isHexDigit(characterArray[idx+2])) { |
| shouldEscape = false; |
| } else if (componentFlag == HAS_HOST && ((idx == base && ch == '[') || (idx == end-1 && ch == ']'))) { |
| shouldEscape = false; |
| } else { |
| shouldEscape = true; |
| } |
| if (shouldEscape) { |
| sawIllegalChar = true; |
| if (componentFlag && flags) { |
| *flags |= componentFlag; |
| } |
| if (!*escapedString) { |
| *escapedString = CFStringCreateMutable(alloc, 0); |
| } |
| if (useCString) { |
| CFStringRef tempString = CFStringCreateWithBytes(alloc, (uint8_t *)&(characterArray[*mark]), idx - *mark, kCFStringEncodingISOLatin1, false); |
| CFStringAppend(*escapedString, tempString); |
| CFRelease(tempString); |
| } else { |
| CFStringAppendCharacters(*escapedString, (const UniChar *)&(characterArray[*mark]), idx - *mark); |
| } |
| // try as a single UniChar first |
| if ( _appendPercentEscapesForCharacter(&ch, false, encoding, *escapedString) ) { |
| *mark = idx + 1; |
| } |
| // if that failed, the encoding is UTF8 and this is a surrogate pair, then percent-encode the surrogate pair |
| else if ( (encoding == kCFStringEncodingUTF8) && ((idx + 1) < end) && CFCharacterSetIsSurrogateHighCharacter(ch) && CFCharacterSetIsSurrogateLowCharacter(characterArray[idx + 1]) ) { |
| // percent-encode the surrogate pair |
| UniChar surrogatePair[2]; |
| surrogatePair[0] = ch; |
| surrogatePair[1] = characterArray[idx + 1]; |
| if ( _appendPercentEscapesForCharacter(surrogatePair, true, encoding, *escapedString) ) { |
| // we consumed 2 chararacters instead of 1 |
| *mark = idx + 2; |
| ++idx; |
| } |
| } |
| } |
| } |
| return sawIllegalChar; |
| } |
| #endif // CFURL_INCLUDE_SCAN_CHARACTERS |
