updated to newest ref added block level variables to avoid retain cycles

@@ -65,6 +65,14 @@ extern NSString* const NetworkRequestErrorDomain;
 // This number is not official, as far as I know there is no officially documented bandwidth limit
 // This number is not official, as far as I know there is no officially documented bandwidth limit
 extern unsigned long const ASIWWANBandwidthThrottleAmount;
 extern unsigned long const ASIWWANBandwidthThrottleAmount;
 
 
+#if NS_BLOCKS_AVAILABLE
+typedef void (^ASIHTTPRequestBlock)(ASIHTTPRequest *request);
+//typedef BOOL (^ASIHTTPRequestAuthenticationBlock)(ASIHTTPRequest *request);
+typedef void (^ASIHTTPRequestSizeBlock)(ASIHTTPRequest *request, long long size);
+typedef void (^ASIHTTPRequestProgressBlock)(ASIHTTPRequest *request, unsigned long long size, unsigned long long total);
+typedef void (^ASIHTTPRequestDataReceivedBlock)(ASIHTTPRequest *request, NSData *data);
+#endif
+
 @interface ASIHTTPRequest : NSOperation <NSCopying> {
 @interface ASIHTTPRequest : NSOperation <NSCopying> {
 	
 	
 	// The url for this operation, should include GET params in the query string where appropriate
 	// The url for this operation, should include GET params in the query string where appropriate
@@ -427,6 +435,41 @@ extern unsigned long const ASIWWANBandwidthThrottleAmount;
 
 
 	// Set secondsToCache to use a custom time interval for expiring the response when it is stored in a cache
 	// Set secondsToCache to use a custom time interval for expiring the response when it is stored in a cache
 	NSTimeInterval secondsToCache;
 	NSTimeInterval secondsToCache;
+    
+#if NS_BLOCKS_AVAILABLE
+    //block to execute when request starts
+    ASIHTTPRequestBlock startedBlock;
+    
+    //block to execute when headers are received
+    ASIHTTPRequestBlock headersReceivedBlock;
+    
+    //block to execute when request completes successfully
+    ASIHTTPRequestBlock completionBlock;
+    
+    //block to execute when request fails
+    ASIHTTPRequestBlock failureBlock;
+    
+    //block for when bytes are received
+    ASIHTTPRequestProgressBlock bytesReceivedBlock;
+    
+    //block for when bytes are sent
+    ASIHTTPRequestProgressBlock bytesSentBlock;
+    
+    //block for when download size is incremented
+    ASIHTTPRequestSizeBlock downloadSizeIncrementedBlock;
+    
+    //block for when upload size is incremented
+    ASIHTTPRequestSizeBlock uploadSizeIncrementedBlock;
+    
+    //block for handling raw bytes received
+    ASIHTTPRequestDataReceivedBlock dataReceivedBlock;
+    
+    //block for handling authentication
+    ASIHTTPRequestBlock authenticationNeededBlock;
+    
+    //block for handling proxy authentication
+    ASIHTTPRequestBlock proxyAuthenticationNeededBlock;    
+#endif 
 }
 }
 
 
 #pragma mark init / dealloc
 #pragma mark init / dealloc
@@ -440,6 +483,20 @@ extern unsigned long const ASIWWANBandwidthThrottleAmount;
 + (id)requestWithURL:(NSURL *)newURL usingCache:(id <ASICacheDelegate>)cache;
 + (id)requestWithURL:(NSURL *)newURL usingCache:(id <ASICacheDelegate>)cache;
 + (id)requestWithURL:(NSURL *)newURL usingCache:(id <ASICacheDelegate>)cache andCachePolicy:(ASICachePolicy)policy;
 + (id)requestWithURL:(NSURL *)newURL usingCache:(id <ASICacheDelegate>)cache andCachePolicy:(ASICachePolicy)policy;
 
 
+#if NS_BLOCKS_AVAILABLE
+- (void)setStartedBlock:(ASIHTTPRequestBlock)aStartedBlock;
+- (void)setHeadersReceivedBlock:(ASIHTTPRequestBlock)aReceivedBlock;
+- (void)setCompletionBlock:(ASIHTTPRequestBlock)aCompletionBlock;
+- (void)setFailedBlock:(ASIHTTPRequestBlock)aFailedBlock;
+- (void)setBytesReceivedBlock:(ASIHTTPRequestProgressBlock) aBytesReceivedBlock;
+- (void)setBytesSentBlock:(ASIHTTPRequestProgressBlock)aBytesSentBlock;
+- (void)setDownloadSizeIncrementedBlock:(ASIHTTPRequestSizeBlock) aDownloadSizeIncrementedBlock;
+- (void)setUploadSizeIncrementedBlock:(ASIHTTPRequestSizeBlock) anUploadSizeIncrementedBlock;
+- (void)setDataReceivedBlock:(ASIHTTPRequestDataReceivedBlock)aReceivedBlock;
+- (void)setAuthenticationNeededBlock:(ASIHTTPRequestBlock)anAuthenticationBlock;
+- (void)setProxyAuthenticationNeededBlock:(ASIHTTPRequestBlock)aProxyAuthenticationBlock;
+#endif
+
 #pragma mark setup request
 #pragma mark setup request
 
 
 // Add a custom header to the request
 // Add a custom header to the request

@@ -363,9 +363,75 @@ static NSOperationQueue *sharedQueue = nil;
 	[responseStatusMessage release];
 	[responseStatusMessage release];
 	[connectionInfo release];
 	[connectionInfo release];
 	[requestID release];
 	[requestID release];
+#if NS_BLOCKS_AVAILABLE
+    [completionBlock release];
+    [failureBlock release];
+    [startedBlock release];
+    [headersReceivedBlock release];
+    [bytesReceivedBlock release];
+    [bytesSentBlock release];
+    [downloadSizeIncrementedBlock release];
+    [uploadSizeIncrementedBlock release];
+    [dataReceivedBlock release];
+    [proxyAuthenticationNeededBlock release];
+    [authenticationNeededBlock release];
+#endif
 	[super dealloc];
 	[super dealloc];
 }
 }
 
 
+#pragma mark -
+#pragma mark blocks
+#if NS_BLOCKS_AVAILABLE
+- (void)setStartedBlock:(ASIHTTPRequestBlock)aStartedBlock{
+    [startedBlock release];
+    startedBlock = [aStartedBlock copy];
+}
+
+- (void)setHeadersReceivedBlock:(ASIHTTPRequestBlock)aReceivedBlock{
+    [headersReceivedBlock release];
+    headersReceivedBlock = [aReceivedBlock copy];
+}
+
+- (void)setCompletionBlock:(ASIHTTPRequestBlock)aCompletionBlock{
+    [completionBlock release];
+    completionBlock = [aCompletionBlock copy];
+}
+- (void)setFailedBlock:(ASIHTTPRequestBlock)aFailedBlock{
+    [failureBlock release];
+    failureBlock = [aFailedBlock copy];
+}
+- (void)setBytesReceivedBlock:(ASIHTTPRequestProgressBlock) aBytesReceivedBlock{
+    [bytesReceivedBlock release];
+    bytesReceivedBlock = [aBytesReceivedBlock copy];
+}
+- (void)setBytesSentBlock:(ASIHTTPRequestProgressBlock)aBytesSentBlock{
+    [bytesSentBlock release];
+    bytesSentBlock = [aBytesSentBlock copy];
+}
+- (void)setDownloadSizeIncrementedBlock:(ASIHTTPRequestSizeBlock) aDownloadSizeIncrementedBlock{
+    [downloadSizeIncrementedBlock release];
+    downloadSizeIncrementedBlock = [aDownloadSizeIncrementedBlock copy];
+}
+- (void)setUploadSizeIncrementedBlock:(ASIHTTPRequestSizeBlock) anUploadSizeIncrementedBlock{
+    [uploadSizeIncrementedBlock release];
+    uploadSizeIncrementedBlock = [anUploadSizeIncrementedBlock copy];
+}
+
+- (void)setDataReceivedBlock:(ASIHTTPRequestDataReceivedBlock)aReceivedBlock{
+    [dataReceivedBlock release];
+    dataReceivedBlock = [aReceivedBlock copy];
+}
+
+- (void)setAuthenticationNeededBlock:(ASIHTTPRequestBlock)anAuthenticationBlock{
+    [authenticationNeededBlock release];
+    authenticationNeededBlock = [anAuthenticationBlock copy];
+}
+- (void)setProxyAuthenticationNeededBlock:(ASIHTTPRequestBlock)aProxyAuthenticationBlock{
+    [proxyAuthenticationNeededBlock release];
+    proxyAuthenticationNeededBlock = [aProxyAuthenticationBlock copy];
+}
+#endif
+
 #pragma mark setup request
 #pragma mark setup request
 
 
 - (void)addRequestHeader:(NSString *)header value:(NSString *)value
 - (void)addRequestHeader:(NSString *)header value:(NSString *)value
@@ -1508,7 +1574,12 @@ static NSOperationQueue *sharedQueue = nil;
 	[ASIHTTPRequest performSelector:@selector(request:didReceiveBytes:) onTarget:&queue withObject:self amount:&value];
 	[ASIHTTPRequest performSelector:@selector(request:didReceiveBytes:) onTarget:&queue withObject:self amount:&value];
 	[ASIHTTPRequest performSelector:@selector(request:didReceiveBytes:) onTarget:&downloadProgressDelegate withObject:self amount:&value];
 	[ASIHTTPRequest performSelector:@selector(request:didReceiveBytes:) onTarget:&downloadProgressDelegate withObject:self amount:&value];
 	[ASIHTTPRequest updateProgressIndicator:&downloadProgressDelegate withProgress:[self totalBytesRead]+[self partialDownloadSize] ofTotal:[self contentLength]+[self partialDownloadSize]];
 	[ASIHTTPRequest updateProgressIndicator:&downloadProgressDelegate withProgress:[self totalBytesRead]+[self partialDownloadSize] ofTotal:[self contentLength]+[self partialDownloadSize]];
-		
+#if NS_BLOCKS_AVAILABLE    
+    if(bytesReceivedBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        bytesReceivedBlock(blockCopy, bytesReadSoFar, blockCopy->contentLength + blockCopy->partialDownloadSize);
+    }
+#endif
 	[self setLastBytesRead:bytesReadSoFar];
 	[self setLastBytesRead:bytesReadSoFar];
 }
 }
 
 
@@ -1547,6 +1618,12 @@ static NSOperationQueue *sharedQueue = nil;
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&queue withObject:self amount:&value];
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&queue withObject:self amount:&value];
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&uploadProgressDelegate withObject:self amount:&value];
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&uploadProgressDelegate withObject:self amount:&value];
 	[ASIHTTPRequest updateProgressIndicator:&uploadProgressDelegate withProgress:[self totalBytesSent]-[self uploadBufferSize] ofTotal:[self postLength]-[self uploadBufferSize]];
 	[ASIHTTPRequest updateProgressIndicator:&uploadProgressDelegate withProgress:[self totalBytesSent]-[self uploadBufferSize] ofTotal:[self postLength]-[self uploadBufferSize]];
+#if NS_BLOCKS_AVAILABLE
+    if(bytesSentBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        bytesSentBlock(blockCopy, value, blockCopy->postLength);
+    }
+#endif
 }
 }
 
 
 
 
@@ -1554,6 +1631,12 @@ static NSOperationQueue *sharedQueue = nil;
 {
 {
 	[ASIHTTPRequest performSelector:@selector(request:incrementDownloadSizeBy:) onTarget:&queue withObject:self amount:&length];
 	[ASIHTTPRequest performSelector:@selector(request:incrementDownloadSizeBy:) onTarget:&queue withObject:self amount:&length];
 	[ASIHTTPRequest performSelector:@selector(request:incrementDownloadSizeBy:) onTarget:&downloadProgressDelegate withObject:self amount:&length];
 	[ASIHTTPRequest performSelector:@selector(request:incrementDownloadSizeBy:) onTarget:&downloadProgressDelegate withObject:self amount:&length];
+#if NS_BLOCKS_AVAILABLE
+    if(downloadSizeIncrementedBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        downloadSizeIncrementedBlock(blockCopy, length);
+    }
+#endif
 }
 }
 
 
 
 
@@ -1561,6 +1644,12 @@ static NSOperationQueue *sharedQueue = nil;
 {
 {
 	[ASIHTTPRequest performSelector:@selector(request:incrementUploadSizeBy:) onTarget:&queue withObject:self amount:&length];
 	[ASIHTTPRequest performSelector:@selector(request:incrementUploadSizeBy:) onTarget:&queue withObject:self amount:&length];
 	[ASIHTTPRequest performSelector:@selector(request:incrementUploadSizeBy:) onTarget:&uploadProgressDelegate withObject:self amount:&length];
 	[ASIHTTPRequest performSelector:@selector(request:incrementUploadSizeBy:) onTarget:&uploadProgressDelegate withObject:self amount:&length];
+#if NS_BLOCKS_AVAILABLE
+    if(uploadSizeIncrementedBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        uploadSizeIncrementedBlock(blockCopy, length);
+    }
+#endif
 }
 }
 
 
 
 
@@ -1570,6 +1659,12 @@ static NSOperationQueue *sharedQueue = nil;
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&queue withObject:self amount:&progressToRemove];
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&queue withObject:self amount:&progressToRemove];
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&uploadProgressDelegate withObject:self amount:&progressToRemove];
 	[ASIHTTPRequest performSelector:@selector(request:didSendBytes:) onTarget:&uploadProgressDelegate withObject:self amount:&progressToRemove];
 	[ASIHTTPRequest updateProgressIndicator:&uploadProgressDelegate withProgress:0 ofTotal:[self postLength]];
 	[ASIHTTPRequest updateProgressIndicator:&uploadProgressDelegate withProgress:0 ofTotal:[self postLength]];
+#if NS_BLOCKS_AVAILABLE
+    if(bytesSentBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        bytesSentBlock(blockCopy, progressToRemove, blockCopy->postLength);
+    }
+#endif
 }
 }
 
 
 + (void)performInvocation:(NSInvocation *)invocation onTarget:(id *)target
 + (void)performInvocation:(NSInvocation *)invocation onTarget:(id *)target
@@ -1686,6 +1781,13 @@ static NSOperationQueue *sharedQueue = nil;
 	
 	
 	// Let the queue know we have started
 	// Let the queue know we have started
 	[self callSelectorOnMainThread:&queueRequestReceivedResponseHeadersSelector forDelegate:&queue];
 	[self callSelectorOnMainThread:&queueRequestReceivedResponseHeadersSelector forDelegate:&queue];
+    
+#if NS_BLOCKS_AVAILABLE
+    if(headersReceivedBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        headersReceivedBlock(blockCopy);
+    }
+#endif
 }
 }
 
 
 - (void)requestStarted
 - (void)requestStarted
@@ -1698,6 +1800,13 @@ static NSOperationQueue *sharedQueue = nil;
 	
 	
 	// Let the queue know we have started
 	// Let the queue know we have started
 	[self callSelectorOnMainThread:&queueRequestStartedSelector forDelegate:&queue];
 	[self callSelectorOnMainThread:&queueRequestStartedSelector forDelegate:&queue];
+    
+#if NS_BLOCKS_AVAILABLE
+    if(startedBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        startedBlock(blockCopy);
+    }
+#endif
 }
 }
 
 
 // Subclasses might override this method to process the result in the same thread
 // Subclasses might override this method to process the result in the same thread
@@ -1715,6 +1824,12 @@ static NSOperationQueue *sharedQueue = nil;
 	
 	
 	// Let the queue know we are done
 	// Let the queue know we are done
 	[self callSelectorOnMainThread:&queueRequestFinishedSelector forDelegate:&queue];
 	[self callSelectorOnMainThread:&queueRequestFinishedSelector forDelegate:&queue];
+#if NS_BLOCKS_AVAILABLE
+    if(completionBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        completionBlock(blockCopy);
+    }
+#endif
 }
 }
 
 
 
 
@@ -1725,6 +1840,13 @@ static NSOperationQueue *sharedQueue = nil;
 	
 	
 	// Let the queue know something went wrong
 	// Let the queue know something went wrong
 	[self callSelectorOnMainThread:&queueRequestFailedSelector forDelegate:&queue];
 	[self callSelectorOnMainThread:&queueRequestFailedSelector forDelegate:&queue];
+    
+#if NS_BLOCKS_AVAILABLE
+    if(failureBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        failureBlock(blockCopy);
+    }
+#endif
 }
 }
 
 
 // Subclasses might override this method to perform error handling in the same thread
 // Subclasses might override this method to perform error handling in the same thread
@@ -2255,6 +2377,12 @@ static NSOperationQueue *sharedQueue = nil;
 		[authenticationDelegate performSelectorOnMainThread:@selector(proxyAuthenticationNeededForRequest:) withObject:self waitUntilDone:[NSThread isMainThread]];
 		[authenticationDelegate performSelectorOnMainThread:@selector(proxyAuthenticationNeededForRequest:) withObject:self waitUntilDone:[NSThread isMainThread]];
 		return YES;
 		return YES;
 	}
 	}
+#if NS_BLOCKS_AVAILABLE
+	if(proxyAuthenticationNeededBlock){
+        __block ASIHTTPRequest *blockCopy = self;
+        proxyAuthenticationNeededBlock(blockCopy);
+    }
+#endif
 	return NO;
 	return NO;
 }
 }
 
 
@@ -2724,6 +2852,13 @@ static NSOperationQueue *sharedQueue = nil;
 		if ([self needsRedirect] && [self shouldRedirect] && [self allowResumeForFileDownloads]) {
 		if ([self needsRedirect] && [self shouldRedirect] && [self allowResumeForFileDownloads]) {
 			return;
 			return;
 		}
 		}
+#if NS_BLOCKS_AVAILABLE
+        if(dataReceivedBlock){
+            NSData *data = [NSData dataWithBytes:buffer length:bytesRead];
+            __block ASIHTTPRequest *blockCopy = self;
+            dataReceivedBlock(blockCopy, data);
+        }
+#endif
 		
 		
 		// Does the delegate want to handle the data manually?
 		// Does the delegate want to handle the data manually?
 		if ([[self delegate] respondsToSelector:[self didReceiveDataSelector]]) {
 		if ([[self delegate] respondsToSelector:[self didReceiveDataSelector]]) {