//
|
// ASIWebPageRequest.m
|
// Part of ASIHTTPRequest -> http://allseeing-i.com/ASIHTTPRequest
|
//
|
// Created by Ben Copsey on 29/06/2010.
|
// Copyright 2010 All-Seeing Interactive. All rights reserved.
|
//
|
// This is an EXPERIMENTAL class - use at your own risk!
|
|
#import "ASIWebPageRequest.h"
|
#import "ASINetworkQueue.h"
|
#import <CommonCrypto/CommonHMAC.h>
|
#import <libxml/HTMLparser.h>
|
#import <libxml/xmlsave.h>
|
#import <libxml/xpath.h>
|
#import <libxml/xpathInternals.h>
|
|
// An xPath query that controls the external resources ASIWebPageRequest will fetch
|
// By default, it will fetch stylesheets, javascript files, images, frames, iframes, and html 5 video / audio
|
static xmlChar *xpathExpr = (xmlChar *)"//link/@href|//a/@href|//script/@src|//img/@src|//frame/@src|//iframe/@src|//style|//*/@style|//source/@src|//video/@poster|//audio/@src";
|
|
static NSLock *xmlParsingLock = nil;
|
static NSMutableArray *requestsUsingXMLParser = nil;
|
|
@interface ASIWebPageRequest ()
|
- (void)readResourceURLs;
|
- (void)updateResourceURLs;
|
- (void)parseAsHTML;
|
- (void)parseAsCSS;
|
- (void)addURLToFetch:(NSString *)newURL;
|
+ (NSArray *)CSSURLsFromString:(NSString *)string;
|
- (NSString *)relativePathTo:(NSString *)destinationPath fromPath:(NSString *)sourcePath;
|
|
- (void)finishedFetchingExternalResources:(ASINetworkQueue *)queue;
|
- (void)externalResourceFetchSucceeded:(ASIHTTPRequest *)externalResourceRequest;
|
- (void)externalResourceFetchFailed:(ASIHTTPRequest *)externalResourceRequest;
|
|
@property (retain, nonatomic) ASINetworkQueue *externalResourceQueue;
|
@property (retain, nonatomic) NSMutableDictionary *resourceList;
|
@end
|
|
@implementation ASIWebPageRequest
|
|
+ (void)initialize
|
{
|
if (self == [ASIWebPageRequest class]) {
|
xmlParsingLock = [[NSLock alloc] init];
|
requestsUsingXMLParser = [[NSMutableArray alloc] init];
|
}
|
}
|
|
- (id)initWithURL:(NSURL *)newURL
|
{
|
self = [super initWithURL:newURL];
|
[self setShouldIgnoreExternalResourceErrors:YES];
|
return self;
|
}
|
|
- (void)dealloc
|
{
|
[externalResourceQueue cancelAllOperations];
|
[externalResourceQueue release];
|
[resourceList release];
|
[parentRequest release];
|
[super dealloc];
|
}
|
|
// This is a bit of a hack
|
// The role of this method in normal ASIHTTPRequests is to tell the queue we are done with the request, and perform some cleanup
|
// We override it to stop that happening, and instead do that work in the bottom of finishedFetchingExternalResources:
|
- (void)markAsFinished
|
{
|
if ([self error]) {
|
[super markAsFinished];
|
}
|
}
|
|
// This method is normally responsible for telling delegates we are done, but it happens to be the most convenient place to parse the responses
|
// Again, we call the super implementation in finishedFetchingExternalResources:, or here if this download was not an HTML or CSS file
|
- (void)requestFinished
|
{
|
complete = NO;
|
if ([self mainRequest] || [self didUseCachedResponse]) {
|
[super requestFinished];
|
[super markAsFinished];
|
return;
|
}
|
webContentType = ASINotParsedWebContentType;
|
NSString *contentType = [[[self responseHeaders] objectForKey:@"Content-Type"] lowercaseString];
|
contentType = [[contentType componentsSeparatedByString:@";"] objectAtIndex:0];
|
if ([contentType isEqualToString:@"text/html"] || [contentType isEqualToString:@"text/xhtml"] || [contentType isEqualToString:@"text/xhtml+xml"] || [contentType isEqualToString:@"application/xhtml+xml"]) {
|
[self parseAsHTML];
|
return;
|
} else if ([contentType isEqualToString:@"text/css"]) {
|
[self parseAsCSS];
|
return;
|
}
|
[super requestFinished];
|
[super markAsFinished];
|
}
|
|
- (void)parseAsCSS
|
{
|
webContentType = ASICSSWebContentType;
|
|
NSString *responseCSS = nil;
|
NSError *err = nil;
|
if ([self downloadDestinationPath]) {
|
responseCSS = [NSString stringWithContentsOfFile:[self downloadDestinationPath] encoding:[self responseEncoding] error:&err];
|
} else {
|
responseCSS = [self responseString];
|
}
|
if (err) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:100 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Unable to read HTML string from response",NSLocalizedDescriptionKey,err,NSUnderlyingErrorKey,nil]]];
|
return;
|
} else if (!responseCSS) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:100 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Unable to read HTML string from response",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
NSArray *urls = [[self class] CSSURLsFromString:responseCSS];
|
|
[self setResourceList:[NSMutableDictionary dictionary]];
|
|
for (NSString *theURL in urls) {
|
[self addURLToFetch:theURL];
|
}
|
if (![[self resourceList] count]) {
|
[super requestFinished];
|
[super markAsFinished];
|
return;
|
}
|
|
// Create a new request for every item in the queue
|
[[self externalResourceQueue] cancelAllOperations];
|
[self setExternalResourceQueue:[ASINetworkQueue queue]];
|
[[self externalResourceQueue] setDelegate:self];
|
[[self externalResourceQueue] setShouldCancelAllRequestsOnFailure:[self shouldIgnoreExternalResourceErrors]];
|
[[self externalResourceQueue] setShowAccurateProgress:[self showAccurateProgress]];
|
[[self externalResourceQueue] setQueueDidFinishSelector:@selector(finishedFetchingExternalResources:)];
|
[[self externalResourceQueue] setRequestDidFinishSelector:@selector(externalResourceFetchSucceeded:)];
|
[[self externalResourceQueue] setRequestDidFailSelector:@selector(externalResourceFetchFailed:)];
|
for (NSString *theURL in [[self resourceList] keyEnumerator]) {
|
ASIWebPageRequest *externalResourceRequest = [ASIWebPageRequest requestWithURL:[NSURL URLWithString:theURL relativeToURL:[self url]]];
|
[externalResourceRequest setRequestHeaders:[self requestHeaders]];
|
[externalResourceRequest setDownloadCache:[self downloadCache]];
|
[externalResourceRequest setCachePolicy:[self cachePolicy]];
|
[externalResourceRequest setCacheStoragePolicy:[self cacheStoragePolicy]];
|
[externalResourceRequest setUserInfo:[NSDictionary dictionaryWithObject:theURL forKey:@"Path"]];
|
[externalResourceRequest setParentRequest:self];
|
[externalResourceRequest setUrlReplacementMode:[self urlReplacementMode]];
|
[externalResourceRequest setShouldResetDownloadProgress:NO];
|
[externalResourceRequest setDelegate:self];
|
[externalResourceRequest setUploadProgressDelegate:self];
|
[externalResourceRequest setDownloadProgressDelegate:self];
|
if ([self downloadDestinationPath]) {
|
[externalResourceRequest setDownloadDestinationPath:[self cachePathForRequest:externalResourceRequest]];
|
}
|
[[self externalResourceQueue] addOperation:externalResourceRequest];
|
}
|
[[self externalResourceQueue] go];
|
}
|
|
- (const char *)encodingName
|
{
|
xmlCharEncoding encoding = XML_CHAR_ENCODING_NONE;
|
switch ([self responseEncoding])
|
{
|
case NSASCIIStringEncoding:
|
encoding = XML_CHAR_ENCODING_ASCII;
|
break;
|
case NSJapaneseEUCStringEncoding:
|
encoding = XML_CHAR_ENCODING_EUC_JP;
|
break;
|
case NSUTF8StringEncoding:
|
encoding = XML_CHAR_ENCODING_UTF8;
|
break;
|
case NSISOLatin1StringEncoding:
|
encoding = XML_CHAR_ENCODING_8859_1;
|
break;
|
case NSShiftJISStringEncoding:
|
encoding = XML_CHAR_ENCODING_SHIFT_JIS;
|
break;
|
case NSISOLatin2StringEncoding:
|
encoding = XML_CHAR_ENCODING_8859_2;
|
break;
|
case NSISO2022JPStringEncoding:
|
encoding = XML_CHAR_ENCODING_2022_JP;
|
break;
|
case NSUTF16BigEndianStringEncoding:
|
encoding = XML_CHAR_ENCODING_UTF16BE;
|
break;
|
case NSUTF16LittleEndianStringEncoding:
|
encoding = XML_CHAR_ENCODING_UTF16LE;
|
break;
|
case NSUTF32BigEndianStringEncoding:
|
encoding = XML_CHAR_ENCODING_UCS4BE;
|
break;
|
case NSUTF32LittleEndianStringEncoding:
|
encoding = XML_CHAR_ENCODING_UCS4LE;
|
break;
|
case NSNEXTSTEPStringEncoding:
|
case NSSymbolStringEncoding:
|
case NSNonLossyASCIIStringEncoding:
|
case NSUnicodeStringEncoding:
|
case NSMacOSRomanStringEncoding:
|
case NSUTF32StringEncoding:
|
default:
|
encoding = XML_CHAR_ENCODING_ERROR;
|
break;
|
}
|
return xmlGetCharEncodingName(encoding);
|
}
|
|
- (void)parseAsHTML
|
{
|
webContentType = ASIHTMLWebContentType;
|
|
// Only allow parsing of a single document at a time
|
[xmlParsingLock lock];
|
|
if (![requestsUsingXMLParser count]) {
|
xmlInitParser();
|
}
|
[requestsUsingXMLParser addObject:self];
|
|
|
/* Load XML document */
|
if ([self downloadDestinationPath]) {
|
doc = htmlReadFile([[self downloadDestinationPath] cStringUsingEncoding:NSUTF8StringEncoding], [self encodingName], HTML_PARSE_NONET | HTML_PARSE_NOWARNING | HTML_PARSE_NOERROR);
|
} else {
|
NSData *data = [self responseData];
|
doc = htmlReadMemory([data bytes], (int)[data length], "", [self encodingName], HTML_PARSE_NONET | HTML_PARSE_NOWARNING | HTML_PARSE_NOERROR);
|
}
|
if (doc == NULL) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to parse reponse XML",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
|
[self setResourceList:[NSMutableDictionary dictionary]];
|
|
// Populate the list of URLS to download
|
[self readResourceURLs];
|
|
if ([self error] || ![[self resourceList] count]) {
|
[requestsUsingXMLParser removeObject:self];
|
xmlFreeDoc(doc);
|
doc = NULL;
|
}
|
|
[xmlParsingLock unlock];
|
|
if ([self error]) {
|
return;
|
} else if (![[self resourceList] count]) {
|
[super requestFinished];
|
[super markAsFinished];
|
return;
|
}
|
|
// Create a new request for every item in the queue
|
[[self externalResourceQueue] cancelAllOperations];
|
[self setExternalResourceQueue:[ASINetworkQueue queue]];
|
[[self externalResourceQueue] setDelegate:self];
|
[[self externalResourceQueue] setShouldCancelAllRequestsOnFailure:[self shouldIgnoreExternalResourceErrors]];
|
[[self externalResourceQueue] setShowAccurateProgress:[self showAccurateProgress]];
|
[[self externalResourceQueue] setQueueDidFinishSelector:@selector(finishedFetchingExternalResources:)];
|
[[self externalResourceQueue] setRequestDidFinishSelector:@selector(externalResourceFetchSucceeded:)];
|
[[self externalResourceQueue] setRequestDidFailSelector:@selector(externalResourceFetchFailed:)];
|
for (NSString *theURL in [[self resourceList] keyEnumerator]) {
|
ASIWebPageRequest *externalResourceRequest = [ASIWebPageRequest requestWithURL:[NSURL URLWithString:theURL relativeToURL:[self url]]];
|
[externalResourceRequest setRequestHeaders:[self requestHeaders]];
|
[externalResourceRequest setDownloadCache:[self downloadCache]];
|
[externalResourceRequest setCachePolicy:[self cachePolicy]];
|
[externalResourceRequest setCacheStoragePolicy:[self cacheStoragePolicy]];
|
[externalResourceRequest setUserInfo:[NSDictionary dictionaryWithObject:theURL forKey:@"Path"]];
|
[externalResourceRequest setParentRequest:self];
|
[externalResourceRequest setUrlReplacementMode:[self urlReplacementMode]];
|
[externalResourceRequest setShouldResetDownloadProgress:NO];
|
[externalResourceRequest setDelegate:self];
|
[externalResourceRequest setUploadProgressDelegate:self];
|
[externalResourceRequest setDownloadProgressDelegate:self];
|
if ([self downloadDestinationPath]) {
|
[externalResourceRequest setDownloadDestinationPath:[self cachePathForRequest:externalResourceRequest]];
|
}
|
[[self externalResourceQueue] addOperation:externalResourceRequest];
|
}
|
[[self externalResourceQueue] go];
|
}
|
|
- (void)externalResourceFetchSucceeded:(ASIHTTPRequest *)externalResourceRequest
|
{
|
NSString *originalPath = [[externalResourceRequest userInfo] objectForKey:@"Path"];
|
NSMutableDictionary *requestResponse = [[self resourceList] objectForKey:originalPath];
|
NSString *contentType = [[externalResourceRequest responseHeaders] objectForKey:@"Content-Type"];
|
if (!contentType) {
|
contentType = @"application/octet-stream";
|
}
|
[requestResponse setObject:contentType forKey:@"ContentType"];
|
if ([self downloadDestinationPath]) {
|
[requestResponse setObject:[externalResourceRequest downloadDestinationPath] forKey:@"DataPath"];
|
} else {
|
NSData *data = [externalResourceRequest responseData];
|
if (data) {
|
[requestResponse setObject:data forKey:@"Data"];
|
}
|
}
|
}
|
|
- (void)externalResourceFetchFailed:(ASIHTTPRequest *)externalResourceRequest
|
{
|
if ([[self externalResourceQueue] shouldCancelAllRequestsOnFailure]) {
|
[self failWithError:[externalResourceRequest error]];
|
}
|
}
|
|
- (void)finishedFetchingExternalResources:(ASINetworkQueue *)queue
|
{
|
if ([self urlReplacementMode] != ASIDontModifyURLs) {
|
if (webContentType == ASICSSWebContentType) {
|
NSMutableString *parsedResponse;
|
NSError *err = nil;
|
if ([self downloadDestinationPath]) {
|
parsedResponse = [NSMutableString stringWithContentsOfFile:[self downloadDestinationPath] encoding:[self responseEncoding] error:&err];
|
} else {
|
parsedResponse = [[[self responseString] mutableCopy] autorelease];
|
}
|
if (err) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to read response CSS from disk",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
if (![self error]) {
|
for (NSString *resource in [[self resourceList] keyEnumerator]) {
|
if ([parsedResponse rangeOfString:resource].location != NSNotFound) {
|
NSString *newURL = [self contentForExternalURL:resource];
|
if (newURL) {
|
[parsedResponse replaceOccurrencesOfString:resource withString:newURL options:0 range:NSMakeRange(0, [parsedResponse length])];
|
}
|
}
|
}
|
}
|
if ([self downloadDestinationPath]) {
|
[parsedResponse writeToFile:[self downloadDestinationPath] atomically:NO encoding:[self responseEncoding] error:&err];
|
if (err) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to write response CSS to disk",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
} else {
|
[self setRawResponseData:(id)[parsedResponse dataUsingEncoding:[self responseEncoding]]];
|
}
|
} else {
|
[xmlParsingLock lock];
|
|
[self updateResourceURLs];
|
|
if (![self error]) {
|
|
// We'll use the xmlsave API so we can strip the xml declaration
|
xmlSaveCtxtPtr saveContext;
|
|
if ([self downloadDestinationPath]) {
|
|
// Truncate the file first
|
[[[[NSFileManager alloc] init] autorelease] createFileAtPath:[self downloadDestinationPath] contents:nil attributes:nil];
|
|
saveContext = xmlSaveToFd([[NSFileHandle fileHandleForWritingAtPath:[self downloadDestinationPath]] fileDescriptor],NULL,2); // 2 == XML_SAVE_NO_DECL, this isn't declared on Mac OS 10.5
|
xmlSaveDoc(saveContext, doc);
|
xmlSaveClose(saveContext);
|
|
} else {
|
#if TARGET_OS_MAC && MAC_OS_X_VERSION_MAX_ALLOWED <= __MAC_10_5
|
// xmlSaveToBuffer() is not implemented in the 10.5 version of libxml
|
NSString *tempPath = [NSTemporaryDirectory() stringByAppendingPathComponent:[[NSProcessInfo processInfo] globallyUniqueString]];
|
[[[[NSFileManager alloc] init] autorelease] createFileAtPath:tempPath contents:nil attributes:nil];
|
saveContext = xmlSaveToFd([[NSFileHandle fileHandleForWritingAtPath:tempPath] fileDescriptor],NULL,2); // 2 == XML_SAVE_NO_DECL, this isn't declared on Mac OS 10.5
|
xmlSaveDoc(saveContext, doc);
|
xmlSaveClose(saveContext);
|
[self setRawResponseData:[NSMutableData dataWithContentsOfFile:tempPath]];
|
#else
|
xmlBufferPtr buffer = xmlBufferCreate();
|
saveContext = xmlSaveToBuffer(buffer,NULL,2); // 2 == XML_SAVE_NO_DECL, this isn't declared on Mac OS 10.5
|
xmlSaveDoc(saveContext, doc);
|
xmlSaveClose(saveContext);
|
[self setRawResponseData:[[[NSMutableData alloc] initWithBytes:buffer->content length:buffer->use] autorelease]];
|
xmlBufferFree(buffer);
|
#endif
|
}
|
|
// Strip the content encoding if the original response was gzipped
|
if ([self isResponseCompressed]) {
|
NSMutableDictionary *headers = [[[self responseHeaders] mutableCopy] autorelease];
|
[headers removeObjectForKey:@"Content-Encoding"];
|
[self setResponseHeaders:headers];
|
}
|
}
|
|
xmlFreeDoc(doc);
|
doc = nil;
|
|
[requestsUsingXMLParser removeObject:self];
|
if (![requestsUsingXMLParser count]) {
|
xmlCleanupParser();
|
}
|
[xmlParsingLock unlock];
|
}
|
}
|
if (![self parentRequest]) {
|
[[self class] updateProgressIndicator:&downloadProgressDelegate withProgress:contentLength ofTotal:contentLength];
|
}
|
|
NSMutableDictionary *newHeaders = [[[self responseHeaders] mutableCopy] autorelease];
|
[newHeaders removeObjectForKey:@"Content-Encoding"];
|
[self setResponseHeaders:newHeaders];
|
|
// Write the parsed content back to the cache
|
if ([self urlReplacementMode] != ASIDontModifyURLs) {
|
[[self downloadCache] storeResponseForRequest:self maxAge:[self secondsToCache]];
|
}
|
|
[super requestFinished];
|
[super markAsFinished];
|
}
|
|
- (void)readResourceURLs
|
{
|
// Create xpath evaluation context
|
xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
|
if(xpathCtx == NULL) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to create new XPath context",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
|
// Evaluate xpath expression
|
xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx);
|
if(xpathObj == NULL) {
|
xmlXPathFreeContext(xpathCtx);
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to evaluate XPath expression!",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
|
// Now loop through our matches
|
xmlNodeSetPtr nodes = xpathObj->nodesetval;
|
|
int size = (nodes) ? nodes->nodeNr : 0;
|
int i;
|
for(i = size - 1; i >= 0; i--) {
|
assert(nodes->nodeTab[i]);
|
NSString *parentName = [NSString stringWithCString:(char *)nodes->nodeTab[i]->parent->name encoding:[self responseEncoding]];
|
NSString *nodeName = [NSString stringWithCString:(char *)nodes->nodeTab[i]->name encoding:[self responseEncoding]];
|
|
xmlChar *nodeValue = xmlNodeGetContent(nodes->nodeTab[i]);
|
NSString *value = [NSString stringWithCString:(char *)nodeValue encoding:[self responseEncoding]];
|
xmlFree(nodeValue);
|
|
// Our xpath query matched all <link> elements, but we're only interested in stylesheets
|
// We do the work here rather than in the xPath query because the query is case-sensitive, and we want to match on 'stylesheet', 'StyleSHEEt' etc
|
if ([[parentName lowercaseString] isEqualToString:@"link"]) {
|
xmlChar *relAttribute = xmlGetNoNsProp(nodes->nodeTab[i]->parent,(xmlChar *)"rel");
|
if (relAttribute) {
|
NSString *rel = [NSString stringWithCString:(char *)relAttribute encoding:[self responseEncoding]];
|
xmlFree(relAttribute);
|
if ([[rel lowercaseString] isEqualToString:@"stylesheet"]) {
|
[self addURLToFetch:value];
|
}
|
}
|
|
// Parse the content of <style> tags and style attributes to find external image urls or external css files
|
} else if ([[nodeName lowercaseString] isEqualToString:@"style"]) {
|
NSArray *externalResources = [[self class] CSSURLsFromString:value];
|
for (NSString *theURL in externalResources) {
|
[self addURLToFetch:theURL];
|
}
|
|
// Parse the content of <source src=""> tags (HTML 5 audio + video)
|
// We explictly disable the download of files with .webm, .ogv and .ogg extensions, since it's highly likely they won't be useful to us
|
} else if ([[parentName lowercaseString] isEqualToString:@"source"] || [[parentName lowercaseString] isEqualToString:@"audio"]) {
|
NSString *fileExtension = [[value pathExtension] lowercaseString];
|
if (![fileExtension isEqualToString:@"ogg"] && ![fileExtension isEqualToString:@"ogv"] && ![fileExtension isEqualToString:@"webm"]) {
|
[self addURLToFetch:value];
|
}
|
|
// For all other elements matched by our xpath query (except hyperlinks), add the content as an external url to fetch
|
} else if (![[parentName lowercaseString] isEqualToString:@"a"]) {
|
[self addURLToFetch:value];
|
}
|
if (nodes->nodeTab[i]->type != XML_NAMESPACE_DECL) {
|
nodes->nodeTab[i] = NULL;
|
}
|
}
|
|
xmlXPathFreeObject(xpathObj);
|
xmlXPathFreeContext(xpathCtx);
|
}
|
|
- (void)addURLToFetch:(NSString *)newURL
|
{
|
// Get rid of any surrounding whitespace
|
newURL = [newURL stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
|
// Don't attempt to fetch data URIs
|
if ([newURL length] > 4) {
|
if (![[[newURL substringToIndex:5] lowercaseString] isEqualToString:@"data:"]) {
|
NSURL *theURL = [NSURL URLWithString:newURL relativeToURL:[self url]];
|
if (theURL) {
|
if (![[self resourceList] objectForKey:newURL]) {
|
[[self resourceList] setObject:[NSMutableDictionary dictionary] forKey:newURL];
|
}
|
}
|
}
|
}
|
}
|
|
|
- (void)updateResourceURLs
|
{
|
// Create xpath evaluation context
|
xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
|
if(xpathCtx == NULL) {
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to create new XPath context",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
|
// Evaluate xpath expression
|
xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx);
|
if(xpathObj == NULL) {
|
xmlXPathFreeContext(xpathCtx);
|
[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:101 userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Error: unable to evaluate XPath expression!",NSLocalizedDescriptionKey,nil]]];
|
return;
|
}
|
|
// Loop through all the matches, replacing urls where nescessary
|
xmlNodeSetPtr nodes = xpathObj->nodesetval;
|
int size = (nodes) ? nodes->nodeNr : 0;
|
int i;
|
for(i = size - 1; i >= 0; i--) {
|
assert(nodes->nodeTab[i]);
|
NSString *parentName = [NSString stringWithCString:(char *)nodes->nodeTab[i]->parent->name encoding:[self responseEncoding]];
|
NSString *nodeName = [NSString stringWithCString:(char *)nodes->nodeTab[i]->name encoding:[self responseEncoding]];
|
|
xmlChar *nodeValue = xmlNodeGetContent(nodes->nodeTab[i]);
|
NSString *value = [NSString stringWithCString:(char *)nodeValue encoding:[self responseEncoding]];
|
xmlFree(nodeValue);
|
|
// Replace external urls in <style> tags or in style attributes
|
if ([[nodeName lowercaseString] isEqualToString:@"style"]) {
|
NSArray *externalResources = [[self class] CSSURLsFromString:value];
|
for (NSString *theURL in externalResources) {
|
if ([value rangeOfString:theURL].location != NSNotFound) {
|
NSString *newURL = [self contentForExternalURL:theURL];
|
if (newURL) {
|
value = [value stringByReplacingOccurrencesOfString:theURL withString:newURL];
|
}
|
}
|
}
|
xmlNodeSetContent(nodes->nodeTab[i], (xmlChar *)[value cStringUsingEncoding:[self responseEncoding]]);
|
|
// Replace relative hyperlinks with absolute ones, since we will need to set a local baseURL when loading this in a web view
|
} else if ([self urlReplacementMode] == ASIReplaceExternalResourcesWithLocalURLs && [[parentName lowercaseString] isEqualToString:@"a"]) {
|
NSString *newURL = [[NSURL URLWithString:value relativeToURL:[self url]] absoluteString];
|
if (newURL) {
|
xmlNodeSetContent(nodes->nodeTab[i], (xmlChar *)[newURL cStringUsingEncoding:[self responseEncoding]]);
|
}
|
|
// Replace all other external resource urls
|
} else {
|
NSString *newURL = [self contentForExternalURL:value];
|
if (newURL) {
|
xmlNodeSetContent(nodes->nodeTab[i], (xmlChar *)[newURL cStringUsingEncoding:[self responseEncoding]]);
|
}
|
}
|
|
if (nodes->nodeTab[i]->type != XML_NAMESPACE_DECL) {
|
nodes->nodeTab[i] = NULL;
|
}
|
}
|
xmlXPathFreeObject(xpathObj);
|
xmlXPathFreeContext(xpathCtx);
|
}
|
|
// The three methods below are responsible for forwarding delegate methods we want to handle to the parent request's approdiate delegate
|
// Certain delegate methods are ignored (eg setProgress: / setDoubleValue: / setMaxValue:)
|
- (BOOL)respondsToSelector:(SEL)selector
|
{
|
if ([self parentRequest]) {
|
return [[self parentRequest] respondsToSelector:selector];
|
}
|
//Ok, now check for selectors we want to pass on to the delegate
|
if (selector == @selector(requestStarted:) || selector == @selector(request:didReceiveResponseHeaders:) || selector == @selector(request:willRedirectToURL:) || selector == @selector(requestFinished:) || selector == @selector(requestFailed:) || selector == @selector(request:didReceiveData:) || selector == @selector(authenticationNeededForRequest:) || selector == @selector(proxyAuthenticationNeededForRequest:)) {
|
return [delegate respondsToSelector:selector];
|
} else if (selector == @selector(request:didReceiveBytes:) || selector == @selector(request:incrementDownloadSizeBy:)) {
|
return [downloadProgressDelegate respondsToSelector:selector];
|
} else if (selector == @selector(request:didSendBytes:) || selector == @selector(request:incrementUploadSizeBy:)) {
|
return [uploadProgressDelegate respondsToSelector:selector];
|
}
|
return [super respondsToSelector:selector];
|
}
|
|
- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
|
{
|
if ([self parentRequest]) {
|
return [[self parentRequest] methodSignatureForSelector:selector];
|
}
|
if (selector == @selector(requestStarted:) || selector == @selector(request:didReceiveResponseHeaders:) || selector == @selector(request:willRedirectToURL:) || selector == @selector(requestFinished:) || selector == @selector(requestFailed:) || selector == @selector(request:didReceiveData:) || selector == @selector(authenticationNeededForRequest:) || selector == @selector(proxyAuthenticationNeededForRequest:)) {
|
return [(id)delegate methodSignatureForSelector:selector];
|
} else if (selector == @selector(request:didReceiveBytes:) || selector == @selector(request:incrementDownloadSizeBy:)) {
|
return [(id)downloadProgressDelegate methodSignatureForSelector:selector];
|
} else if (selector == @selector(request:didSendBytes:) || selector == @selector(request:incrementUploadSizeBy:)) {
|
return [(id)uploadProgressDelegate methodSignatureForSelector:selector];
|
}
|
return nil;
|
}
|
|
- (void)forwardInvocation:(NSInvocation *)anInvocation
|
{
|
if ([self parentRequest]) {
|
return [[self parentRequest] forwardInvocation:anInvocation];
|
}
|
SEL selector = [anInvocation selector];
|
if (selector == @selector(requestStarted:) || selector == @selector(request:didReceiveResponseHeaders:) || selector == @selector(request:willRedirectToURL:) || selector == @selector(requestFinished:) || selector == @selector(requestFailed:) || selector == @selector(request:didReceiveData:) || selector == @selector(authenticationNeededForRequest:) || selector == @selector(proxyAuthenticationNeededForRequest:)) {
|
[anInvocation invokeWithTarget:delegate];
|
} else if (selector == @selector(request:didReceiveBytes:) || selector == @selector(request:incrementDownloadSizeBy:)) {
|
[anInvocation invokeWithTarget:downloadProgressDelegate];
|
} else if (selector == @selector(request:didSendBytes:) || selector == @selector(request:incrementUploadSizeBy:)) {
|
[anInvocation invokeWithTarget:uploadProgressDelegate];
|
}
|
}
|
|
// A quick and dirty way to build a list of external resource urls from a css string
|
+ (NSArray *)CSSURLsFromString:(NSString *)string
|
{
|
NSMutableArray *urls = [NSMutableArray array];
|
NSScanner *scanner = [NSScanner scannerWithString:string];
|
[scanner setCaseSensitive:NO];
|
while (1) {
|
NSString *theURL = nil;
|
[scanner scanUpToString:@"url(" intoString:NULL];
|
[scanner scanString:@"url(" intoString:NULL];
|
[scanner scanUpToString:@")" intoString:&theURL];
|
if (!theURL) {
|
break;
|
}
|
// Remove any quotes or whitespace around the url
|
theURL = [theURL stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
|
theURL = [theURL stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"\"'"]];
|
theURL = [theURL stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
|
[urls addObject:theURL];
|
}
|
return urls;
|
}
|
|
// Returns a relative file path from sourcePath to destinationPath (eg ../../foo/bar.txt)
|
- (NSString *)relativePathTo:(NSString *)destinationPath fromPath:(NSString *)sourcePath
|
{
|
NSArray *sourcePathComponents = [sourcePath pathComponents];
|
NSArray *destinationPathComponents = [destinationPath pathComponents];
|
NSUInteger i;
|
NSString *newPath = @"";
|
NSString *sourcePathComponent, *destinationPathComponent;
|
for (i=0; i<[sourcePathComponents count]; i++) {
|
sourcePathComponent = [sourcePathComponents objectAtIndex:i];
|
if ([destinationPathComponents count] > i) {
|
destinationPathComponent = [destinationPathComponents objectAtIndex:i];
|
if (![sourcePathComponent isEqualToString:destinationPathComponent]) {
|
NSUInteger i2;
|
for (i2=i+1; i2<[sourcePathComponents count]; i2++) {
|
newPath = [newPath stringByAppendingPathComponent:@".."];
|
}
|
newPath = [newPath stringByAppendingPathComponent:destinationPathComponent];
|
for (i2=i+1; i2<[destinationPathComponents count]; i2++) {
|
newPath = [newPath stringByAppendingPathComponent:[destinationPathComponents objectAtIndex:i2]];
|
}
|
break;
|
}
|
}
|
}
|
return newPath;
|
}
|
|
- (NSString *)contentForExternalURL:(NSString *)theURL
|
{
|
if ([self urlReplacementMode] == ASIReplaceExternalResourcesWithLocalURLs) {
|
NSString *resourcePath = [[resourceList objectForKey:theURL] objectForKey:@"DataPath"];
|
return [self relativePathTo:resourcePath fromPath:[self downloadDestinationPath]];
|
}
|
NSData *data;
|
if ([[resourceList objectForKey:theURL] objectForKey:@"DataPath"]) {
|
data = [NSData dataWithContentsOfFile:[[resourceList objectForKey:theURL] objectForKey:@"DataPath"]];
|
} else {
|
data = [[resourceList objectForKey:theURL] objectForKey:@"Data"];
|
}
|
NSString *contentType = [[resourceList objectForKey:theURL] objectForKey:@"ContentType"];
|
if (data && contentType) {
|
NSString *dataURI = [NSString stringWithFormat:@"data:%@;base64,",contentType];
|
dataURI = [dataURI stringByAppendingString:[ASIHTTPRequest base64forData:data]];
|
return dataURI;
|
}
|
return nil;
|
}
|
|
- (NSString *)cachePathForRequest:(ASIWebPageRequest *)theRequest
|
{
|
// If we're using a download cache (and its a good idea to do so when using ASIWebPageRequest), ask it for the location to store this file
|
// This ends up being quite efficient, as we download directly to the cache
|
if ([self downloadCache]) {
|
return [[self downloadCache] pathToStoreCachedResponseDataForRequest:theRequest];
|
|
// This is a fallback for when we don't have a download cache - we store the external resource in a file in the temporary directory
|
} else {
|
// Borrowed from: http://stackoverflow.com/questions/652300/using-md5-hash-on-a-string-in-cocoa
|
const char *cStr = [[[theRequest url] absoluteString] UTF8String];
|
unsigned char result[16];
|
CC_MD5(cStr, (CC_LONG)strlen(cStr), result);
|
NSString *md5 = [NSString stringWithFormat:@"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7],result[8], result[9], result[10], result[11],result[12], result[13], result[14], result[15]];
|
return [[NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) objectAtIndex:0] stringByAppendingPathComponent:[md5 stringByAppendingPathExtension:@"html"]];
|
}
|
}
|
|
|
@synthesize externalResourceQueue;
|
@synthesize resourceList;
|
@synthesize parentRequest;
|
@synthesize urlReplacementMode;
|
@synthesize shouldIgnoreExternalResourceErrors;
|
@end
|
