Refactor to fix lots of bugs, especially locking issues

@@ -50,6 +50,11 @@
 
 
 - (void)buildPostBody
 - (void)buildPostBody
 {
 {
+	if (!postData && ! fileData) {
+		[super buildPostBody];
+		return;
+	}	
+
 	NSMutableData *body = [[[NSMutableData alloc] init] autorelease];
 	NSMutableData *body = [[[NSMutableData alloc] init] autorelease];
 	
 	
 	// Set your own boundary string only if really obsessive. We don't bother to check if post data contains the boundary, since it's pretty unlikely that it does.
 	// Set your own boundary string only if really obsessive. We don't bother to check if post data contains the boundary, since it's pretty unlikely that it does.

@@ -10,6 +10,7 @@
 //  Portions are based on the ImageClient example from Apple:
 //  Portions are based on the ImageClient example from Apple:
 //  See: http://developer.apple.com/samplecode/ImageClient/listing37.html
 //  See: http://developer.apple.com/samplecode/ImageClient/listing37.html
 
 
+#import <Cocoa/Cocoa.h>
 
 
 @interface ASIHTTPRequest : NSOperation {
 @interface ASIHTTPRequest : NSOperation {
 	
 	
@@ -93,18 +94,18 @@
 	int responseStatusCode;
 	int responseStatusCode;
 	
 	
 	//Size of the response
 	//Size of the response
-	unsigned int contentLength;
+	unsigned long long contentLength;
 
 
 	//Size of the POST payload
 	//Size of the POST payload
-	unsigned int postLength;	
+	unsigned long long postLength;	
 	
 	
 	//The total amount of downloaded data
 	//The total amount of downloaded data
-	unsigned int totalBytesRead;
+	unsigned long long totalBytesRead;
 	
 	
 	//Last amount of data read (used for incrementing progress)
 	//Last amount of data read (used for incrementing progress)
-	unsigned int lastBytesRead;
+	unsigned long long lastBytesRead;
 	//Last amount of data sent (used for incrementing progress)
 	//Last amount of data sent (used for incrementing progress)
-	unsigned int lastBytesSent;
+	unsigned long long lastBytesSent;
 	
 	
 	//Realm for authentication when credentials are required
 	//Realm for authentication when credentials are required
 	NSString *authenticationRealm;
 	NSString *authenticationRealm;
@@ -112,6 +113,9 @@
 	//This lock will block the request until the delegate supplies authentication info
 	//This lock will block the request until the delegate supplies authentication info
 	NSConditionLock *authenticationLock;
 	NSConditionLock *authenticationLock;
 	
 	
+	//This lock prevents the operation from being cancelled at an inopportune moment
+	NSLock *cancelledLock;
+	
 	//Called on the delegate when the request completes successfully
 	//Called on the delegate when the request completes successfully
 	SEL didFinishSelector;
 	SEL didFinishSelector;
 	
 	
@@ -128,7 +132,7 @@
 	NSAutoreleasePool *pool;
 	NSAutoreleasePool *pool;
 	
 	
 	// Will be YES when a HEAD request will handle the content-length before this request starts
 	// Will be YES when a HEAD request will handle the content-length before this request starts
-	BOOL useCachedContentLength;
+	BOOL shouldResetProgressIndicators;
 	
 	
 	// Used by HEAD requests when showAccurateProgress is YES to preset the content-length for this request
 	// Used by HEAD requests when showAccurateProgress is YES to preset the content-length for this request
 	ASIHTTPRequest *mainRequest;
 	ASIHTTPRequest *mainRequest;
@@ -177,9 +181,9 @@
 
 
 // Called on main thread to update progress delegates
 // Called on main thread to update progress delegates
 - (void)updateProgressIndicators;
 - (void)updateProgressIndicators;
-- (void)resetUploadProgress:(NSNumber *)max;
+- (void)resetUploadProgress:(unsigned long long)value;
 - (void)updateUploadProgress;
 - (void)updateUploadProgress;
-- (void)resetDownloadProgress:(NSNumber *)max;
+- (void)resetDownloadProgress:(unsigned long long)value;
 - (void)updateDownloadProgress;
 - (void)updateDownloadProgress;
 
 
 // Called when authorisation is needed, as we only find out we don't have permission to something when the upload is complete
 // Called when authorisation is needed, as we only find out we don't have permission to something when the upload is complete
@@ -279,10 +283,10 @@
 @property (assign) NSTimeInterval timeOutSeconds;
 @property (assign) NSTimeInterval timeOutSeconds;
 @property (retain) NSString *requestMethod;
 @property (retain) NSString *requestMethod;
 @property (retain,setter=setPostBody:) NSData *postBody;
 @property (retain,setter=setPostBody:) NSData *postBody;
-@property (assign) unsigned int contentLength;
-@property (assign) unsigned int postLength;
-@property (assign) BOOL useCachedContentLength;
+@property (assign) unsigned long long contentLength;
+@property (assign) unsigned long long postLength;
+@property (assign) BOOL shouldResetProgressIndicators;
 @property (retain) ASIHTTPRequest *mainRequest;
 @property (retain) ASIHTTPRequest *mainRequest;
 @property (assign) BOOL showAccurateProgress;
 @property (assign) BOOL showAccurateProgress;
-@property (assign,readonly) unsigned int totalBytesRead;
+@property (assign,readonly) unsigned long long totalBytesRead;
 @end
 @end

@@ -33,7 +33,7 @@ static void ReadStreamClientCallBack(CFReadStreamRef readStream, CFStreamEventTy
 }
 }
 
 
 // This lock prevents the operation from being cancelled while it is trying to update the progress, and vice versa
 // This lock prevents the operation from being cancelled while it is trying to update the progress, and vice versa
-static NSLock *progressLock;
+static NSRecursiveLock *progressLock;
 
 
 @implementation ASIHTTPRequest
 @implementation ASIHTTPRequest
 
 
@@ -41,9 +41,9 @@ static NSLock *progressLock;
 
 
 #pragma mark init / dealloc
 #pragma mark init / dealloc
 
 
-- (void)initialize
++ (void)initialize
 {
 {
-	progressLock = [[NSLock alloc] init];
+	progressLock = [[NSRecursiveLock alloc] init];
 }
 }
 
 
 - (id)initWithURL:(NSURL *)newURL
 - (id)initWithURL:(NSURL *)newURL
@@ -52,7 +52,7 @@ static NSLock *progressLock;
 	[self setRequestMethod:@"GET"];
 	[self setRequestMethod:@"GET"];
 	lastBytesSent = 0;
 	lastBytesSent = 0;
 	showAccurateProgress = YES;
 	showAccurateProgress = YES;
-	useCachedContentLength = NO;
+	shouldResetProgressIndicators = YES;
 	updatedProgress = NO;
 	updatedProgress = NO;
 	mainRequest = nil;
 	mainRequest = nil;
 	username = nil;
 	username = nil;
@@ -74,6 +74,7 @@ static NSLock *progressLock;
 	didFailSelector = @selector(requestFailed:);
 	didFailSelector = @selector(requestFailed:);
 	delegate = nil;
 	delegate = nil;
 	url = [newURL retain];
 	url = [newURL retain];
+	cancelledLock = [[NSLock alloc] init];
 	return self;
 	return self;
 }
 }
 
 
@@ -105,6 +106,7 @@ static NSLock *progressLock;
 	[receivedData release];
 	[receivedData release];
 	[responseHeaders release];
 	[responseHeaders release];
 	[requestMethod release];
 	[requestMethod release];
+	[cancelledLock release];
 	[super dealloc];
 	[super dealloc];
 }
 }
 
 
@@ -143,17 +145,15 @@ static NSLock *progressLock;
 	return complete;
 	return complete;
 }
 }
 
 
+
 - (void)cancel
 - (void)cancel
 {
 {
-	[progressLock lock];
+	[self failWithProblem:@"The request was cancelled"];
+	[self cancelLoad];
+	complete = YES;
 	[super cancel];
 	[super cancel];
-	[progressLock unlock];
 }
 }
 
 
-- (int)totalBytesRead
-{
-	return totalBytesRead;
-}
 
 
 // Call this method to get the recieved data as an NSString. Don't use for Binary data!
 // Call this method to get the recieved data as an NSString. Don't use for Binary data!
 - (NSString *)dataString
 - (NSString *)dataString
@@ -226,8 +226,8 @@ static NSLock *progressLock;
 		CFHTTPMessageSetHeaderFieldValue(request, (CFStringRef)header, (CFStringRef)[requestHeaders objectForKey:header]);
 		CFHTTPMessageSetHeaderFieldValue(request, (CFStringRef)header, (CFStringRef)[requestHeaders objectForKey:header]);
 	}
 	}
 	
 	
-
-
+	//NSData *d = (NSData *)CFHTTPMessageCopySerializedMessage(request);
+	//NSLog(@"%@",[[[NSString alloc] initWithBytes:[d bytes] length:[d length] encoding:NSUTF8StringEncoding] autorelease]);
 
 
 	
 	
 	// If this is a post request and we have data to send, add it to the request
 	// If this is a post request and we have data to send, add it to the request
@@ -243,6 +243,13 @@ static NSLock *progressLock;
 // Start the request
 // Start the request
 - (void)loadRequest
 - (void)loadRequest
 {
 {
+	[cancelledLock lock];
+	
+	if ([self isCancelled]) {
+		[cancelledLock unlock];
+		return;
+	}
+	
 	CFRunLoopAddCommonMode(CFRunLoopGetCurrent(),ASIHTTPRequestRunMode);
 	CFRunLoopAddCommonMode(CFRunLoopGetCurrent(),ASIHTTPRequestRunMode);
 	
 	
 	[authenticationLock release];
 	[authenticationLock release];
@@ -258,7 +265,7 @@ static NSLock *progressLock;
 	}
 	}
 	
 	
 	lastBytesSent = 0;
 	lastBytesSent = 0;
-	if (!useCachedContentLength) {
+	if (shouldResetProgressIndicators) {
 		contentLength = 0;
 		contentLength = 0;
 	}
 	}
 	[self setResponseHeaders:nil];
 	[self setResponseHeaders:nil];
@@ -267,6 +274,7 @@ static NSLock *progressLock;
     // Create the stream for the request.
     // Create the stream for the request.
     readStream = CFReadStreamCreateForStreamedHTTPRequest(kCFAllocatorDefault, request,readStream);
     readStream = CFReadStreamCreateForStreamedHTTPRequest(kCFAllocatorDefault, request,readStream);
     if (!readStream) {
     if (!readStream) {
+		[cancelledLock unlock];
 		[self failWithProblem:@"Unable to create read stream"];
 		[self failWithProblem:@"Unable to create read stream"];
         return;
         return;
     }
     }
@@ -276,6 +284,7 @@ static NSLock *progressLock;
     if (!CFReadStreamSetClient(readStream, kNetworkEvents, ReadStreamClientCallBack, &ctxt)) {
     if (!CFReadStreamSetClient(readStream, kNetworkEvents, ReadStreamClientCallBack, &ctxt)) {
         CFRelease(readStream);
         CFRelease(readStream);
         readStream = NULL;
         readStream = NULL;
+		[cancelledLock unlock];
 		[self failWithProblem:@"Unable to setup read stream"];
 		[self failWithProblem:@"Unable to setup read stream"];
         return;
         return;
     }
     }
@@ -289,14 +298,23 @@ static NSLock *progressLock;
         CFReadStreamUnscheduleFromRunLoop(readStream, CFRunLoopGetCurrent(), ASIHTTPRequestRunMode);
         CFReadStreamUnscheduleFromRunLoop(readStream, CFRunLoopGetCurrent(), ASIHTTPRequestRunMode);
         CFRelease(readStream);
         CFRelease(readStream);
         readStream = NULL;
         readStream = NULL;
+		[cancelledLock unlock];
 		[self failWithProblem:@"Unable to start http connection"];
 		[self failWithProblem:@"Unable to start http connection"];
         return;
         return;
     }
     }
+	[cancelledLock unlock];
 	
 	
-	if (uploadProgressDelegate) {
-		[self performSelectorOnMainThread:@selector(resetUploadProgress:) withObject:[NSNumber numberWithDouble:postLength] waitUntilDone:YES];
+	
+	if (uploadProgressDelegate && shouldResetProgressIndicators) {
+		double amount = 1;
+		if (showAccurateProgress) {
+			amount = postLength;
+		}
+		[self resetUploadProgress:amount];
 	}
 	}
 
 
+
+	
 	// Record when the request started, so we can timeout if nothing happens
 	// Record when the request started, so we can timeout if nothing happens
 	[self setLastActivityTime:[NSDate date]];
 	[self setLastActivityTime:[NSDate date]];
 	
 	
@@ -307,9 +325,11 @@ static NSLock *progressLock;
 		[pool release];
 		[pool release];
 		pool = [[NSAutoreleasePool alloc] init];
 		pool = [[NSAutoreleasePool alloc] init];
 		
 		
+		NSDate *now = [NSDate new];
+		
 		// See if we need to timeout
 		// See if we need to timeout
 		if (lastActivityTime && timeOutSeconds > 0) {
 		if (lastActivityTime && timeOutSeconds > 0) {
-			if ([[NSDate date] timeIntervalSinceDate:lastActivityTime] > timeOutSeconds) {
+			if ([now timeIntervalSinceDate:lastActivityTime] > timeOutSeconds) {
 				[self failWithProblem:@"Request timed out"];
 				[self failWithProblem:@"Request timed out"];
 				[self cancelLoad];
 				[self cancelLoad];
 				complete = YES;
 				complete = YES;
@@ -324,10 +344,12 @@ static NSLock *progressLock;
 			complete = YES;
 			complete = YES;
 			break;
 			break;
 		}
 		}
-		[self performSelectorOnMainThread:@selector(updateProgressIndicators) withObject:nil waitUntilDone:YES];
+		
+		[self updateProgressIndicators];
 		
 		
 		//This thread should wait for 1/4 second for the stream to do something. We'll stop early if it does.
 		//This thread should wait for 1/4 second for the stream to do something. We'll stop early if it does.
 		CFRunLoopRunInMode(ASIHTTPRequestRunMode,0.25,YES);
 		CFRunLoopRunInMode(ASIHTTPRequestRunMode,0.25,YES);
+		[now release];
 	}
 	}
 	
 	
 	[pool release];
 	[pool release];
@@ -337,6 +359,7 @@ static NSLock *progressLock;
 // Cancel loading and clean up
 // Cancel loading and clean up
 - (void)cancelLoad
 - (void)cancelLoad
 {
 {
+	[cancelledLock lock];
     if (readStream) {
     if (readStream) {
         CFReadStreamClose(readStream);
         CFReadStreamClose(readStream);
         CFReadStreamSetClient(readStream, kCFStreamEventNone, NULL, NULL);
         CFReadStreamSetClient(readStream, kCFStreamEventNone, NULL, NULL);
@@ -355,6 +378,7 @@ static NSLock *progressLock;
 	}
 	}
 	
 	
 	[self setResponseHeaders:nil];
 	[self setResponseHeaders:nil];
+	[cancelledLock unlock];
 }
 }
 
 
 
 
@@ -364,9 +388,9 @@ static NSLock *progressLock;
 
 
 - (void)updateProgressIndicators
 - (void)updateProgressIndicators
 {
 {
+	
 	//Only update progress if this isn't a HEAD request used to preset the content-length
 	//Only update progress if this isn't a HEAD request used to preset the content-length
 	if (!mainRequest) {
 	if (!mainRequest) {
-		
 		if (showAccurateProgress || (complete && !updatedProgress)) {
 		if (showAccurateProgress || (complete && !updatedProgress)) {
 			[self updateUploadProgress];
 			[self updateUploadProgress];
 			[self updateDownloadProgress];
 			[self updateDownloadProgress];
@@ -411,17 +435,11 @@ static NSLock *progressLock;
 }
 }
 
 
 
 
-- (void)resetUploadProgress:(NSNumber *)max
+- (void)resetUploadProgress:(unsigned long long)value
 {
 {
 	[progressLock lock];
 	[progressLock lock];
-	if ([self isCancelled]) {
-		[progressLock unlock];
-		return;
-	}	
-	
 	//We're using a progress queue or compatible controller to handle progress
 	//We're using a progress queue or compatible controller to handle progress
 	if ([uploadProgressDelegate respondsToSelector:@selector(incrementUploadSizeBy:)]) {
 	if ([uploadProgressDelegate respondsToSelector:@selector(incrementUploadSizeBy:)]) {
-		int value = [max intValue];
 		SEL selector = @selector(incrementUploadSizeBy:);
 		SEL selector = @selector(incrementUploadSizeBy:);
 		NSMethodSignature *signature = [[uploadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 		NSMethodSignature *signature = [[uploadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
@@ -437,20 +455,21 @@ static NSLock *progressLock;
 
 
 - (void)updateUploadProgress
 - (void)updateUploadProgress
 {
 {
-	[progressLock lock];
+	[cancelledLock lock];
 	if ([self isCancelled]) {
 	if ([self isCancelled]) {
-		[progressLock unlock];
 		return;
 		return;
 	}
 	}
-	
+	unsigned long long byteCount = [[(NSNumber *)CFReadStreamCopyProperty (readStream, kCFStreamPropertyHTTPRequestBytesWrittenCount) autorelease] unsignedLongLongValue];
+	[cancelledLock unlock];
+	if (byteCount > lastBytesSent) {
 		[self setLastActivityTime:[NSDate date]];		
 		[self setLastActivityTime:[NSDate date]];		
+	}
 	
 	
-	unsigned int byteCount = [[(NSNumber *)CFReadStreamCopyProperty (readStream, kCFStreamPropertyHTTPRequestBytesWrittenCount) autorelease] unsignedIntValue];
 	if (uploadProgressDelegate) {
 	if (uploadProgressDelegate) {
 		
 		
 		//We're using a progress queue or compatible controller to handle progress
 		//We're using a progress queue or compatible controller to handle progress
 		if ([uploadProgressDelegate respondsToSelector:@selector(incrementUploadProgressBy:)]) {
 		if ([uploadProgressDelegate respondsToSelector:@selector(incrementUploadProgressBy:)]) {
-			int value = 0;
+			unsigned long long value = 0;
 			if (showAccurateProgress) {
 			if (showAccurateProgress) {
 				value = byteCount-lastBytesSent;
 				value = byteCount-lastBytesSent;
 			} else {
 			} else {
@@ -473,22 +492,15 @@ static NSLock *progressLock;
 		
 		
 	}
 	}
 	lastBytesSent = byteCount;
 	lastBytesSent = byteCount;
-	[progressLock unlock];
+
 }
 }
 
 
 
 
-- (void)resetDownloadProgress:(NSNumber *)max
+- (void)resetDownloadProgress:(unsigned long long)value
 {
 {
 	[progressLock lock];	
 	[progressLock lock];	
-	if ([self isCancelled]) {
-		[progressLock unlock];
-		return;
-	}	
-	
-	
 	//We're using a progress queue or compatible controller to handle progress
 	//We're using a progress queue or compatible controller to handle progress
 	if ([downloadProgressDelegate respondsToSelector:@selector(incrementDownloadSizeBy:)]) {
 	if ([downloadProgressDelegate respondsToSelector:@selector(incrementDownloadSizeBy:)]) {
-		int value = [max intValue];
 		SEL selector = @selector(incrementDownloadSizeBy:);
 		SEL selector = @selector(incrementDownloadSizeBy:);
 		NSMethodSignature *signature = [[downloadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 		NSMethodSignature *signature = [[downloadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
@@ -496,6 +508,7 @@ static NSLock *progressLock;
 		[invocation setSelector:selector];
 		[invocation setSelector:selector];
 		[invocation setArgument:&value atIndex:2];
 		[invocation setArgument:&value atIndex:2];
 		[invocation invoke];
 		[invocation invoke];
+
 	} else {
 	} else {
 		[ASIHTTPRequest setProgress:0 forProgressIndicator:downloadProgressDelegate];
 		[ASIHTTPRequest setProgress:0 forProgressIndicator:downloadProgressDelegate];
 	}
 	}
@@ -504,30 +517,33 @@ static NSLock *progressLock;
 
 
 - (void)updateDownloadProgress
 - (void)updateDownloadProgress
 {
 {
-	[progressLock lock];
-	if ([self isCancelled]) {
-		[progressLock unlock];
-		return;
-	}	
+	unsigned long long bytesReadSoFar = totalBytesRead;
+	
+	//We won't update download progress until we've examined the headers, since we might need to authenticate
+	if (responseHeaders) {
 		
 		
+		if (bytesReadSoFar > lastBytesRead) {
 			[self setLastActivityTime:[NSDate date]];
 			[self setLastActivityTime:[NSDate date]];
+		}
+		
+		if (downloadProgressDelegate) {
 		
 		
-	//We won't update downlaod progress until we've examined the headers, since we might need to authenticate
-	if (downloadProgressDelegate && responseHeaders) {
 
 
 			//We're using a progress queue or compatible controller to handle progress
 			//We're using a progress queue or compatible controller to handle progress
 			if ([downloadProgressDelegate respondsToSelector:@selector(incrementDownloadProgressBy:)]) {
 			if ([downloadProgressDelegate respondsToSelector:@selector(incrementDownloadProgressBy:)]) {
 				
 				
 				NSAutoreleasePool *thePool = [[NSAutoreleasePool alloc] init];
 				NSAutoreleasePool *thePool = [[NSAutoreleasePool alloc] init];
 				
 				
-			int value = 0;
+				unsigned long long value = 0;
 				if (showAccurateProgress) {
 				if (showAccurateProgress) {
-				value = totalBytesRead-lastBytesRead;
+					value = bytesReadSoFar-lastBytesRead;
 				} else {
 				} else {
 					value = 1;
 					value = 1;
 					updatedProgress = YES;
 					updatedProgress = YES;
 				}
 				}
 				
 				
+
+				
 				SEL selector = @selector(incrementDownloadProgressBy:);
 				SEL selector = @selector(incrementDownloadProgressBy:);
 				NSMethodSignature *signature = [[downloadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 				NSMethodSignature *signature = [[downloadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 				NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 				NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
@@ -540,26 +556,22 @@ static NSLock *progressLock;
 				
 				
 				//We aren't using a queue, we should just set progress of the indicator to 0
 				//We aren't using a queue, we should just set progress of the indicator to 0
 			} else if (contentLength > 0)  {
 			} else if (contentLength > 0)  {
-			[ASIHTTPRequest setProgress:(double)(totalBytesRead/contentLength) forProgressIndicator:downloadProgressDelegate];
+				[ASIHTTPRequest setProgress:(double)(bytesReadSoFar/contentLength) forProgressIndicator:downloadProgressDelegate];
+			}
 		}
 		}
 		
 		
-		lastBytesRead = totalBytesRead;
+		lastBytesRead = bytesReadSoFar;
 	}
 	}
-	[progressLock unlock];
+
 }
 }
 
 
 -(void)removeUploadProgressSoFar
 -(void)removeUploadProgressSoFar
 {
 {
-	[progressLock lock];
-	if ([self isCancelled]) {
-		[progressLock unlock];
-		return;
-	}
 	
 	
 	//We're using a progress queue or compatible controller to handle progress
 	//We're using a progress queue or compatible controller to handle progress
-	if ([uploadProgressDelegate respondsToSelector:@selector(incrementUploadProgressBy:)]) {
-		int value = 0-lastBytesSent;
-		SEL selector = @selector(incrementUploadProgressBy:);
+	if ([uploadProgressDelegate respondsToSelector:@selector(decrementUploadProgressBy:)]) {
+		unsigned long long value = 0-lastBytesSent;
+		SEL selector = @selector(decrementUploadProgressBy:);
 		NSMethodSignature *signature = [[uploadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 		NSMethodSignature *signature = [[uploadProgressDelegate class] instanceMethodSignatureForSelector:selector];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 		[invocation setTarget:uploadProgressDelegate];
 		[invocation setTarget:uploadProgressDelegate];
@@ -571,7 +583,6 @@ static NSLock *progressLock;
 	} else {
 	} else {
 		[ASIHTTPRequest setProgress:0 forProgressIndicator:uploadProgressDelegate];
 		[ASIHTTPRequest setProgress:0 forProgressIndicator:uploadProgressDelegate];
 	}
 	}
-	[progressLock unlock];
 }
 }
 
 
 
 
@@ -579,8 +590,9 @@ static NSLock *progressLock;
 {
 {
 	
 	
 	SEL selector;
 	SEL selector;
+	[progressLock lock];
 	
 	
-	//Cocoa Touch: UIProgressView
+	// Cocoa Touch: UIProgressView
 	if ([indicator respondsToSelector:@selector(setProgress:)]) {
 	if ([indicator respondsToSelector:@selector(setProgress:)]) {
 		selector = @selector(setProgress:);
 		selector = @selector(setProgress:);
 		NSMethodSignature *signature = [[indicator class] instanceMethodSignatureForSelector:selector];
 		NSMethodSignature *signature = [[indicator class] instanceMethodSignatureForSelector:selector];
@@ -590,26 +602,28 @@ static NSLock *progressLock;
 		[invocation setArgument:&progressFloat atIndex:2];
 		[invocation setArgument:&progressFloat atIndex:2];
 		[invocation invokeWithTarget:indicator];
 		[invocation invokeWithTarget:indicator];
 		
 		
+		//If we're running in the main thread, update the progress straight away. Otherwise, it's not that urgent
+		[invocation performSelectorOnMainThread:@selector(invokeWithTarget:) withObject:indicator waitUntilDone:[NSThread isMainThread]];
 		
 		
-		//Cocoa: NSProgressIndicator
+		
+	// Cocoa: NSProgressIndicator
 	} else if ([indicator respondsToSelector:@selector(setDoubleValue:)]) {
 	} else if ([indicator respondsToSelector:@selector(setDoubleValue:)]) {
 		selector = @selector(setDoubleValue:);
 		selector = @selector(setDoubleValue:);
 		NSMethodSignature *signature = [[indicator class] instanceMethodSignatureForSelector:selector];
 		NSMethodSignature *signature = [[indicator class] instanceMethodSignatureForSelector:selector];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 		NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
 		[invocation setSelector:selector];
 		[invocation setSelector:selector];
 		[invocation setArgument:&progress atIndex:2];
 		[invocation setArgument:&progress atIndex:2];
-		[invocation invokeWithTarget:indicator];
 		
 		
-		//Progress indicator is some other thing that we can't handle
-	} else {
-		return;
+		//If we're running in the main thread, update the progress straight away. Otherwise, it's not that urgent
+		[invocation performSelectorOnMainThread:@selector(invokeWithTarget:) withObject:indicator waitUntilDone:[NSThread isMainThread]];
+		
 	}
 	}
+	[progressLock unlock];
 }
 }
 
 
 
 
 #pragma mark handling request complete / failure
 #pragma mark handling request complete / failure
 
 
-
 // Subclasses can override this method to process the result in the same thread
 // Subclasses can override this method to process the result in the same thread
 // If not overidden, it will call the didFinishSelector on the delegate, if one has been setup
 // If not overidden, it will call the didFinishSelector on the delegate, if one has been setup
 - (void)requestFinished
 - (void)requestFinished
@@ -656,18 +670,15 @@ static NSLock *progressLock;
 		//We won't reset the download progress delegate if we got an authentication challenge
 		//We won't reset the download progress delegate if we got an authentication challenge
 		if (!isAuthenticationChallenge) {
 		if (!isAuthenticationChallenge) {
 
 
-			//Only check the content length if we haven't already got one (may have been set by an ASINetworkQueue using a previous HEAD request)
-			if (!useCachedContentLength) {
 			//See if we got a Content-length header
 			//See if we got a Content-length header
 			NSString *cLength = [responseHeaders valueForKey:@"Content-Length"];
 			NSString *cLength = [responseHeaders valueForKey:@"Content-Length"];
 			if (cLength) {
 			if (cLength) {
-					contentLength = CFStringGetDoubleValue((CFStringRef)cLength);
+				contentLength = CFStringGetIntValue((CFStringRef)cLength);
 				if (mainRequest) {
 				if (mainRequest) {
 					[mainRequest setContentLength:contentLength];
 					[mainRequest setContentLength:contentLength];
 				}
 				}
-					if (downloadProgressDelegate && showAccurateProgress) {
-						[self performSelectorOnMainThread:@selector(resetDownloadProgress:) withObject:[NSNumber numberWithDouble:contentLength] waitUntilDone:YES];
-					}
+				if (downloadProgressDelegate && showAccurateProgress && shouldResetProgressIndicators) {
+					[self resetDownloadProgress:contentLength];
 				}
 				}
 			}
 			}
 			
 			
@@ -940,12 +951,15 @@ static NSLock *progressLock;
 			[receivedData appendBytes:buffer length:bytesRead];
 			[receivedData appendBytes:buffer length:bytesRead];
 		}
 		}
     }
     }
+
+
 }
 }
 
 
 
 
 - (void)handleStreamComplete
 - (void)handleStreamComplete
 {
 {
 
 
+	
 	//Try to read the headers (if this is a HEAD request handleBytesAvailable available may not be called)
 	//Try to read the headers (if this is a HEAD request handleBytesAvailable available may not be called)
 	if (!responseHeaders) {
 	if (!responseHeaders) {
 		if ([self readResponseHeadersReturningAuthenticationFailure]) {
 		if ([self readResponseHeadersReturningAuthenticationFailure]) {
@@ -953,10 +967,10 @@ static NSLock *progressLock;
 			return;
 			return;
 		}
 		}
 	}
 	}
-
-	
+	[progressLock lock];	
 	complete = YES;
 	complete = YES;
 	[self updateProgressIndicators];	
 	[self updateProgressIndicators];	
+
     if (readStream) {
     if (readStream) {
         CFReadStreamClose(readStream);
         CFReadStreamClose(readStream);
         CFReadStreamSetClient(readStream, kCFStreamEventNone, NULL, NULL);
         CFReadStreamSetClient(readStream, kCFStreamEventNone, NULL, NULL);
@@ -969,8 +983,9 @@ static NSLock *progressLock;
 	if (downloadDestinationPath) {
 	if (downloadDestinationPath) {
 		[outputStream close];
 		[outputStream close];
 	}
 	}
-
+	[progressLock unlock];
 	[self requestFinished];
 	[self requestFinished];
+
 }
 }
 
 
 
 
@@ -1101,7 +1116,9 @@ static NSLock *progressLock;
 @synthesize postBody;
 @synthesize postBody;
 @synthesize contentLength;
 @synthesize contentLength;
 @synthesize postLength;
 @synthesize postLength;
-@synthesize useCachedContentLength;
+@synthesize shouldResetProgressIndicators;
 @synthesize mainRequest;
 @synthesize mainRequest;
+@synthesize totalBytesRead;
 @synthesize showAccurateProgress;
 @synthesize showAccurateProgress;
+@synthesize totalBytesRead;
 @end
 @end

@@ -109,8 +109,9 @@
 	ASIHTTPRequest *request = [[[ASIHTTPRequest alloc] initWithURL:url] autorelease];
 	ASIHTTPRequest *request = [[[ASIHTTPRequest alloc] initWithURL:url] autorelease];
 	[request setDownloadProgressDelegate:self];
 	[request setDownloadProgressDelegate:self];
 	[request start];
 	[request start];
+	
 	BOOL success = (progress == 1);
 	BOOL success = (progress == 1);
-	STAssertTrue(success,@"Failed to properly increment download progress");	
+	STAssertTrue(success,@"Failed to properly increment download progress %f != 1.0",progress);	
 }
 }
 
 
 
 
@@ -121,8 +122,9 @@
 	[request setPostBody:[NSMutableData dataWithLength:1024*32]];
 	[request setPostBody:[NSMutableData dataWithLength:1024*32]];
 	[request setUploadProgressDelegate:self];
 	[request setUploadProgressDelegate:self];
 	[request start];
 	[request start];
+	
 	BOOL success = (progress == 1);
 	BOOL success = (progress == 1);
-	STAssertTrue(success,@"Failed to properly increment upload progress");	
+	STAssertTrue(success,@"Failed to properly increment upload progress %f != 1.0",progress);	
 }
 }
 
 
 
 

@@ -6,7 +6,7 @@
 //  Copyright 2008 All-Seeing Interactive. All rights reserved.
 //  Copyright 2008 All-Seeing Interactive. All rights reserved.
 //
 //
 
 
-
+#import <Cocoa/Cocoa.h>
 
 
 @interface ASINetworkQueue : NSOperationQueue {
 @interface ASINetworkQueue : NSOperationQueue {
 	
 	
@@ -26,19 +26,19 @@
 	id uploadProgressDelegate;
 	id uploadProgressDelegate;
 	
 	
 	// Total amount uploaded so far for all requests in this queue
 	// Total amount uploaded so far for all requests in this queue
-	unsigned int uploadProgressBytes;
+	unsigned long long uploadProgressBytes;
 	
 	
 	// Total amount to be uploaded for all requests in this queue - requests add to this figure as they work out how much data they have to transmit
 	// Total amount to be uploaded for all requests in this queue - requests add to this figure as they work out how much data they have to transmit
-	unsigned int uploadProgressTotalBytes;
+	unsigned long long uploadProgressTotalBytes;
 
 
 	// Download progress indicator, probably an NSProgressIndicator or UIProgressView
 	// Download progress indicator, probably an NSProgressIndicator or UIProgressView
 	id downloadProgressDelegate;
 	id downloadProgressDelegate;
 	
 	
 	// Total amount downloaded so far for all requests in this queue
 	// Total amount downloaded so far for all requests in this queue
-	unsigned int downloadProgressBytes;
+	unsigned long long downloadProgressBytes;
 	
 	
 	// Total amount to be downloaded for all requests in this queue - requests add to this figure as they receive Content-Length headers
 	// Total amount to be downloaded for all requests in this queue - requests add to this figure as they receive Content-Length headers
-	unsigned int downloadProgressTotalBytes;
+	unsigned long long downloadProgressTotalBytes;
 	
 	
 	// When YES, the queue will cancel all requests when a request fails. Default is YES
 	// When YES, the queue will cancel all requests when a request fails. Default is YES
 	BOOL shouldCancelAllRequestsOnFailure;
 	BOOL shouldCancelAllRequestsOnFailure;
@@ -61,16 +61,19 @@
 - (void)addHEADOperation:(NSOperation *)operation;
 - (void)addHEADOperation:(NSOperation *)operation;
 
 
 // Called at the start of a request to add on the size of this upload to the total
 // Called at the start of a request to add on the size of this upload to the total
-- (void)incrementUploadSizeBy:(int)bytes;
+- (void)incrementUploadSizeBy:(unsigned long long)bytes;
 
 
 // Called during a request when data is written to the upload stream to increment the progress indicator
 // Called during a request when data is written to the upload stream to increment the progress indicator
-- (void)incrementUploadProgressBy:(int)bytes;
+- (void)incrementUploadProgressBy:(unsigned long long)bytes;
 
 
 // Called at the start of a request to add on the size of this download to the total
 // Called at the start of a request to add on the size of this download to the total
-- (void)incrementDownloadSizeBy:(int)bytes;
+- (void)incrementDownloadSizeBy:(unsigned long long)bytes;
 
 
 // Called during a request when data is received to increment the progress indicator
 // Called during a request when data is received to increment the progress indicator
-- (void)incrementDownloadProgressBy:(int)bytes;
+- (void)incrementDownloadProgressBy:(unsigned long long)bytes;
+
+// Called during a request when authorisation fails to cancel any progress so far
+- (void)decrementUploadProgressBy:(unsigned long long)bytes;
 
 
 // All ASINetworkQueues are paused when created so that total size can be calculated before the queue starts
 // All ASINetworkQueues are paused when created so that total size can be calculated before the queue starts
 // This method will start the queue
 // This method will start the queue

@@ -34,6 +34,7 @@
 	
 	
 	showAccurateProgress = NO;
 	showAccurateProgress = NO;
 	
 	
+	[self setMaxConcurrentOperationCount:4];
 	[self setSuspended:YES];
 	[self setSuspended:YES];
 	
 	
 	return self;
 	return self;
@@ -59,9 +60,6 @@
 	uploadProgressTotalBytes = 0;
 	uploadProgressTotalBytes = 0;
 	downloadProgressBytes = 0;
 	downloadProgressBytes = 0;
 	downloadProgressTotalBytes = 0;
 	downloadProgressTotalBytes = 0;
-	[self setUploadProgressDelegate:nil];
-	[self setDownloadProgressDelegate:nil];
-	[self setDelegate:nil];
 	[super cancelAllOperations];
 	[super cancelAllOperations];
 }
 }
 
 
@@ -103,6 +101,8 @@
 	if ([operation isKindOfClass:[ASIHTTPRequest class]]) {
 	if ([operation isKindOfClass:[ASIHTTPRequest class]]) {
 		
 		
 		ASIHTTPRequest *request = (ASIHTTPRequest *)operation;
 		ASIHTTPRequest *request = (ASIHTTPRequest *)operation;
+		[request setRequestMethod:@"HEAD"];
+		[request setQueuePriority:10];
 		[request setShowAccurateProgress:YES];
 		[request setShowAccurateProgress:YES];
 		if (uploadProgressDelegate) {
 		if (uploadProgressDelegate) {
 			[request setUploadProgressDelegate:self];
 			[request setUploadProgressDelegate:self];
@@ -133,12 +133,11 @@
 			//If this is a GET request and we want accurate progress, perform a HEAD request first to get the content-length
 			//If this is a GET request and we want accurate progress, perform a HEAD request first to get the content-length
 			if ([[request requestMethod] isEqualToString:@"GET"]) {
 			if ([[request requestMethod] isEqualToString:@"GET"]) {
 				ASIHTTPRequest *HEADRequest = [[[ASIHTTPRequest alloc] initWithURL:[request url]] autorelease];
 				ASIHTTPRequest *HEADRequest = [[[ASIHTTPRequest alloc] initWithURL:[request url]] autorelease];
-				[HEADRequest setRequestMethod:@"HEAD"];
-				[HEADRequest setQueuePriority:10];
 				[HEADRequest setMainRequest:request];
 				[HEADRequest setMainRequest:request];
 				[self addHEADOperation:HEADRequest];
 				[self addHEADOperation:HEADRequest];
 				
 				
-				[request setUseCachedContentLength:YES];
+				//Tell the request not to reset the progress indicator when it gets a content-length, as we will get the length from the HEAD request
+				[request setShouldResetProgressIndicators:NO];
 				[request addDependency:HEADRequest];
 				[request addDependency:HEADRequest];
 			
 			
 			//If we want to track uploading for this request accurately, we need to add the size of the post content to the total
 			//If we want to track uploading for this request accurately, we need to add the size of the post content to the total
@@ -150,6 +149,9 @@
 		[request setShowAccurateProgress:showAccurateProgress];
 		[request setShowAccurateProgress:showAccurateProgress];
 		
 		
 		if (uploadProgressDelegate) {
 		if (uploadProgressDelegate) {
+			
+			//For uploads requests, we always work out the total upload size before the queue starts, so we tell the request not to reset the progress indicator when starting each request
+			[request setShouldResetProgressIndicators:NO];
 			[request setUploadProgressDelegate:self];
 			[request setUploadProgressDelegate:self];
 		} else {
 		} else {
 			[request setUploadProgressDelegate:NULL];
 			[request setUploadProgressDelegate:NULL];
@@ -173,7 +175,7 @@
 	if (requestDidFailSelector) {
 	if (requestDidFailSelector) {
 		[delegate performSelector:requestDidFailSelector withObject:request];
 		[delegate performSelector:requestDidFailSelector withObject:request];
 	}
 	}
-	if (shouldCancelAllRequestsOnFailure) {
+	if (shouldCancelAllRequestsOnFailure && requestsCount > 0) {
 		[self cancelAllOperations];
 		[self cancelAllOperations];
 	}
 	}
 }
 }
@@ -191,7 +193,7 @@
 	}
 	}
 }
 }
 
 
-- (void)incrementUploadSizeBy:(int)bytes
+- (void)incrementUploadSizeBy:(unsigned long long)bytes
 {
 {
 	if (!uploadProgressDelegate) {
 	if (!uploadProgressDelegate) {
 		return;
 		return;
@@ -200,7 +202,19 @@
 	[self incrementUploadProgressBy:0];
 	[self incrementUploadProgressBy:0];
 }
 }
 
 
-- (void)incrementUploadProgressBy:(int)bytes
+- (void)decrementUploadProgressBy:(unsigned long long)bytes
+{
+	if (!uploadProgressDelegate || uploadProgressTotalBytes == 0) {
+		return;
+	}
+	uploadProgressBytes -= bytes;
+	
+	double progress = (uploadProgressBytes*1.0)/(uploadProgressTotalBytes*1.0);
+	[ASIHTTPRequest setProgress:progress forProgressIndicator:uploadProgressDelegate];
+}
+
+
+- (void)incrementUploadProgressBy:(unsigned long long)bytes
 {
 {
 	if (!uploadProgressDelegate || uploadProgressTotalBytes == 0) {
 	if (!uploadProgressDelegate || uploadProgressTotalBytes == 0) {
 		return;
 		return;
@@ -209,24 +223,26 @@
 	
 	
 	double progress = (uploadProgressBytes*1.0)/(uploadProgressTotalBytes*1.0);
 	double progress = (uploadProgressBytes*1.0)/(uploadProgressTotalBytes*1.0);
 	[ASIHTTPRequest setProgress:progress forProgressIndicator:uploadProgressDelegate];
 	[ASIHTTPRequest setProgress:progress forProgressIndicator:uploadProgressDelegate];
+
 }
 }
 
 
-- (void)incrementDownloadSizeBy:(int)bytes
+- (void)incrementDownloadSizeBy:(unsigned long long)bytes
 {
 {
 	if (!downloadProgressDelegate) {
 	if (!downloadProgressDelegate) {
 		return;
 		return;
 	}
 	}
 	downloadProgressTotalBytes += bytes;
 	downloadProgressTotalBytes += bytes;
 	[self incrementDownloadProgressBy:0];
 	[self incrementDownloadProgressBy:0];
+	NSLog(@"download size is now: %qu",downloadProgressTotalBytes);
 }
 }
 
 
-- (void)incrementDownloadProgressBy:(int)bytes
+- (void)incrementDownloadProgressBy:(unsigned long long)bytes
 {
 {
 	if (!downloadProgressDelegate || downloadProgressTotalBytes == 0) {
 	if (!downloadProgressDelegate || downloadProgressTotalBytes == 0) {
 		return;
 		return;
 	}
 	}
 	downloadProgressBytes += bytes;
 	downloadProgressBytes += bytes;
-	//NSLog(@"%hu/%hu",downloadProgressBytes,downloadProgressTotalBytes);
+	//NSLog(@"%qu/%qu",downloadProgressBytes,downloadProgressTotalBytes);
 	double progress = (downloadProgressBytes*1.0)/(downloadProgressTotalBytes*1.0);
 	double progress = (downloadProgressBytes*1.0)/(downloadProgressTotalBytes*1.0);
 	[ASIHTTPRequest setProgress:progress forProgressIndicator:downloadProgressDelegate];
 	[ASIHTTPRequest setProgress:progress forProgressIndicator:downloadProgressDelegate];
 }
 }

@@ -201,8 +201,6 @@
 
 
 - (void)requestFailedCancellingOthers:(ASIHTTPRequest *)request
 - (void)requestFailedCancellingOthers:(ASIHTTPRequest *)request
 {
 {
-	BOOL success = (request == requestThatShouldFail);
-	STAssertTrue(success,@"Wrong request failed");
 	complete = YES;
 	complete = YES;
 }
 }