Synnefo » Pithos MacOS & iOS Common Lib

//

//  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