#import "ASIHTTPRequest.h"

#if TARGET_OS_IPHONE

#import "Reachability.h"

#import "ASIAuthenticationDialog.h"

#import <MobileCoreServices/MobileCoreServices.h>

#else

#import <SystemConfiguration/SystemConfiguration.h>

#endif

#import "ASIInputStream.h"

#import "ASIDataDecompressor.h"

#import "ASIDataCompressor.h"

NSString *ASIHTTPRequestVersion = @"v1.8-21 2010-12-04";

NSString* const NetworkRequestErrorDomain = @"ASIHTTPRequestErrorDomain";

static NSString *ASIHTTPRequestRunLoopMode = @"ASIHTTPRequestRunLoopMode";

static const CFOptionFlags kNetworkEvents = kCFStreamEventHasBytesAvailable | kCFStreamEventEndEncountered | kCFStreamEventErrorOccurred;

static NSMutableArray *sessionCredentialsStore = nil;

static NSMutableArray *sessionProxyCredentialsStore = nil;

static NSRecursiveLock *sessionCredentialsLock = nil;

static NSMutableArray *sessionCookies = nil;

const int RedirectionLimit = 5;

static NSTimeInterval defaultTimeOutSeconds = 10;

static void ReadStreamClientCallBack(CFReadStreamRef readStream, CFStreamEventType type, void *clientCallBackInfo) {

[((ASIHTTPRequest*)clientCallBackInfo) handleNetworkEvent: type];

}

static NSRecursiveLock *progressLock;

static NSError *ASIRequestCancelledError;

static NSError *ASIRequestTimedOutError;

static NSError *ASIAuthenticationError;

static NSError *ASIUnableToCreateRequestError;

static NSError *ASITooMuchRedirectionError;

static NSMutableArray *bandwidthUsageTracker = nil;

static unsigned long averageBandwidthUsedPerSecond = 0;

static unsigned int nextConnectionNumberToCreate = 0;

static NSMutableArray *persistentConnectionsPool = nil;

static NSRecursiveLock *connectionsLock = nil;

static unsigned int nextRequestID = 0;

static unsigned long bandwidthUsedInLastSecond = 0;

static NSDate *bandwidthMeasurementDate = nil;

static NSLock *bandwidthThrottlingLock = nil;

static unsigned long maxBandwidthPerSecond = 0;

unsigned long const ASIWWANBandwidthThrottleAmount = 14800;

#if TARGET_OS_IPHONE

static BOOL isBandwidthThrottled = NO;

static BOOL shouldThrottleBandwithForWWANOnly = NO;

#endif

static NSRecursiveLock *sessionCookiesLock = nil;

static NSRecursiveLock *delegateAuthenticationLock = nil;

static NSDate *throttleWakeUpTime = nil;

static id <ASICacheDelegate> defaultCache = nil;

static unsigned int runningRequestCount = 0;

static BOOL shouldUpdateNetworkActivityIndicator = YES;

static NSThread *networkThread = nil;

static NSOperationQueue *sharedQueue = nil;

@interface ASIHTTPRequest ()

- (void)cancelLoad;

- (void)destroyReadStream;

- (void)scheduleReadStream;

- (void)unscheduleReadStream;

- (BOOL)willAskDelegateForCredentials;

- (BOOL)willAskDelegateForProxyCredentials;

- (void)askDelegateForProxyCredentials;

- (void)askDelegateForCredentials;

- (void)failAuthentication;

+ (void)measureBandwidthUsage;

+ (void)recordBandwidthUsage;

- (void)startRequest;

- (void)updateStatus:(NSTimer *)timer;

- (void)checkRequestStatus;

- (void)markAsFinished;

- (void)performRedirect;

- (BOOL)shouldTimeOut;

+ (void)performInvocation:(NSInvocation *)invocation onTarget:(id *)target releasingObject:(id)objectToRelease;

+ (void)hideNetworkActivityIndicatorAfterDelay;

+ (void)hideNetworkActivityIndicatorIfNeeeded;

+ (void)runRequests;

- (void)useDataFromCache;

- (void)updatePartialDownloadSize;

#if TARGET_OS_IPHONE

+ (void)registerForNetworkReachabilityNotifications;

+ (void)unsubscribeFromNetworkReachabilityNotifications;

+ (void)reachabilityChanged:(NSNotification *)note;

#endif

#if NS_BLOCKS_AVAILABLE

- (void)performBlockOnMainThread:(ASIBasicBlock)block;

- (void)releaseBlocksOnMainThread;

+ (void)releaseBlocks:(NSArray *)blocks;

- (void)callBlock:(ASIBasicBlock)block;

#endif

@property (assign) BOOL complete;

@property (retain) NSArray *responseCookies;

@property (assign) int responseStatusCode;

@property (retain, nonatomic) NSDate *lastActivityTime;

@property (assign) unsigned long long partialDownloadSize;

@property (assign, nonatomic) unsigned long long uploadBufferSize;

@property (retain, nonatomic) NSOutputStream *postBodyWriteStream;

@property (retain, nonatomic) NSInputStream *postBodyReadStream;

@property (assign, nonatomic) unsigned long long lastBytesRead;

@property (assign, nonatomic) unsigned long long lastBytesSent;

@property (retain) NSRecursiveLock *cancelledLock;

@property (retain, nonatomic) NSOutputStream *fileDownloadOutputStream;

@property (retain, nonatomic) NSOutputStream *inflatedFileDownloadOutputStream;

@property (assign) int authenticationRetryCount;

@property (assign) int proxyAuthenticationRetryCount;

@property (assign, nonatomic) BOOL updatedProgress;

@property (assign, nonatomic) BOOL needsRedirect;

@property (assign, nonatomic) int redirectCount;

@property (retain, nonatomic) NSData *compressedPostBody;

@property (retain, nonatomic) NSString *compressedPostBodyFilePath;

@property (retain) NSString *authenticationRealm;

@property (retain) NSString *proxyAuthenticationRealm;

@property (retain) NSString *responseStatusMessage;

@property (assign) BOOL inProgress;

@property (assign) int retryCount;

@property (assign) BOOL connectionCanBeReused;

@property (retain, nonatomic) NSMutableDictionary *connectionInfo;

@property (retain, nonatomic) NSInputStream *readStream;

@property (assign) ASIAuthenticationState authenticationNeeded;

@property (assign, nonatomic) BOOL readStreamIsScheduled;

@property (assign, nonatomic) BOOL downloadComplete;

@property (retain) NSNumber *requestID;

@property (assign, nonatomic) NSString *runLoopMode;

@property (retain, nonatomic) NSTimer *statusTimer;

@property (assign) BOOL didUseCachedResponse;

@property (retain, nonatomic) NSURL *redirectURL;

@implementation ASIHTTPRequest

#pragma mark init / dealloc

+ (void)initialize

{

if (self == [ASIHTTPRequest class]) {

persistentConnectionsPool = [[NSMutableArray alloc] init];

connectionsLock = [[NSRecursiveLock alloc] init];

progressLock = [[NSRecursiveLock alloc] init];

bandwidthThrottlingLock = [[NSLock alloc] init];

sessionCookiesLock = [[NSRecursiveLock alloc] init];

sessionCredentialsLock = [[NSRecursiveLock alloc] init];

delegateAuthenticationLock = [[NSRecursiveLock alloc] init];

bandwidthUsageTracker = [[NSMutableArray alloc] initWithCapacity:5];

ASIRequestTimedOutError = [[NSError alloc] initWithDomain:NetworkRequestErrorDomain code:ASIRequestTimedOutErrorType userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"The request timed out",NSLocalizedDescriptionKey,nil]];

ASIAuthenticationError = [[NSError alloc] initWithDomain:NetworkRequestErrorDomain code:ASIAuthenticationErrorType userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Authentication needed",NSLocalizedDescriptionKey,nil]];

ASIRequestCancelledError = [[NSError alloc] initWithDomain:NetworkRequestErrorDomain code:ASIRequestCancelledErrorType userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"The request was cancelled",NSLocalizedDescriptionKey,nil]];

ASIUnableToCreateRequestError = [[NSError alloc] initWithDomain:NetworkRequestErrorDomain code:ASIUnableToCreateRequestErrorType userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"Unable to create request (bad url?)",NSLocalizedDescriptionKey,nil]];

ASITooMuchRedirectionError = [[NSError alloc] initWithDomain:NetworkRequestErrorDomain code:ASITooMuchRedirectionErrorType userInfo:[NSDictionary dictionaryWithObjectsAndKeys:@"The request failed because it redirected too many times",NSLocalizedDescriptionKey,nil]];

sharedQueue = [[NSOperationQueue alloc] init];

[sharedQueue setMaxConcurrentOperationCount:4];

}

}

- (id)initWithURL:(NSURL *)newURL

{

self = [self init];

[self setRequestMethod:@"GET"];

[self setRunLoopMode:NSDefaultRunLoopMode];

[self setShouldAttemptPersistentConnection:YES];

[self setPersistentConnectionTimeoutSeconds:60.0];

[self setShouldPresentCredentialsBeforeChallenge:YES];

[self setShouldRedirect:YES];

[self setShowAccurateProgress:YES];

[self setShouldResetDownloadProgress:YES];

[self setShouldResetUploadProgress:YES];

[self setAllowCompressedResponse:YES];

[self setShouldWaitToInflateCompressedResponses:YES];

[self setDefaultResponseEncoding:NSISOLatin1StringEncoding];

[self setShouldPresentProxyAuthenticationDialog:YES];

[self setTimeOutSeconds:[ASIHTTPRequest defaultTimeOutSeconds]];

[self setUseSessionPersistence:YES];

[self setUseCookiePersistence:YES];

[self setValidatesSecureCertificate:YES];

[self setRequestCookies:[[[NSMutableArray alloc] init] autorelease]];

[self setDidStartSelector:@selector(requestStarted:)];

[self setDidReceiveResponseHeadersSelector:@selector(request:didReceiveResponseHeaders:)];

[self setWillRedirectSelector:@selector(request:willRedirectToURL:)];

[self setDidFinishSelector:@selector(requestFinished:)];

[self setDidFailSelector:@selector(requestFailed:)];

[self setDidReceiveDataSelector:@selector(request:didReceiveData:)];

[self setURL:newURL];

[self setCancelledLock:[[[NSRecursiveLock alloc] init] autorelease]];

[self setDownloadCache:[[self class] defaultCache]];

return self;

}

+ (id)requestWithURL:(NSURL *)newURL

{

return [[[self alloc] initWithURL:newURL] autorelease];

}

+ (id)requestWithURL:(NSURL *)newURL usingCache:(id <ASICacheDelegate>)cache

{

return [self requestWithURL:newURL usingCache:cache andCachePolicy:ASIUseDefaultCachePolicy];

}

+ (id)requestWithURL:(NSURL *)newURL usingCache:(id <ASICacheDelegate>)cache andCachePolicy:(ASICachePolicy)policy

{

ASIHTTPRequest *request = [[[self alloc] initWithURL:newURL] autorelease];

[request setDownloadCache:cache];

[request setCachePolicy:policy];

return request;

}

- (void)dealloc

{

[self setAuthenticationNeeded:ASINoAuthenticationNeededYet];

if (requestAuthentication) {

CFRelease(requestAuthentication);

}

if (proxyAuthentication) {

CFRelease(proxyAuthentication);

}

if (request) {

CFRelease(request);

}

if (clientCertificateIdentity) {

CFRelease(clientCertificateIdentity);

}

[self cancelLoad];

[queue release];

[userInfo release];

[postBody release];

[compressedPostBody release];

[error release];

[requestHeaders release];

[requestCookies release];

[downloadDestinationPath release];

[temporaryFileDownloadPath release];

[temporaryUncompressedDataDownloadPath release];

[fileDownloadOutputStream release];

[inflatedFileDownloadOutputStream release];

[username release];

[password release];

[domain release];

[authenticationRealm release];

[authenticationScheme release];

[requestCredentials release];

[proxyHost release];

[proxyType release];

[proxyUsername release];

[proxyPassword release];

[proxyDomain release];

[proxyAuthenticationRealm release];

[proxyAuthenticationScheme release];

[proxyCredentials release];

[url release];

[originalURL release];

[lastActivityTime release];

[responseCookies release];

[rawResponseData release];

[responseHeaders release];

[requestMethod release];

[cancelledLock release];

[postBodyFilePath release];

[compressedPostBodyFilePath release];

[postBodyWriteStream release];

[postBodyReadStream release];

[PACurl release];

[clientCertificates release];

[responseStatusMessage release];

[connectionInfo release];

[requestID release];

[dataDecompressor release];

#if NS_BLOCKS_AVAILABLE

[self releaseBlocksOnMainThread];

#endif

[super dealloc];

}

#if NS_BLOCKS_AVAILABLE

- (void)releaseBlocksOnMainThread

{

NSMutableArray *blocks = [NSMutableArray array];

if (completionBlock) {

[blocks addObject:completionBlock];

[completionBlock release];

completionBlock = nil;

}

if (failureBlock) {

[blocks addObject:failureBlock];

[failureBlock release];

failureBlock = nil;

}

if (startedBlock) {

[blocks addObject:startedBlock];

[startedBlock release];

startedBlock = nil;

}

if (headersReceivedBlock) {

[blocks addObject:headersReceivedBlock];

[headersReceivedBlock release];

headersReceivedBlock = nil;

}

if (bytesReceivedBlock) {

[blocks addObject:bytesReceivedBlock];

[bytesReceivedBlock release];

bytesReceivedBlock = nil;

}

if (bytesSentBlock) {

[blocks addObject:bytesSentBlock];

[bytesSentBlock release];

bytesSentBlock = nil;

}

if (downloadSizeIncrementedBlock) {

[blocks addObject:downloadSizeIncrementedBlock];

[downloadSizeIncrementedBlock release];

downloadSizeIncrementedBlock = nil;

}

if (uploadSizeIncrementedBlock) {

[blocks addObject:uploadSizeIncrementedBlock];

[uploadSizeIncrementedBlock release];

uploadSizeIncrementedBlock = nil;

}

if (dataReceivedBlock) {

[blocks addObject:dataReceivedBlock];

[dataReceivedBlock release];

dataReceivedBlock = nil;

}

if (proxyAuthenticationNeededBlock) {

[blocks addObject:proxyAuthenticationNeededBlock];

[proxyAuthenticationNeededBlock release];

proxyAuthenticationNeededBlock = nil;

}

if (authenticationNeededBlock) {

[blocks addObject:authenticationNeededBlock];

[authenticationNeededBlock release];

authenticationNeededBlock = nil;

}

[[self class] performSelectorOnMainThread:@selector(releaseBlocks:) withObject:blocks waitUntilDone:[NSThread isMainThread]];

}

+ (void)releaseBlocks:(NSArray *)blocks

{

// Blocks will be released when this method exits

}

#endif

#pragma mark setup request

- (void)addRequestHeader:(NSString *)header value:(NSString *)value

{

if (!requestHeaders) {

[self setRequestHeaders:[NSMutableDictionary dictionaryWithCapacity:1]];

}

[requestHeaders setObject:value forKey:header];

}

- (void)buildPostBody

{

if ([self haveBuiltPostBody]) {

return;

}

// Are we submitting the request body from a file on disk

if ([self postBodyFilePath]) {

// If we were writing to the post body via appendPostData or appendPostDataFromFile, close the write stream

if ([self postBodyWriteStream]) {

[[self postBodyWriteStream] close];

[self setPostBodyWriteStream:nil];

}

NSString *path;

if ([self shouldCompressRequestBody]) {

if (![self compressedPostBodyFilePath]) {

[self setCompressedPostBodyFilePath:[NSTemporaryDirectory() stringByAppendingPathComponent:[[NSProcessInfo processInfo] globallyUniqueString]]];

NSError *err = nil;

if (![ASIDataCompressor compressDataFromFile:[self postBodyFilePath] toFile:[self compressedPostBodyFilePath] error:&err]) {

[self failWithError:err];

return;

}

}

path = [self compressedPostBodyFilePath];

} else {

path = [self postBodyFilePath];

}

NSError *err = nil;

[self setPostLength:[[[[[NSFileManager alloc] init] autorelease] attributesOfItemAtPath:path error:&err] fileSize]];

if (err) {

[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:ASIFileManagementError userInfo:[NSDictionary dictionaryWithObjectsAndKeys:[NSString stringWithFormat:@"Failed to get attributes for file at path '%@'",path],NSLocalizedDescriptionKey,error,NSUnderlyingErrorKey,nil]]];

return;

}

// Otherwise, we have an in-memory request body

} else {

if ([self shouldCompressRequestBody]) {

NSError *err = nil;

NSData *compressedBody = [ASIDataCompressor compressData:[self postBody] error:&err];

if (err) {

[self failWithError:err];

return;

}

[self setCompressedPostBody:compressedBody];

[self setPostLength:[[self compressedPostBody] length]];

} else {

[self setPostLength:[[self postBody] length]];

}

}

if ([self postLength] > 0) {

if ([requestMethod isEqualToString:@"GET"] || [requestMethod isEqualToString:@"DELETE"] || [requestMethod isEqualToString:@"HEAD"]) {

[self setRequestMethod:@"POST"];

}

[self addRequestHeader:@"Content-Length" value:[NSString stringWithFormat:@"%llu",[self postLength]]];

}

[self setHaveBuiltPostBody:YES];

}

- (void)setupPostBody

{

if ([self shouldStreamPostDataFromDisk]) {

if (![self postBodyFilePath]) {

[self setPostBodyFilePath:[NSTemporaryDirectory() stringByAppendingPathComponent:[[NSProcessInfo processInfo] globallyUniqueString]]];

[self setDidCreateTemporaryPostDataFile:YES];

}

if (![self postBodyWriteStream]) {

[self setPostBodyWriteStream:[[[NSOutputStream alloc] initToFileAtPath:[self postBodyFilePath] append:NO] autorelease]];

[[self postBodyWriteStream] open];

}

} else {

if (![self postBody]) {

[self setPostBody:[[[NSMutableData alloc] init] autorelease]];

}

}

}

- (void)appendPostData:(NSData *)data

{

[self setupPostBody];

if ([data length] == 0) {

return;

}

if ([self shouldStreamPostDataFromDisk]) {

[[self postBodyWriteStream] write:[data bytes] maxLength:[data length]];

} else {

[[self postBody] appendData:data];

}

}

- (void)appendPostDataFromFile:(NSString *)file

{

[self setupPostBody];

NSInputStream *stream = [[[NSInputStream alloc] initWithFileAtPath:file] autorelease];

[stream open];

NSUInteger bytesRead;

while ([stream hasBytesAvailable]) {

unsigned char buffer[1024*256];

bytesRead = [stream read:buffer maxLength:sizeof(buffer)];

if (bytesRead == 0) {

break;

}

if ([self shouldStreamPostDataFromDisk]) {

[[self postBodyWriteStream] write:buffer maxLength:bytesRead];

} else {

[[self postBody] appendData:[NSData dataWithBytes:buffer length:bytesRead]];

}

}

[stream close];

}

- (NSURL *)url

{

[[self cancelledLock] lock];

NSURL *u = url;

[[self cancelledLock] unlock];

return u;

}

- (void)setURL:(NSURL *)newURL

{

[[self cancelledLock] lock];

if ([newURL isEqual:[self url]]) {

[[self cancelledLock] unlock];

return;

}

[url release];

url = [newURL retain];

if (requestAuthentication) {

CFRelease(requestAuthentication);

requestAuthentication = NULL;

}

if (proxyAuthentication) {

CFRelease(proxyAuthentication);

proxyAuthentication = NULL;

}

if (request) {

CFRelease(request);

request = NULL;

}

[self setRedirectURL:nil];

[[self cancelledLock] unlock];

}

- (id)delegate

{

[[self cancelledLock] lock];

id d = delegate;

[[self cancelledLock] unlock];

return d;

}

- (void)setDelegate:(id)newDelegate

{

[[self cancelledLock] lock];

delegate = newDelegate;

[[self cancelledLock] unlock];

}

- (id)queue

{

[[self cancelledLock] lock];

id q = queue;

[[self cancelledLock] unlock];

return q;

}

- (void)setQueue:(id)newQueue

{

[[self cancelledLock] lock];

if (newQueue != queue) {

[queue release];

queue = [newQueue retain];

}

[[self cancelledLock] unlock];

}

#pragma mark get information about this request

- (void)cancelOnRequestThread

{

#if DEBUG_REQUEST_STATUS

//NSLog(@"Request cancelled: %@",self);

#endif

[[self cancelledLock] lock];

if ([self isCancelled] || [self complete]) {

[[self cancelledLock] unlock];

return;

}

[self failWithError:ASIRequestCancelledError];

[self setComplete:YES];

[self cancelLoad];

CFRetain(self);

[self willChangeValueForKey:@"isCancelled"];

cancelled = YES;

[self didChangeValueForKey:@"isCancelled"];

[[self cancelledLock] unlock];

CFRelease(self);

}

- (void)cancel

{

[self performSelector:@selector(cancelOnRequestThread) onThread:[[self class] threadForRequest:self] withObject:nil waitUntilDone:NO];

}

- (void)clearDelegatesAndCancel

{

[[self cancelledLock] lock];

// Clear delegates

[self setDelegate:nil];

[self setQueue:nil];

[self setDownloadProgressDelegate:nil];

[self setUploadProgressDelegate:nil];

#if NS_BLOCKS_AVAILABLE

// Clear blocks

[self releaseBlocksOnMainThread];

#endif

[[self cancelledLock] unlock];

[self cancel];

}

- (BOOL)isCancelled

{

BOOL result;

[[self cancelledLock] lock];

result = cancelled;

[[self cancelledLock] unlock];

return result;

}

- (NSString *)responseString

{

NSData *data = [self responseData];

if (!data) {

return nil;

}

return [[[NSString alloc] initWithBytes:[data bytes] length:[data length] encoding:[self responseEncoding]] autorelease];

}

- (BOOL)isResponseCompressed

{

NSString *encoding = [[self responseHeaders] objectForKey:@"Content-Encoding"];

return encoding && [encoding rangeOfString:@"gzip"].location != NSNotFound;

}

- (NSData *)responseData

{

if ([self isResponseCompressed] && [self shouldWaitToInflateCompressedResponses]) {

return [ASIDataDecompressor uncompressData:[self rawResponseData] error:NULL];

} else {

return [self rawResponseData];

}

return nil;

}

#pragma mark running a request

- (void)startSynchronous

{

#if DEBUG_REQUEST_STATUS || DEBUG_THROTTLING

//NSLog(@"Starting synchronous request %@",self);

#endif

[self setRunLoopMode:ASIHTTPRequestRunLoopMode];

[self setInProgress:YES];

if (![self isCancelled] && ![self complete]) {

[self main];

while (!complete) {

[[NSRunLoop currentRunLoop] runMode:[self runLoopMode] beforeDate:[NSDate distantFuture]];

}

}

[self setInProgress:NO];

}

- (void)start

{

[self setInProgress:YES];

[self performSelector:@selector(main) onThread:[[self class] threadForRequest:self] withObject:nil waitUntilDone:NO];

}

- (void)startAsynchronous

{

#if DEBUG_REQUEST_STATUS || DEBUG_THROTTLING

//NSLog(@"Starting asynchronous request %@",self);

#endif

[sharedQueue addOperation:self];

}

#pragma mark concurrency

- (BOOL)isConcurrent

{

return YES;

}

- (BOOL)isFinished

{

return finished;

}

- (BOOL)isExecuting {

return [self inProgress];

}

#pragma mark request logic

- (void)main

{

@try {

[[self cancelledLock] lock];

#if TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_4_0

if ([ASIHTTPRequest isMultitaskingSupported] && [self shouldContinueWhenAppEntersBackground]) {

backgroundTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{

// Synchronize the cleanup call on the main thread in case

// the task actually finishes at around the same time.

dispatch_async(dispatch_get_main_queue(), ^{

if (backgroundTask != UIBackgroundTaskInvalid)

{

[[UIApplication sharedApplication] endBackgroundTask:backgroundTask];

backgroundTask = UIBackgroundTaskInvalid;

[self cancel];

}

});

}];

}

#endif

// A HEAD request generated by an ASINetworkQueue may have set the error already. If so, we should not proceed.

if ([self error]) {

[self setComplete:YES];

[self markAsFinished];

return;

}

[self setComplete:NO];

[self setDidUseCachedResponse:NO];

if (![self url]) {

[self failWithError:ASIUnableToCreateRequestError];

return;

}

// Must call before we create the request so that the request method can be set if needs be

if (![self mainRequest]) {

[self buildPostBody];

}

if (![[self requestMethod] isEqualToString:@"GET"]) {

[self setDownloadCache:nil];

}

// If we're redirecting, we'll already have a CFHTTPMessageRef

if (request) {

CFRelease(request);

}

// Create a new HTTP request.

request = CFHTTPMessageCreateRequest(kCFAllocatorDefault, (CFStringRef)[self requestMethod], (CFURLRef)[self url], [self useHTTPVersionOne] ? kCFHTTPVersion1_0 : kCFHTTPVersion1_1);

if (!request) {

[self failWithError:ASIUnableToCreateRequestError];

return;

}

//If this is a HEAD request generated by an ASINetworkQueue, we need to let the main request generate its headers first so we can use them

if ([self mainRequest]) {

[[self mainRequest] buildRequestHeaders];

}

// Even if this is a HEAD request with a mainRequest, we still need to call to give subclasses a chance to add their own to HEAD requests (ASIS3Request does this)

[self buildRequestHeaders];

if ([self downloadCache]) {

// If this request should use the default policy, set its policy to the download cache's default policy

if (![self cachePolicy]) {

[self setCachePolicy:[[self downloadCache] defaultCachePolicy]];

}

// If have have cached data that is valid for this request, use that and stop

if ([[self downloadCache] canUseCachedDataForRequest:self]) {

[self useDataFromCache];

return;

}

// If cached data is stale, or we have been told to ask the server if it has been modified anyway, we need to add headers for a conditional GET

if ([self cachePolicy] & (ASIAskServerIfModifiedWhenStaleCachePolicy|ASIAskServerIfModifiedCachePolicy)) {

NSDictionary *cachedHeaders = [[self downloadCache] cachedResponseHeadersForURL:[self url]];

if (cachedHeaders) {

NSString *etag = [cachedHeaders objectForKey:@"Etag"];

if (etag) {

[[self requestHeaders] setObject:etag forKey:@"If-None-Match"];

}

NSString *lastModified = [cachedHeaders objectForKey:@"Last-Modified"];

if (lastModified) {

[[self requestHeaders] setObject:lastModified forKey:@"If-Modified-Since"];

}

}

}

}

[self applyAuthorizationHeader];

NSString *header;

for (header in [self requestHeaders]) {

CFHTTPMessageSetHeaderFieldValue(request, (CFStringRef)header, (CFStringRef)[[self requestHeaders] objectForKey:header]);

}

[self startRequest];

} @catch (NSException *exception) {

NSError *underlyingError = [NSError errorWithDomain:NetworkRequestErrorDomain code:ASIUnhandledExceptionError userInfo:[exception userInfo]];

[self failWithError:[NSError errorWithDomain:NetworkRequestErrorDomain code:ASIUnhandledExceptionError userInfo:[NSDictionary dictionaryWithObjectsAndKeys:[exception name],NSLocalizedDescriptionKey,[exception reason],NSLocalizedFailureReasonErrorKey,underlyingError,NSUnderlyingErrorKey,nil]]];

} @finally {

[[self cancelledLock] unlock];

}

}

- (void)applyAuthorizationHeader

{

// Do we want to send credentials before we are asked for them?

if (![self shouldPresentCredentialsBeforeChallenge]) {

return;

}

// First, see if we have any credentials we can use in the session store

NSDictionary *credentials = nil;

if ([self useSessionPersistence]) {

credentials = [self findSessionAuthenticationCredentials];

}

// Are any credentials set on this request that might be used for basic authentication?

if ([self username] && [self password] && ![self domain]) {

// If we have stored credentials, is this server asking for basic authentication? If we don't have credentials, we'll assume basic

if (!credentials || (CFStringRef)[credentials objectForKey:@"AuthenticationScheme"] == kCFHTTPAuthenticationSchemeBasic) {

[self addBasicAuthenticationHeaderWithUsername:[self username] andPassword:[self password]];

}

}

if (credentials && ![[self requestHeaders] objectForKey:@"Authorization"]) {

// When the Authentication key is set, the credentials were stored after an authentication challenge, so we can let CFNetwork apply them

// (credentials for Digest and NTLM will always be stored like this)

if ([credentials objectForKey:@"Authentication"]) {

// If we've already talked to this server and have valid credentials, let's apply them to the request

if (!CFHTTPMessageApplyCredentialDictionary(request, (CFHTTPAuthenticationRef)[credentials objectForKey:@"Authentication"], (CFDictionaryRef)[credentials objectForKey:@"Credentials"], NULL)) {

[[self class] removeAuthenticationCredentialsFromSessionStore:[credentials objectForKey:@"Credentials"]];

}

// If the Authentication key is not set, these credentials were stored after a username and password set on a previous request passed basic authentication

// When this happens, we'll need to create the Authorization header ourselves

} else {

NSDictionary *usernameAndPassword = [credentials objectForKey:@"Credentials"];

[self addBasicAuthenticationHeaderWithUsername:[usernameAndPassword objectForKey:(NSString *)kCFHTTPAuthenticationUsername] andPassword:[usernameAndPassword objectForKey:(NSString *)kCFHTTPAuthenticationPassword]];

}

}

if ([self useSessionPersistence]) {

credentials = [self findSessionProxyAuthenticationCredentials];

if (credentials) {

if (!CFHTTPMessageApplyCredentialDictionary(request, (CFHTTPAuthenticationRef)[credentials objectForKey:@"Authentication"], (CFDictionaryRef)[credentials objectForKey:@"Credentials"], NULL)) {

[[self class] removeProxyAuthenticationCredentialsFromSessionStore:[credentials objectForKey:@"Credentials"]];

}

}

}

}

- (void)applyCookieHeader

{

// Add cookies from the persistent (mac os global) store

if ([self useCookiePersistence]) {

NSArray *cookies = [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookiesForURL:[[self url] absoluteURL]];

if (cookies) {

[[self requestCookies] addObjectsFromArray:cookies];

}

}

// Apply request cookies

NSArray *cookies;

if ([self mainRequest]) {

cookies = [[self mainRequest] requestCookies];

} else {

cookies = [self requestCookies];

}

if ([cookies count] > 0) {

NSHTTPCookie *cookie;

NSString *cookieHeader = nil;

for (cookie in cookies) {

if (!cookieHeader) {

cookieHeader = [NSString stringWithFormat: @"%@=%@",[cookie name],[cookie value]];

} else {

cookieHeader = [NSString stringWithFormat: @"%@; %@=%@",cookieHeader,[cookie name],[cookie value]];

}

}

if (cookieHeader) {

[self addRequestHeader:@"Cookie" value:cookieHeader];

}

}

}

- (void)buildRequestHeaders