/*
* Copyright (C) 2005, 2007, 2008, 2009 Apple Inc. All rights reserved.
* Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#import "WebNSURLExtras.h"
#import "WebKitNSStringExtras.h"
#import "WebLocalizableStrings.h"
#import "WebNSDataExtras.h"
#import "WebNSObjectExtras.h"
#import "WebSystemInterface.h"
#import <Foundation/NSURLRequest.h>
#import <WebCore/KURL.h>
#import <WebCore/LoaderNSURLExtras.h>
#import <WebKitSystemInterface.h>
#import <wtf/Assertions.h>
#import <unicode/uchar.h>
#import <unicode/uidna.h>
#import <unicode/uscript.h>
using namespace WebCore;
using namespace WTF;
typedef void (* StringRangeApplierFunction)(NSString *string, NSRange range, void *context);
// Needs to be big enough to hold an IDN-encoded name.
// For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
#define HOST_NAME_BUFFER_LENGTH 2048
#define URL_BYTES_BUFFER_LENGTH 2048
static pthread_once_t IDNScriptWhiteListFileRead = PTHREAD_ONCE_INIT;
static uint32_t IDNScriptWhiteList[(USCRIPT_CODE_LIMIT + 31) / 32];
static inline BOOL isLookalikeCharacter(int charCode)
{
// FIXME: Move this code down into WebCore so it can be shared with other platforms.
// This function treats the following as unsafe, lookalike characters:
// any non-printable character, any character considered as whitespace that isn't already converted to a space by ICU,
// and any ignorable character.
// We also considered the characters in Mozilla's blacklist (http://kb.mozillazine.org/Network.IDN.blacklist_chars),
// and included all of these characters that ICU can encode.
if (!u_isprint(charCode) || u_isUWhiteSpace(charCode) || u_hasBinaryProperty(charCode, UCHAR_DEFAULT_IGNORABLE_CODE_POINT))
return YES;
switch (charCode) {
case 0x00ED: /* LATIN SMALL LETTER I WITH ACUTE */
case 0x01C3: /* LATIN LETTER RETROFLEX CLICK */
case 0x0251: /* LATIN SMALL LETTER ALPHA */
case 0x0261: /* LATIN SMALL LETTER SCRIPT G */
case 0x0337: /* COMBINING SHORT SOLIDUS OVERLAY */
case 0x0338: /* COMBINING LONG SOLIDUS OVERLAY */
case 0x05B4: /* HEBREW POINT HIRIQ */
case 0x05BC: /* HEBREW POINT DAGESH OR MAPIQ */
case 0x05C3: /* HEBREW PUNCTUATION SOF PASUQ */
case 0x05F4: /* HEBREW PUNCTUATION GERSHAYIM */
case 0x0660: /* ARABIC INDIC DIGIT ZERO */
case 0x06D4: /* ARABIC FULL STOP */
case 0x06F0: /* EXTENDED ARABIC INDIC DIGIT ZERO */
case 0x2027: /* HYPHENATION POINT */
case 0x2039: /* SINGLE LEFT-POINTING ANGLE QUOTATION MARK */
case 0x203A: /* SINGLE RIGHT-POINTING ANGLE QUOTATION MARK */
case 0x2044: /* FRACTION SLASH */
case 0x2215: /* DIVISION SLASH */
case 0x2216: /* SET MINUS */
case 0x233F: /* APL FUNCTIONAL SYMBOL SLASH BAR */
case 0x23AE: /* INTEGRAL EXTENSION */
case 0x244A: /* OCR DOUBLE BACKSLASH */
case 0x2571: /* BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT */
case 0x2572: /* BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT */
case 0x29F8: /* BIG SOLIDUS */
case 0x29f6: /* SOLIDUS WITH OVERBAR */
case 0x2AFB: /* TRIPLE SOLIDUS BINARY RELATION */
case 0x2AFD: /* DOUBLE SOLIDUS OPERATOR */
case 0x3008: /* LEFT ANGLE BRACKET */
case 0x3014: /* LEFT TORTOISE SHELL BRACKET */
case 0x3015: /* RIGHT TORTOISE SHELL BRACKET */
case 0x3033: /* VERTICAL KANA REPEAT MARK UPPER HALF */
case 0x3035: /* VERTICAL KANA REPEAT MARK LOWER HALF */
case 0x321D: /* PARENTHESIZED KOREAN CHARACTER OJEON */
case 0x321E: /* PARENTHESIZED KOREAN CHARACTER O HU */
case 0x33DF: /* SQUARE A OVER M */
case 0xFE14: /* PRESENTATION FORM FOR VERTICAL SEMICOLON */
case 0xFE15: /* PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK */
case 0xFE3F: /* PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET */
case 0xFE5D: /* SMALL LEFT TORTOISE SHELL BRACKET */
case 0xFE5E: /* SMALL RIGHT TORTOISE SHELL BRACKET */
return YES;
default:
return NO;
}
}
static char hexDigit(int i)
{
if (i < 0 || i > 16) {
LOG_ERROR("illegal hex digit");
return '0';
}
int h = i;
if (h >= 10) {
h = h - 10 + 'A';
}
else {
h += '0';
}
return h;
}
static BOOL isHexDigit(char c)
{
return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
}
static int hexDigitValue(char c)
{
if (c >= '0' && c <= '9') {
return c - '0';
}
if (c >= 'A' && c <= 'F') {
return c - 'A' + 10;
}
if (c >= 'a' && c <= 'f') {
return c - 'a' + 10;
}
LOG_ERROR("illegal hex digit");
return 0;
}
static void applyHostNameFunctionToMailToURLString(NSString *string, StringRangeApplierFunction f, void *context)
{
// In a mailto: URL, host names come after a '@' character and end with a '>' or ',' or '?' character.
// Skip quoted strings so that characters in them don't confuse us.
// When we find a '?' character, we are past the part of the URL that contains host names.
static NSCharacterSet *hostNameOrStringStartCharacters;
if (hostNameOrStringStartCharacters == nil) {
hostNameOrStringStartCharacters = [NSCharacterSet characterSetWithCharactersInString:@"\"@?"];
CFRetain(hostNameOrStringStartCharacters);
}
static NSCharacterSet *hostNameEndCharacters;
if (hostNameEndCharacters == nil) {
hostNameEndCharacters = [NSCharacterSet characterSetWithCharactersInString:@">,?"];
CFRetain(hostNameEndCharacters);
}
static NSCharacterSet *quotedStringCharacters;
if (quotedStringCharacters == nil) {
quotedStringCharacters = [NSCharacterSet characterSetWithCharactersInString:@"\"\\"];
CFRetain(quotedStringCharacters);
}
unsigned stringLength = [string length];
NSRange remaining = NSMakeRange(0, stringLength);
while (1) {
// Find start of host name or of quoted string.
NSRange hostNameOrStringStart = [string rangeOfCharacterFromSet:hostNameOrStringStartCharacters options:0 range:remaining];
if (hostNameOrStringStart.location == NSNotFound) {
return;
}
unichar c = [string characterAtIndex:hostNameOrStringStart.location];
remaining.location = NSMaxRange(hostNameOrStringStart);
remaining.length = stringLength - remaining.location;
if (c == '?') {
return;
}
if (c == '@') {
// Find end of host name.
unsigned hostNameStart = remaining.location;
NSRange hostNameEnd = [string rangeOfCharacterFromSet:hostNameEndCharacters options:0 range:remaining];
BOOL done;
if (hostNameEnd.location == NSNotFound) {
hostNameEnd.location = stringLength;
done = YES;
} else {
remaining.location = hostNameEnd.location;
remaining.length = stringLength - remaining.location;
done = NO;
}
// Process host name range.
f(string, NSMakeRange(hostNameStart, hostNameEnd.location - hostNameStart), context);
if (done) {
return;
}
} else {
// Skip quoted string.
ASSERT(c == '"');
while (1) {
NSRange escapedCharacterOrStringEnd = [string rangeOfCharacterFromSet:quotedStringCharacters options:0 range:remaining];
if (escapedCharacterOrStringEnd.location == NSNotFound) {
return;
}
c = [string characterAtIndex:escapedCharacterOrStringEnd.location];
remaining.location = NSMaxRange(escapedCharacterOrStringEnd);
remaining.length = stringLength - remaining.location;
// If we are the end of the string, then break from the string loop back to the host name loop.
if (c == '"') {
break;
}
// Skip escaped character.
ASSERT(c == '\\');
if (remaining.length == 0) {
return;
}
remaining.location += 1;
remaining.length -= 1;
}
}
}
}
static void applyHostNameFunctionToURLString(NSString *string, StringRangeApplierFunction f, void *context)
{
// Find hostnames. Too bad we can't use any real URL-parsing code to do this,
// but we have to do it before doing all the %-escaping, and this is the only
// code we have that parses mailto URLs anyway.
// Maybe we should implement this using a character buffer instead?
if ([string _webkit_hasCaseInsensitivePrefix:@"mailto:"]) {
applyHostNameFunctionToMailToURLString(string, f, context);
return;
}
// Find the host name in a hierarchical URL.
// It comes after a "://" sequence, with scheme characters preceding.
// If ends with the end of the string or a ":", "/", or a "?".
// If there is a "@" character, the host part is just the part after the "@".
NSRange separatorRange = [string rangeOfString:@"://"];
if (separatorRange.location == NSNotFound) {
return;
}
// Check that all characters before the :// are valid scheme characters.
static NSCharacterSet *nonSchemeCharacters;
if (nonSchemeCharacters == nil) {
nonSchemeCharacters = [[NSCharacterSet characterSetWithCharactersInString:@"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-."] invertedSet];
CFRetain(nonSchemeCharacters);
}
if ([string rangeOfCharacterFromSet:nonSchemeCharacters options:0 range:NSMakeRange(0, separatorRange.location)].location != NSNotFound) {
return;
}
unsigned stringLength = [string length];
static NSCharacterSet *hostTerminators;
if (hostTerminators == nil) {
hostTerminators = [NSCharacterSet characterSetWithCharactersInString:@":/?#"];
CFRetain(hostTerminators);
}
// Start after the separator.
unsigned authorityStart = NSMaxRange(separatorRange);
// Find terminating character.
NSRange hostNameTerminator = [string rangeOfCharacterFromSet:hostTerminators options:0 range:NSMakeRange(authorityStart, stringLength - authorityStart)];
unsigned hostNameEnd = hostNameTerminator.location == NSNotFound ? stringLength : hostNameTerminator.location;
// Find "@" for the start of the host name.
NSRange userInfoTerminator = [string rangeOfString:@"@" options:0 range:NSMakeRange(authorityStart, hostNameEnd - authorityStart)];
unsigned hostNameStart = userInfoTerminator.location == NSNotFound ? authorityStart : NSMaxRange(userInfoTerminator);
f(string, NSMakeRange(hostNameStart, hostNameEnd - hostNameStart), context);
}
@implementation NSURL (WebNSURLExtras)
static void collectRangesThatNeedMapping(NSString *string, NSRange range, void *context, BOOL encode)
{
BOOL needsMapping = encode
? [string _web_hostNameNeedsEncodingWithRange:range]
: [string _web_hostNameNeedsDecodingWithRange:range];
if (!needsMapping) {
return;
}
NSMutableArray **array = (NSMutableArray **)context;
if (*array == nil) {
*array = [[NSMutableArray alloc] init];
}
[*array addObject:[NSValue valueWithRange:range]];
}
static void collectRangesThatNeedEncoding(NSString *string, NSRange range, void *context)
{
return collectRangesThatNeedMapping(string, range, context, YES);
}
static void collectRangesThatNeedDecoding(NSString *string, NSRange range, void *context)
{
return collectRangesThatNeedMapping(string, range, context, NO);
}
static NSString *mapHostNames(NSString *string, BOOL encode)
{
// Generally, we want to optimize for the case where there is one host name that does not need mapping.
if (encode && [string canBeConvertedToEncoding:NSASCIIStringEncoding])
return string;
// Make a list of ranges that actually need mapping.
NSMutableArray *hostNameRanges = nil;
StringRangeApplierFunction f = encode
? collectRangesThatNeedEncoding
: collectRangesThatNeedDecoding;
applyHostNameFunctionToURLString(string, f, &hostNameRanges);
if (hostNameRanges == nil)
return string;
// Do the mapping.
NSMutableString *mutableCopy = [string mutableCopy];
unsigned i = [hostNameRanges count];
while (i-- != 0) {
NSRange hostNameRange = [[hostNameRanges objectAtIndex:i] rangeValue];
NSString *mappedHostName = encode
? [string _web_encodeHostNameWithRange:hostNameRange]
: [string _web_decodeHostNameWithRange:hostNameRange];
[mutableCopy replaceCharactersInRange:hostNameRange withString:mappedHostName];
}
[hostNameRanges release];
return [mutableCopy autorelease];
}
+ (NSURL *)_web_URLWithUserTypedString:(NSString *)string relativeToURL:(NSURL *)URL
{
if (string == nil) {
return nil;
}
string = mapHostNames([string _webkit_stringByTrimmingWhitespace], YES);
NSData *userTypedData = [string dataUsingEncoding:NSUTF8StringEncoding];
ASSERT(userTypedData);
const UInt8 *inBytes = static_cast<const UInt8 *>([userTypedData bytes]);
int inLength = [userTypedData length];
if (inLength == 0) {
return [NSURL URLWithString:@""];
}
char *outBytes = static_cast<char *>(malloc(inLength * 3)); // large enough to %-escape every character
char *p = outBytes;
int outLength = 0;
int i;
for (i = 0; i < inLength; i++) {
UInt8 c = inBytes[i];
if (c <= 0x20 || c >= 0x7f) {
*p++ = '%';
*p++ = hexDigit(c >> 4);
*p++ = hexDigit(c & 0xf);
outLength += 3;
}
else {
*p++ = c;
outLength++;
}
}
NSData *data = [NSData dataWithBytesNoCopy:outBytes length:outLength]; // adopts outBytes
return [self _web_URLWithData:data relativeToURL:URL];
}
+ (NSURL *)_web_URLWithUserTypedString:(NSString *)string
{
return [self _web_URLWithUserTypedString:string relativeToURL:nil];
}
+ (NSURL *)_web_URLWithDataAsString:(NSString *)string
{
if (string == nil) {
return nil;
}
return [self _web_URLWithDataAsString:string relativeToURL:nil];
}
+ (NSURL *)_web_URLWithDataAsString:(NSString *)string relativeToURL:(NSURL *)baseURL
{
if (string == nil) {
return nil;
}
string = [string _webkit_stringByTrimmingWhitespace];
NSData *data = [string dataUsingEncoding:NSISOLatin1StringEncoding];
return [self _web_URLWithData:data relativeToURL:baseURL];
}
+ (NSURL *)_web_URLWithData:(NSData *)data
{
return [NSURL _web_URLWithData:data relativeToURL:nil];
}
+ (NSURL *)_web_URLWithData:(NSData *)data relativeToURL:(NSURL *)baseURL
{
if (data == nil)
return nil;
NSURL *result = nil;
size_t length = [data length];
if (length > 0) {
// work around <rdar://4470771>: CFURLCreateAbsoluteURLWithBytes(.., TRUE) doesn't remove non-path components.
baseURL = [baseURL _webkit_URLByRemovingResourceSpecifier];
const UInt8 *bytes = static_cast<const UInt8*>([data bytes]);
// NOTE: We use UTF-8 here since this encoding is used when computing strings when returning URL components
// (e.g calls to NSURL -path). However, this function is not tolerant of illegal UTF-8 sequences, which
// could either be a malformed string or bytes in a different encoding, like shift-jis, so we fall back
// onto using ISO Latin 1 in those cases.
result = WebCFAutorelease(CFURLCreateAbsoluteURLWithBytes(NULL, bytes, length, kCFStringEncodingUTF8, (CFURLRef)baseURL, YES));
if (!result)
result = WebCFAutorelease(CFURLCreateAbsoluteURLWithBytes(NULL, bytes, length, kCFStringEncodingISOLatin1, (CFURLRef)baseURL, YES));
} else
result = [NSURL URLWithString:@""];
return result;
}
- (NSData *)_web_originalData
{
UInt8 *buffer = (UInt8 *)malloc(URL_BYTES_BUFFER_LENGTH);
CFIndex bytesFilled = CFURLGetBytes((CFURLRef)self, buffer, URL_BYTES_BUFFER_LENGTH);
if (bytesFilled == -1) {
CFIndex bytesToAllocate = CFURLGetBytes((CFURLRef)self, NULL, 0);
buffer = (UInt8 *)realloc(buffer, bytesToAllocate);
bytesFilled = CFURLGetBytes((CFURLRef)self, buffer, bytesToAllocate);
ASSERT(bytesFilled == bytesToAllocate);
}
// buffer is adopted by the NSData
NSData *data = [NSData dataWithBytesNoCopy:buffer length:bytesFilled freeWhenDone:YES];
NSURL *baseURL = (NSURL *)CFURLGetBaseURL((CFURLRef)self);
if (baseURL)
return [[NSURL _web_URLWithData:data relativeToURL:baseURL] _web_originalData];
return data;
}
- (NSString *)_web_originalDataAsString
{
return [[[NSString alloc] initWithData:[self _web_originalData] encoding:NSISOLatin1StringEncoding] autorelease];
}
static CFStringRef createStringWithEscapedUnsafeCharacters(CFStringRef string)
{
CFIndex length = CFStringGetLength(string);
Vector<UChar, 2048> sourceBuffer(length);
CFStringGetCharacters(string, CFRangeMake(0, length), sourceBuffer.data());
Vector<UChar, 2048> outBuffer;
CFIndex i = 0;
while (i < length) {
UChar32 c;
U16_NEXT(sourceBuffer, i, length, c)
if (isLookalikeCharacter(c)) {
uint8_t utf8Buffer[4];
CFIndex offset = 0;
UBool failure = false;
U8_APPEND(utf8Buffer, offset, 4, c, failure)
ASSERT(!failure);
for (CFIndex j = 0; j < offset; ++j) {
outBuffer.append('%');
outBuffer.append(hexDigit(utf8Buffer[j] >> 4));
outBuffer.append(hexDigit(utf8Buffer[j] & 0xf));
}
} else {
UChar utf16Buffer[2];
CFIndex offset = 0;
UBool failure = false;
U16_APPEND(utf16Buffer, offset, 2, c, failure)
ASSERT(!failure);
for (CFIndex j = 0; j < offset; ++j)
outBuffer.append(utf16Buffer[j]);
}
}
return CFStringCreateWithCharacters(NULL, outBuffer.data(), outBuffer.size());
}
- (NSString *)_web_userVisibleString
{
NSData *data = [self _web_originalData];
const unsigned char *before = static_cast<const unsigned char*>([data bytes]);
int length = [data length];
bool needsHostNameDecoding = false;
const unsigned char *p = before;
int bufferLength = (length * 3) + 1;
char *after = static_cast<char *>(malloc(bufferLength)); // large enough to %-escape every character
char *q = after;
int i;
for (i = 0; i < length; i++) {
unsigned char c = p[i];
// unescape escape sequences that indicate bytes greater than 0x7f
if (c == '%' && (i + 1 < length && isHexDigit(p[i + 1])) && i + 2 < length && isHexDigit(p[i + 2])) {
unsigned char u = (hexDigitValue(p[i + 1]) << 4) | hexDigitValue(p[i + 2]);
if (u > 0x7f) {
// unescape
*q++ = u;
} else {
// do not unescape
*q++ = p[i];
*q++ = p[i + 1];
*q++ = p[i + 2];
}
i += 2;
} else {
*q++ = c;
// Check for "xn--" in an efficient, non-case-sensitive, way.
if (c == '-' && i >= 3 && !needsHostNameDecoding && (q[-4] | 0x20) == 'x' && (q[-3] | 0x20) == 'n' && q[-2] == '-')
needsHostNameDecoding = true;
}
}
*q = '\0';
// Check string to see if it can be converted to display using UTF-8
NSString *result = [NSString stringWithUTF8String:after];
if (!result) {
// Could not convert to UTF-8.
// Convert characters greater than 0x7f to escape sequences.
// Shift current string to the end of the buffer
// then we will copy back bytes to the start of the buffer
// as we convert.
int afterlength = q - after;
char *p = after + bufferLength - afterlength - 1;
memmove(p, after, afterlength + 1); // copies trailing '\0'
char *q = after;
while (*p) {
unsigned char c = *p;
if (c > 0x7f) {
*q++ = '%';
*q++ = hexDigit(c >> 4);
*q++ = hexDigit(c & 0xf);
} else {
*q++ = *p;
}
p++;
}
*q = '\0';
result = [NSString stringWithUTF8String:after];
}
free(after);
result = mapHostNames(result, !needsHostNameDecoding);
result = [result precomposedStringWithCanonicalMapping];
return WebCFAutorelease(createStringWithEscapedUnsafeCharacters((CFStringRef)result));
}
- (BOOL)_web_isEmpty
{
if (!CFURLGetBaseURL((CFURLRef)self))
return CFURLGetBytes((CFURLRef)self, NULL, 0) == 0;
return [[self _web_originalData] length] == 0;
}
- (const char *)_web_URLCString
{
NSMutableData *data = [NSMutableData data];
[data appendData:[self _web_originalData]];
[data appendBytes:"\0" length:1];
return (const char *)[data bytes];
}
- (NSURL *)_webkit_canonicalize
{
NSURLRequest *request = [[NSURLRequest alloc] initWithURL:self];
Class concreteClass = WKNSURLProtocolClassForRequest(request);
if (!concreteClass) {
[request release];
return self;
}
// This applies NSURL's concept of canonicalization, but not KURL's concept. It would
// make sense to apply both, but when we tried that it caused a performance degradation
// (see 5315926). It might make sense to apply only the KURL concept and not the NSURL
// concept, but it's too risky to make that change for WebKit 3.0.
NSURLRequest *newRequest = [concreteClass canonicalRequestForRequest:request];
NSURL *newURL = [newRequest URL];
NSURL *result = [[newURL retain] autorelease];
[request release];
return result;
}
- (NSURL *)_web_URLByTruncatingOneCharacterBeforeComponent:(CFURLComponentType)component
{
CFRange fragRg = CFURLGetByteRangeForComponent((CFURLRef)self, component, NULL);
if (fragRg.location == kCFNotFound)
return self;
UInt8 *urlBytes, buffer[2048];
CFIndex numBytes = CFURLGetBytes((CFURLRef)self, buffer, 2048);
if (numBytes == -1) {
numBytes = CFURLGetBytes((CFURLRef)self, NULL, 0);
urlBytes = static_cast<UInt8*>(malloc(numBytes));
CFURLGetBytes((CFURLRef)self, urlBytes, numBytes);
} else
urlBytes = buffer;
NSURL *result = (NSURL *)CFMakeCollectable(CFURLCreateWithBytes(NULL, urlBytes, fragRg.location - 1, kCFStringEncodingUTF8, NULL));
if (!result)
result = (NSURL *)CFMakeCollectable(CFURLCreateWithBytes(NULL, urlBytes, fragRg.location - 1, kCFStringEncodingISOLatin1, NULL));
if (urlBytes != buffer) free(urlBytes);
return result ? [result autorelease] : self;
}
- (NSURL *)_webkit_URLByRemovingFragment
{
return [self _web_URLByTruncatingOneCharacterBeforeComponent:kCFURLComponentFragment];
}
- (NSURL *)_webkit_URLByRemovingResourceSpecifier
{
return [self _web_URLByTruncatingOneCharacterBeforeComponent:kCFURLComponentResourceSpecifier];
}
- (NSURL *)_web_URLByRemovingComponentAndSubsequentCharacter:(CFURLComponentType)component
{
CFRange range = CFURLGetByteRangeForComponent((CFURLRef)self, component, 0);
if (range.location == kCFNotFound)
return self;
// Remove one subsequent character.
++range.length;
UInt8* urlBytes;
UInt8 buffer[2048];
CFIndex numBytes = CFURLGetBytes((CFURLRef)self, buffer, 2048);
if (numBytes == -1) {
numBytes = CFURLGetBytes((CFURLRef)self, NULL, 0);
urlBytes = static_cast<UInt8*>(malloc(numBytes));
CFURLGetBytes((CFURLRef)self, urlBytes, numBytes);
} else
urlBytes = buffer;
if (numBytes < range.location)
return self;
if (numBytes < range.location + range.length)
range.length = numBytes - range.location;
memmove(urlBytes + range.location, urlBytes + range.location + range.length, numBytes - range.location + range.length);
NSURL *result = (NSURL *)CFMakeCollectable(CFURLCreateWithBytes(NULL, urlBytes, numBytes - range.length, kCFStringEncodingUTF8, NULL));
if (!result)
result = (NSURL *)CFMakeCollectable(CFURLCreateWithBytes(NULL, urlBytes, numBytes - range.length, kCFStringEncodingISOLatin1, NULL));
if (urlBytes != buffer)
free(urlBytes);
return result ? [result autorelease] : self;
}
- (NSURL *)_web_URLByRemovingUserInfo
{
return [self _web_URLByRemovingComponentAndSubsequentCharacter:kCFURLComponentUserInfo];
}
- (BOOL)_webkit_isJavaScriptURL
{
return [[self _web_originalDataAsString] _webkit_isJavaScriptURL];
}
- (NSString *)_webkit_scriptIfJavaScriptURL
{
return [[self absoluteString] _webkit_scriptIfJavaScriptURL];
}
- (BOOL)_webkit_isFileURL
{
return [[self _web_originalDataAsString] _webkit_isFileURL];
}
- (BOOL)_webkit_isFTPDirectoryURL
{
return [[self _web_originalDataAsString] _webkit_isFTPDirectoryURL];
}
- (BOOL)_webkit_shouldLoadAsEmptyDocument
{
return [[self _web_originalDataAsString] _webkit_hasCaseInsensitivePrefix:@"about:"] || [self _web_isEmpty];
}
- (NSURL *)_web_URLWithLowercasedScheme
{
CFRange range;
CFURLGetByteRangeForComponent((CFURLRef)self, kCFURLComponentScheme, &range);
if (range.location == kCFNotFound) {
return self;
}
UInt8 static_buffer[URL_BYTES_BUFFER_LENGTH];
UInt8 *buffer = static_buffer;
CFIndex bytesFilled = CFURLGetBytes((CFURLRef)self, buffer, URL_BYTES_BUFFER_LENGTH);
if (bytesFilled == -1) {
CFIndex bytesToAllocate = CFURLGetBytes((CFURLRef)self, NULL, 0);
buffer = static_cast<UInt8 *>(malloc(bytesToAllocate));
bytesFilled = CFURLGetBytes((CFURLRef)self, buffer, bytesToAllocate);
ASSERT(bytesFilled == bytesToAllocate);
}
int i;
BOOL changed = NO;
for (i = 0; i < range.length; ++i) {
char c = buffer[range.location + i];
char lower = toASCIILower(c);
if (c != lower) {
buffer[range.location + i] = lower;
changed = YES;
}
}
NSURL *result = changed
? (NSURL *)WebCFAutorelease(CFURLCreateAbsoluteURLWithBytes(NULL, buffer, bytesFilled, kCFStringEncodingUTF8, nil, YES))
: (NSURL *)self;
if (buffer != static_buffer) {
free(buffer);
}
return result;
}
-(BOOL)_web_hasQuestionMarkOnlyQueryString
{
CFRange rangeWithSeparators;
CFURLGetByteRangeForComponent((CFURLRef)self, kCFURLComponentQuery, &rangeWithSeparators);
if (rangeWithSeparators.location != kCFNotFound && rangeWithSeparators.length == 1) {
return YES;
}
return NO;
}
-(NSData *)_web_schemeSeparatorWithoutColon
{
NSData *result = nil;
CFRange rangeWithSeparators;
CFRange range = CFURLGetByteRangeForComponent((CFURLRef)self, kCFURLComponentScheme, &rangeWithSeparators);
if (rangeWithSeparators.location != kCFNotFound) {
NSString *absoluteString = [self absoluteString];
NSRange separatorsRange = NSMakeRange(range.location + range.length + 1, rangeWithSeparators.length - range.length - 1);
if (separatorsRange.location + separatorsRange.length <= [absoluteString length]) {
NSString *slashes = [absoluteString substringWithRange:separatorsRange];
result = [slashes dataUsingEncoding:NSISOLatin1StringEncoding];
}
}
return result;
}
#define completeURL (CFURLComponentType)-1
-(NSData *)_web_dataForURLComponentType:(CFURLComponentType)componentType
{
static int URLComponentTypeBufferLength = 2048;
UInt8 staticAllBytesBuffer[URLComponentTypeBufferLength];
UInt8 *allBytesBuffer = staticAllBytesBuffer;
CFIndex bytesFilled = CFURLGetBytes((CFURLRef)self, allBytesBuffer, URLComponentTypeBufferLength);
if (bytesFilled == -1) {
CFIndex bytesToAllocate = CFURLGetBytes((CFURLRef)self, NULL, 0);
allBytesBuffer = static_cast<UInt8 *>(malloc(bytesToAllocate));
bytesFilled = CFURLGetBytes((CFURLRef)self, allBytesBuffer, bytesToAllocate);
}
CFRange range;
if (componentType != completeURL) {
range = CFURLGetByteRangeForComponent((CFURLRef)self, componentType, NULL);
if (range.location == kCFNotFound) {
return nil;
}
}
else {
range.location = 0;
range.length = bytesFilled;
}
NSData *componentData = [NSData dataWithBytes:allBytesBuffer + range.location length:range.length];
const unsigned char *bytes = static_cast<const unsigned char *>([componentData bytes]);
NSMutableData *resultData = [NSMutableData data];
// NOTE: add leading '?' to query strings non-zero length query strings.
// NOTE: retain question-mark only query strings.
if (componentType == kCFURLComponentQuery) {
if (range.length > 0 || [self _web_hasQuestionMarkOnlyQueryString]) {
[resultData appendBytes:"?" length:1];
}
}
int i;
for (i = 0; i < range.length; i++) {
unsigned char c = bytes[i];
if (c <= 0x20 || c >= 0x7f) {
char escaped[3];
escaped[0] = '%';
escaped[1] = hexDigit(c >> 4);
escaped[2] = hexDigit(c & 0xf);
[resultData appendBytes:escaped length:3];
}
else {
char b[1];
b[0] = c;
[resultData appendBytes:b length:1];
}
}
if (staticAllBytesBuffer != allBytesBuffer) {
free(allBytesBuffer);
}
return resultData;
}
-(NSData *)_web_schemeData
{
return [self _web_dataForURLComponentType:kCFURLComponentScheme];
}
-(NSData *)_web_hostData
{
NSData *result = [self _web_dataForURLComponentType:kCFURLComponentHost];
NSData *scheme = [self _web_schemeData];
// Take off localhost for file
if ([scheme _web_isCaseInsensitiveEqualToCString:"file"]) {
return ([result _web_isCaseInsensitiveEqualToCString:"localhost"]) ? nil : result;
}
return result;
}
- (NSString *)_web_hostString
{
NSData *data = [self _web_hostData];
if (!data) {
data = [NSData data];
}
return [[[NSString alloc] initWithData:[self _web_hostData] encoding:NSUTF8StringEncoding] autorelease];
}
- (NSString *)_webkit_suggestedFilenameWithMIMEType:(NSString *)MIMEType
{
return suggestedFilenameWithMIMEType(self, MIMEType);
}
@end
@implementation NSString (WebNSURLExtras)
- (BOOL)_web_isUserVisibleURL
{
BOOL valid = YES;
// get buffer
char static_buffer[1024];
const char *p;
BOOL success = CFStringGetCString((CFStringRef)self, static_buffer, 1023, kCFStringEncodingUTF8);
if (success) {
p = static_buffer;
} else {
p = [self UTF8String];
}
int length = strlen(p);
// check for characters <= 0x20 or >=0x7f, %-escape sequences of %7f, and xn--, these
// are the things that will lead _web_userVisibleString to actually change things.
int i;
for (i = 0; i < length; i++) {
unsigned char c = p[i];
// escape control characters, space, and delete
if (c <= 0x20 || c == 0x7f) {
valid = NO;
break;
} else if (c == '%' && (i + 1 < length && isHexDigit(p[i + 1])) && i + 2 < length && isHexDigit(p[i + 2])) {
unsigned char u = (hexDigitValue(p[i + 1]) << 4) | hexDigitValue(p[i + 2]);
if (u > 0x7f) {
valid = NO;
break;
}
i += 2;
} else {
// Check for "xn--" in an efficient, non-case-sensitive, way.
if (c == '-' && i >= 3 && (p[i - 3] | 0x20) == 'x' && (p[i - 2] | 0x20) == 'n' && p[i - 1] == '-') {
valid = NO;
break;
}
}
}
return valid;
}
- (BOOL)_webkit_isJavaScriptURL
{
return [self _webkit_hasCaseInsensitivePrefix:@"javascript:"];
}
- (BOOL)_webkit_isFileURL
{
return [self rangeOfString:@"file:" options:(NSCaseInsensitiveSearch | NSAnchoredSearch)].location != NSNotFound;
}
- (NSString *)_webkit_stringByReplacingValidPercentEscapes
{
return decodeURLEscapeSequences(self);
}
- (NSString *)_webkit_scriptIfJavaScriptURL
{
if (![self _webkit_isJavaScriptURL]) {
return nil;
}
return [[self substringFromIndex:11] _webkit_stringByReplacingValidPercentEscapes];
}
- (BOOL)_webkit_isFTPDirectoryURL
{
int length = [self length];
if (length < 5) { // 5 is length of "ftp:/"
return NO;
}
unichar lastChar = [self characterAtIndex:length - 1];
return lastChar == '/' && [self _webkit_hasCaseInsensitivePrefix:@"ftp:"];
}
static BOOL readIDNScriptWhiteListFile(NSString *filename)
{
if (!filename) {
return NO;
}
FILE *file = fopen([filename fileSystemRepresentation], "r");
if (file == NULL) {
return NO;
}
// Read a word at a time.
// Allow comments, starting with # character to the end of the line.
while (1) {
// Skip a comment if present.
int result = fscanf(file, " #%*[^\n\r]%*[\n\r]");
if (result == EOF) {
break;
}
// Read a script name if present.
char word[33];
result = fscanf(file, " %32[^# \t\n\r]%*[^# \t\n\r] ", word);
if (result == EOF) {
break;
}
if (result == 1) {
// Got a word, map to script code and put it into the array.
int32_t script = u_getPropertyValueEnum(UCHAR_SCRIPT, word);
if (script >= 0 && script < USCRIPT_CODE_LIMIT) {
size_t index = script / 32;
uint32_t mask = 1 << (script % 32);
IDNScriptWhiteList[index] |= mask;
}
}
}
fclose(file);
return YES;
}
static void readIDNScriptWhiteList(void)
{
// Read white list from library.
NSArray *dirs = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSAllDomainsMask, YES);
int i, numDirs = [dirs count];
for (i = 0; i < numDirs; i++) {
NSString *dir = [dirs objectAtIndex:i];
if (readIDNScriptWhiteListFile([dir stringByAppendingPathComponent:@"IDNScriptWhiteList.txt"])) {
return;
}
}
// Fall back on white list inside bundle.
NSBundle *bundle = [NSBundle bundleWithIdentifier:@"com.apple.WebKit"];
readIDNScriptWhiteListFile([bundle pathForResource:@"IDNScriptWhiteList" ofType:@"txt"]);
}
static BOOL allCharactersInIDNScriptWhiteList(const UChar *buffer, int32_t length)
{
pthread_once(&IDNScriptWhiteListFileRead, readIDNScriptWhiteList);
int32_t i = 0;
while (i < length) {
UChar32 c;
U16_NEXT(buffer, i, length, c)
UErrorCode error = U_ZERO_ERROR;
UScriptCode script = uscript_getScript(c, &error);
if (error != U_ZERO_ERROR) {
LOG_ERROR("got ICU error while trying to look at scripts: %d", error);
return NO;
}
if (script < 0) {
LOG_ERROR("got negative number for script code from ICU: %d", script);
return NO;
}
if (script >= USCRIPT_CODE_LIMIT) {
return NO;
}
size_t index = script / 32;
uint32_t mask = 1 << (script % 32);
if (!(IDNScriptWhiteList[index] & mask)) {
return NO;
}
if (isLookalikeCharacter(c))
return NO;
}
return YES;
}
static BOOL allCharactersAllowedByTLDRules(const UChar* buffer, int32_t length)
{
// Skip trailing dot for root domain.
if (buffer[length - 1] == '.')
--length;
if (length > 3
&& buffer[length - 3] == '.'
&& buffer[length - 2] == 0x0440 // CYRILLIC SMALL LETTER ER
&& buffer[length - 1] == 0x0444) // CYRILLIC SMALL LETTER EF
{
// Rules defined by <http://www.cctld.ru/ru/docs/rulesrf.php>. This code only checks requirements that matter for presentation purposes.
for (int32_t i = length - 4; i; --i) {
UChar ch = buffer[i];
// Only modern Russian letters, digits and dashes are allowed.
if ((ch >= 0x0430 && ch <= 0x044f)
|| ch == 0x0451
|| (ch >= '0' && ch <= '9')
|| ch == '-')
continue;
// Only check top level domain. Lower level registrars may have different rules.
if (ch == '.')
break;
return NO;
}
return YES;
}
// Not a known top level domain with special rules.
return NO;
}
// Return value of nil means no mapping is necessary.
// If makeString is NO, then return value is either nil or self to indicate mapping is necessary.
// If makeString is YES, then return value is either nil or the mapped string.
- (NSString *)_web_mapHostNameWithRange:(NSRange)range encode:(BOOL)encode makeString:(BOOL)makeString
{
if (range.length > HOST_NAME_BUFFER_LENGTH) {
return nil;
}
if ([self length] == 0)
return nil;
UChar sourceBuffer[HOST_NAME_BUFFER_LENGTH];
UChar destinationBuffer[HOST_NAME_BUFFER_LENGTH];
NSString *string = self;
if (encode && [self rangeOfString:@"%" options:NSLiteralSearch range:range].location != NSNotFound) {
NSString *substring = [self substringWithRange:range];
substring = WebCFAutorelease(CFURLCreateStringByReplacingPercentEscapes(NULL, (CFStringRef)substring, CFSTR("")));
if (substring != nil) {
string = substring;
range = NSMakeRange(0, [string length]);
}
}
int length = range.length;
[string getCharacters:sourceBuffer range:range];
UErrorCode error = U_ZERO_ERROR;
int32_t numCharactersConverted = (encode ? uidna_IDNToASCII : uidna_IDNToUnicode)
(sourceBuffer, length, destinationBuffer, HOST_NAME_BUFFER_LENGTH, UIDNA_ALLOW_UNASSIGNED, NULL, &error);
if (error != U_ZERO_ERROR) {
return nil;
}
if (numCharactersConverted == length && memcmp(sourceBuffer, destinationBuffer, length * sizeof(UChar)) == 0) {
return nil;
}
if (!encode && !allCharactersInIDNScriptWhiteList(destinationBuffer, numCharactersConverted) && !allCharactersAllowedByTLDRules(destinationBuffer, numCharactersConverted)) {
return nil;
}
return makeString ? (NSString *)[NSString stringWithCharacters:destinationBuffer length:numCharactersConverted] : (NSString *)self;
}
- (BOOL)_web_hostNameNeedsDecodingWithRange:(NSRange)range
{
return [self _web_mapHostNameWithRange:range encode:NO makeString:NO] != nil;
}
- (BOOL)_web_hostNameNeedsEncodingWithRange:(NSRange)range
{
return [self _web_mapHostNameWithRange:range encode:YES makeString:NO] != nil;
}
- (NSString *)_web_decodeHostNameWithRange:(NSRange)range
{
return [self _web_mapHostNameWithRange:range encode:NO makeString:YES];
}
- (NSString *)_web_encodeHostNameWithRange:(NSRange)range
{
return [self _web_mapHostNameWithRange:range encode:YES makeString:YES];
}
- (NSString *)_web_decodeHostName
{
NSString *name = [self _web_mapHostNameWithRange:NSMakeRange(0, [self length]) encode:NO makeString:YES];
return name == nil ? self : name;
}
- (NSString *)_web_encodeHostName
{
NSString *name = [self _web_mapHostNameWithRange:NSMakeRange(0, [self length]) encode:YES makeString:YES];
return name == nil ? self : name;
}
-(NSRange)_webkit_rangeOfURLScheme
{
NSRange colon = [self rangeOfString:@":"];
if (colon.location != NSNotFound && colon.location > 0) {
NSRange scheme = {0, colon.location};
static NSCharacterSet *InverseSchemeCharacterSet = nil;
if (!InverseSchemeCharacterSet) {
/*
This stuff is very expensive. 10-15 msec on a 2x1.2GHz. If not cached it swamps
everything else when adding items to the autocomplete DB. Makes me wonder if we
even need to enforce the character set here.
*/
NSString *acceptableCharacters = @"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+.-";
InverseSchemeCharacterSet = [[[NSCharacterSet characterSetWithCharactersInString:acceptableCharacters] invertedSet] retain];
}
NSRange illegals = [self rangeOfCharacterFromSet:InverseSchemeCharacterSet options:0 range:scheme];
if (illegals.location == NSNotFound)
return scheme;
}
return NSMakeRange(NSNotFound, 0);
}
-(BOOL)_webkit_looksLikeAbsoluteURL
{
// Trim whitespace because _web_URLWithString allows whitespace.
return [[self _webkit_stringByTrimmingWhitespace] _webkit_rangeOfURLScheme].location != NSNotFound;
}
- (NSString *)_webkit_URLFragment
{
NSRange fragmentRange;
fragmentRange = [self rangeOfString:@"#" options:NSLiteralSearch];
if (fragmentRange.location == NSNotFound)
return nil;
return [self substringFromIndex:fragmentRange.location + 1];
}
@end