Fixing Google Code issue robbiehanson#133 - Improving thread-safety documentation, and undoing unwanted data copy.

robbiehanson · robbiehanson · commit be2a695bd368 · 2011-12-09T16:22:34.000-08:00
diff --git a/GCD/GCDAsyncSocket.h b/GCD/GCDAsyncSocket.h
@@ -449,9 +449,10 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * If the bufferOffset is greater than the length of the given buffer,
  * the method will do nothing, and the delegate will not be called.
  * 
- * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * If you pass a buffer, you must not alter it in any way while the socket is using it.
  * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
- * That is, it will reference the bytes that were appended to the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer via
+ * the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
 **/
 - (void)readDataWithTimeout:(NSTimeInterval)timeout
 					 buffer:(NSMutableData *)buffer
@@ -471,9 +472,10 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * If the bufferOffset is greater than the length of the given buffer,
  * the method will do nothing, and the delegate will not be called.
  * 
- * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * If you pass a buffer, you must not alter it in any way while the socket is using it.
  * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
- * That is, it will reference the bytes that were appended to the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer  via
+ * the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
 **/
 - (void)readDataWithTimeout:(NSTimeInterval)timeout
                      buffer:(NSMutableData *)buffer
@@ -504,7 +506,8 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * 
  * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
  * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
- * That is, it will reference the bytes that were appended to the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer via
+ * the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
 **/
 - (void)readDataToLength:(NSUInteger)length
              withTimeout:(NSTimeInterval)timeout
@@ -518,11 +521,20 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * If the timeout value is negative, the read operation will not use a timeout.
  * 
  * If you pass nil or zero-length data as the "data" parameter,
- * the method will do nothing, and the delegate will not be called.
+ * the method will do nothing (except maybe print a warning), and the delegate will not be called.
  * 
  * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
- * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
- * a character, the read will prematurely end.
+ * If you're developing your own custom protocol, be sure your separator can not occur naturally as
+ * part of the data between separators.
+ * For example, imagine you want to send several small documents over a socket.
+ * Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
+ * In this particular example, it would be better to use a protocol similar to HTTP with
+ * a header that includes the length of the document.
+ * Also be careful that your separator cannot occur naturally as part of the encoding for a character.
+ * 
+ * The given data (separator) parameter should be immutable.
+ * For performance reasons, the socket will retain it, not copy it.
+ * So if it is immutable, don't modify it while the socket is using it.
 **/
 - (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
 
@@ -535,15 +547,25 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * If the buffer if nil, a buffer will automatically be created for you.
  * 
  * If the bufferOffset is greater than the length of the given buffer,
- * the method will do nothing, and the delegate will not be called.
+ * the method will do nothing (except maybe print a warning), and the delegate will not be called.
  * 
- * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * If you pass a buffer, you must not alter it in any way while the socket is using it.
  * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
- * That is, it will reference the bytes that were appended to the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer via
+ * the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
  * 
  * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
- * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
- * a character, the read will prematurely end.
+ * If you're developing your own custom protocol, be sure your separator can not occur naturally as
+ * part of the data between separators.
+ * For example, imagine you want to send several small documents over a socket.
+ * Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
+ * In this particular example, it would be better to use a protocol similar to HTTP with
+ * a header that includes the length of the document.
+ * Also be careful that your separator cannot occur naturally as part of the encoding for a character.
+ * 
+ * The given data (separator) parameter should be immutable.
+ * For performance reasons, the socket will retain it, not copy it.
+ * So if it is immutable, don't modify it while the socket is using it.
 **/
 - (void)readDataToData:(NSData *)data
            withTimeout:(NSTimeInterval)timeout
@@ -562,13 +584,22 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end.
  * 
  * If you pass nil or zero-length data as the "data" parameter,
- * the method will do nothing, and the delegate will not be called.
+ * the method will do nothing (except maybe print a warning), and the delegate will not be called.
  * If you pass a maxLength parameter that is less than the length of the data parameter,
- * the method will do nothing, and the delegate will not be called.
+ * the method will do nothing (except maybe print a warning), and the delegate will not be called.
  * 
  * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
- * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
- * a character, the read will prematurely end.
+ * If you're developing your own custom protocol, be sure your separator can not occur naturally as
+ * part of the data between separators.
+ * For example, imagine you want to send several small documents over a socket.
+ * Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
+ * In this particular example, it would be better to use a protocol similar to HTTP with
+ * a header that includes the length of the document.
+ * Also be careful that your separator cannot occur naturally as part of the encoding for a character.
+ * 
+ * The given data (separator) parameter should be immutable.
+ * For performance reasons, the socket will retain it, not copy it.
+ * So if it is immutable, don't modify it while the socket is using it.
 **/
 - (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout maxLength:(NSUInteger)length tag:(long)tag;
 
@@ -585,18 +616,28 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * it is treated similarly to a timeout - the socket is closed with a GCDAsyncSocketReadMaxedOutError.
  * The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end.
  * 
- * If you pass a maxLength parameter that is less than the length of the data parameter,
- * the method will do nothing, and the delegate will not be called.
+ * If you pass a maxLength parameter that is less than the length of the data (separator) parameter,
+ * the method will do nothing (except maybe print a warning), and the delegate will not be called.
  * If the bufferOffset is greater than the length of the given buffer,
- * the method will do nothing, and the delegate will not be called.
+ * the method will do nothing (except maybe print a warning), and the delegate will not be called.
  * 
- * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * If you pass a buffer, you must not alter it in any way while the socket is using it.
  * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
- * That is, it will reference the bytes that were appended to the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer via
+ * the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
  * 
  * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
- * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
- * a character, the read will prematurely end.
+ * If you're developing your own custom protocol, be sure your separator can not occur naturally as
+ * part of the data between separators.
+ * For example, imagine you want to send several small documents over a socket.
+ * Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
+ * In this particular example, it would be better to use a protocol similar to HTTP with
+ * a header that includes the length of the document.
+ * Also be careful that your separator cannot occur naturally as part of the encoding for a character.
+ * 
+ * The given data (separator) parameter should be immutable.
+ * For performance reasons, the socket will retain it, not copy it.
+ * So if it is immutable, don't modify it while the socket is using it.
 **/
 - (void)readDataToData:(NSData *)data
            withTimeout:(NSTimeInterval)timeout
@@ -612,6 +653,17 @@ typedef enum GCDAsyncSocketError GCDAsyncSocketError;
  * 
  * If you pass in nil or zero-length data, this method does nothing and the delegate will not be called.
  * If the timeout value is negative, the write operation will not use a timeout.
+ * 
+ * Thread-Safety Note:
+ * If the given data parameter is mutable (NSMutableData) then you MUST NOT alter the data while
+ * the socket is writing it. In other words, it's not safe to alter the data until after the delegate method
+ * socket:didWriteDataWithTag: is invoked signifying that this particular write operation has completed.
+ * This is due to the fact that GCDAsyncSocket does NOT copy the data. It simply retains it.
+ * This is for performance reasons. Often times, if NSMutableData is passed, it is because
+ * a request/response was built up in memory. Copying this data adds an unwanted/unneeded overhead.
+ * If you need to write data from an immutable buffer, and you need to alter the buffer before the socket
+ * completes writing the bytes (which is NOT immediately after this method returns, but rather at a later time
+ * when the delegate method notifies you), then you should first copy the bytes, and pass the copy to this method.
 **/
 - (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
 
diff --git a/GCD/GCDAsyncSocket.m b/GCD/GCDAsyncSocket.m
@@ -741,7 +741,7 @@ - (id)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i
 {
 	if((self = [super init]))
 	{
-		buffer = [d copy]; // If d is immutable, this is just a retain
+		buffer = [d retain]; // Retain not copy. For performance as documented in header file.
 		bytesDone = 0;
 		timeout = t;
 		tag = i;
@@ -1250,10 +1250,13 @@ - (BOOL)acceptOnPort:(uint16_t)port error:(NSError **)errPtr
 	return [self acceptOnInterface:nil port:port error:errPtr];
 }
 
-- (BOOL)acceptOnInterface:(NSString *)interface port:(uint16_t)port error:(NSError **)errPtr
+- (BOOL)acceptOnInterface:(NSString *)inInterface port:(uint16_t)port error:(NSError **)errPtr
 {
 	LogTrace();
 	
+	// Just in-case interface parameter is immutable.
+	NSString *interface = [[inInterface copy] autorelease];
+	
 	__block BOOL result = NO;
 	__block NSError *err = nil;
 	
@@ -1783,14 +1786,18 @@ - (BOOL)connectToHost:(NSString *)host
 	return [self connectToHost:host onPort:port viaInterface:nil withTimeout:timeout error:errPtr];
 }
 
-- (BOOL)connectToHost:(NSString *)host
+- (BOOL)connectToHost:(NSString *)inHost
                onPort:(uint16_t)port
-         viaInterface:(NSString *)interface
+         viaInterface:(NSString *)inInterface
           withTimeout:(NSTimeInterval)timeout
                 error:(NSError **)errPtr
 {
 	LogTrace();
 	
+	// Just in case immutable objects were passed
+	NSString *host = [[inHost copy] autorelease];
+	NSString *interface = [[inInterface copy] autorelease];
+	
 	__block BOOL result = NO;
 	__block NSError *err = nil;
 	
@@ -1872,13 +1879,17 @@ - (BOOL)connectToAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeou
 	return [self connectToAddress:remoteAddr viaInterface:nil withTimeout:timeout error:errPtr];
 }
 
-- (BOOL)connectToAddress:(NSData *)remoteAddr
-            viaInterface:(NSString *)interface
+- (BOOL)connectToAddress:(NSData *)inRemoteAddr
+            viaInterface:(NSString *)inInterface
              withTimeout:(NSTimeInterval)timeout
                    error:(NSError **)errPtr
 {
 	LogTrace();
 	
+	// Just in case immutable objects were passed
+	NSData *remoteAddr = [[inRemoteAddr copy] autorelease];
+	NSString *interface = [[inInterface copy] autorelease];
+	
 	__block BOOL result = NO;
 	__block NSError *err = nil;
 	
@@ -3629,7 +3640,10 @@ - (void)readDataWithTimeout:(NSTimeInterval)timeout
                   maxLength:(NSUInteger)length
                         tag:(long)tag
 {
-	if (offset > [buffer length]) return;
+	if (offset > [buffer length]) {
+		LogWarn(@"Cannot read: offset > [buffer length]");
+		return;
+	}
 	
 	GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer
 	                                                          startOffset:offset
@@ -3669,8 +3683,14 @@ - (void)readDataToLength:(NSUInteger)length
             bufferOffset:(NSUInteger)offset
                      tag:(long)tag
 {
-	if (length == 0) return;
-	if (offset > [buffer length]) return;
+	if (length == 0) {
+		LogWarn(@"Cannot read: length == 0");
+		return;
+	}
+	if (offset > [buffer length]) {
+		LogWarn(@"Cannot read: offset > [buffer length]");
+		return;
+	}
 	
 	GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer
 	                                                          startOffset:offset
@@ -3722,16 +3742,25 @@ - (void)readDataToData:(NSData *)data
            withTimeout:(NSTimeInterval)timeout
                 buffer:(NSMutableData *)buffer
           bufferOffset:(NSUInteger)offset
-             maxLength:(NSUInteger)length
+             maxLength:(NSUInteger)maxLength
                    tag:(long)tag
 {
-	if ([data length] == 0) return;
-	if (offset > [buffer length]) return;
-	if (length > 0 && length < [data length]) return;
+	if ([data length] == 0) {
+		LogWarn(@"Cannot read: [data length] == 0");
+		return;
+	}
+	if (offset > [buffer length]) {
+		LogWarn(@"Cannot read: offset > [buffer length]");
+		return;
+	}
+	if (maxLength > 0 && maxLength < [data length]) {
+		LogWarn(@"Cannot read: maxLength > 0 && maxLength < [data length]");
+		return;
+	}
 	
 	GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer
 	                                                          startOffset:offset
-	                                                            maxLength:length
+	                                                            maxLength:maxLength
 	                                                              timeout:timeout
 	                                                           readLength:0
 	                                                           terminator:data
@@ -6659,8 +6688,7 @@ - (int)socketFD
 {
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return SOCKET_NULL;
 	}
 	
@@ -6674,8 +6702,7 @@ - (int)socket4FD
 {
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return SOCKET_NULL;
 	}
 	
@@ -6686,8 +6713,7 @@ - (int)socket6FD
 {
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return SOCKET_NULL;
 	}
 	
@@ -6700,8 +6726,7 @@ - (CFReadStreamRef)readStream
 {
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return NULL;
 	}
 	
@@ -6715,8 +6740,7 @@ - (CFWriteStreamRef)writeStream
 {
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return NULL;
 	}
 	
@@ -6743,7 +6767,6 @@ - (BOOL)enableBackgroundingOnSocketWithCaveat:(BOOL)caveat
 	
 	if (!r1 || !r2)
 	{
-		LogError(@"Error setting voip type");
 		return NO;
 	}
 	
@@ -6764,8 +6787,7 @@ - (BOOL)enableBackgroundingOnSocket
 	
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return NO;
 	}
 	
@@ -6782,8 +6804,7 @@ - (BOOL)enableBackgroundingOnSocketWithCaveat // Deprecated in iOS 4.???
 	
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return NO;
 	}
 	
@@ -6796,8 +6817,7 @@ - (SSLContextRef)sslContext
 {
 	if (dispatch_get_current_queue() != socketQueue)
 	{
-		LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",
-				THIS_FILE, THIS_METHOD);
+		LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);
 		return NULL;
 	}
 	
diff --git a/GCD/Xcode/SimpleHTTPClient/Desktop/SimpleHTTPClient.xcodeproj/project.pbxproj b/GCD/Xcode/SimpleHTTPClient/Desktop/SimpleHTTPClient.xcodeproj/project.pbxproj
@@ -178,7 +178,7 @@
 		DC80C9F213C3978F00D29D06 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
-				LastUpgradeCheck = 0420;
+				LastUpgradeCheck = 0430;
 			};
 			buildConfigurationList = DC80C9F513C3978F00D29D06 /* Build configuration list for PBXProject "SimpleHTTPClient" */;
 			compatibilityVersion = "Xcode 3.2";

Original file line number	Diff line number	Diff line change
`@@ -741,7 +741,7 @@ - (id)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i`
`741`	`741`	`{`
`742`	`742`	`if((self = [super init]))`
`743`	`743`	`{`
`744`		`- buffer = [d copy]; // If d is immutable, this is just a retain`
	`744`	`+ buffer = [d retain]; // Retain not copy. For performance as documented in header file.`
`745`	`745`	`bytesDone = 0;`
`746`	`746`	`timeout = t;`
`747`	`747`	`tag = i;`
`@@ -1250,10 +1250,13 @@ - (BOOL)acceptOnPort:(uint16_t)port error:(NSError **)errPtr`
`1250`	`1250`	`return [self acceptOnInterface:nil port:port error:errPtr];`
`1251`	`1251`	`}`
`1252`	`1252`
`1253`		`-- (BOOL)acceptOnInterface:(NSString )interface port:(uint16_t)port error:(NSError *)errPtr`
	`1253`	`+- (BOOL)acceptOnInterface:(NSString )inInterface port:(uint16_t)port error:(NSError *)errPtr`
`1254`	`1254`	`{`
`1255`	`1255`	`LogTrace();`
`1256`	`1256`
	`1257`	`+ // Just in-case interface parameter is immutable.`
	`1258`	`+ NSString *interface = [[inInterface copy] autorelease];`
	`1259`	`+`
`1257`	`1260`	`__block BOOL result = NO;`
`1258`	`1261`	`__block NSError *err = nil;`
`1259`	`1262`
`@@ -1783,14 +1786,18 @@ - (BOOL)connectToHost:(NSString *)host`
`1783`	`1786`	`return [self connectToHost:host onPort:port viaInterface:nil withTimeout:timeout error:errPtr];`
`1784`	`1787`	`}`
`1785`	`1788`
`1786`		`-- (BOOL)connectToHost:(NSString *)host`
	`1789`	`+- (BOOL)connectToHost:(NSString *)inHost`
`1787`	`1790`	`onPort:(uint16_t)port`
`1788`		`- viaInterface:(NSString *)interface`
	`1791`	`+ viaInterface:(NSString *)inInterface`
`1789`	`1792`	`withTimeout:(NSTimeInterval)timeout`
`1790`	`1793`	`error:(NSError **)errPtr`
`1791`	`1794`	`{`
`1792`	`1795`	`LogTrace();`
`1793`	`1796`
	`1797`	`+ // Just in case immutable objects were passed`
	`1798`	`+ NSString *host = [[inHost copy] autorelease];`
	`1799`	`+ NSString *interface = [[inInterface copy] autorelease];`
	`1800`	`+`
`1794`	`1801`	`__block BOOL result = NO;`
`1795`	`1802`	`__block NSError *err = nil;`
`1796`	`1803`
`@@ -1872,13 +1879,17 @@ - (BOOL)connectToAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeou`
`1872`	`1879`	`return [self connectToAddress:remoteAddr viaInterface:nil withTimeout:timeout error:errPtr];`
`1873`	`1880`	`}`
`1874`	`1881`
`1875`		`-- (BOOL)connectToAddress:(NSData *)remoteAddr`
`1876`		`- viaInterface:(NSString *)interface`
	`1882`	`+- (BOOL)connectToAddress:(NSData *)inRemoteAddr`
	`1883`	`+ viaInterface:(NSString *)inInterface`
`1877`	`1884`	`withTimeout:(NSTimeInterval)timeout`
`1878`	`1885`	`error:(NSError **)errPtr`
`1879`	`1886`	`{`
`1880`	`1887`	`LogTrace();`
`1881`	`1888`
	`1889`	`+ // Just in case immutable objects were passed`
	`1890`	`+ NSData *remoteAddr = [[inRemoteAddr copy] autorelease];`
	`1891`	`+ NSString *interface = [[inInterface copy] autorelease];`
	`1892`	`+`
`1882`	`1893`	`__block BOOL result = NO;`
`1883`	`1894`	`__block NSError *err = nil;`
`1884`	`1895`
`@@ -3629,7 +3640,10 @@ - (void)readDataWithTimeout:(NSTimeInterval)timeout`
`3629`	`3640`	`maxLength:(NSUInteger)length`
`3630`	`3641`	`tag:(long)tag`
`3631`	`3642`	`{`
`3632`		`- if (offset > [buffer length]) return;`
	`3643`	`+ if (offset > [buffer length]) {`
	`3644`	`+ LogWarn(@"Cannot read: offset > [buffer length]");`
	`3645`	`+ return;`
	`3646`	`+ }`
`3633`	`3647`
`3634`	`3648`	`GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer`
`3635`	`3649`	`startOffset:offset`
`@@ -3669,8 +3683,14 @@ - (void)readDataToLength:(NSUInteger)length`
`3669`	`3683`	`bufferOffset:(NSUInteger)offset`
`3670`	`3684`	`tag:(long)tag`
`3671`	`3685`	`{`
`3672`		`- if (length == 0) return;`
`3673`		`- if (offset > [buffer length]) return;`
	`3686`	`+ if (length == 0) {`
	`3687`	`+ LogWarn(@"Cannot read: length == 0");`
	`3688`	`+ return;`
	`3689`	`+ }`
	`3690`	`+ if (offset > [buffer length]) {`
	`3691`	`+ LogWarn(@"Cannot read: offset > [buffer length]");`
	`3692`	`+ return;`
	`3693`	`+ }`
`3674`	`3694`
`3675`	`3695`	`GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer`
`3676`	`3696`	`startOffset:offset`
`@@ -3722,16 +3742,25 @@ - (void)readDataToData:(NSData *)data`
`3722`	`3742`	`withTimeout:(NSTimeInterval)timeout`
`3723`	`3743`	`buffer:(NSMutableData *)buffer`
`3724`	`3744`	`bufferOffset:(NSUInteger)offset`
`3725`		`- maxLength:(NSUInteger)length`
	`3745`	`+ maxLength:(NSUInteger)maxLength`
`3726`	`3746`	`tag:(long)tag`
`3727`	`3747`	`{`
`3728`		`- if ([data length] == 0) return;`
`3729`		`- if (offset > [buffer length]) return;`
`3730`		`- if (length > 0 && length < [data length]) return;`
	`3748`	`+ if ([data length] == 0) {`
	`3749`	`+ LogWarn(@"Cannot read: [data length] == 0");`
	`3750`	`+ return;`
	`3751`	`+ }`
	`3752`	`+ if (offset > [buffer length]) {`
	`3753`	`+ LogWarn(@"Cannot read: offset > [buffer length]");`
	`3754`	`+ return;`
	`3755`	`+ }`
	`3756`	`+ if (maxLength > 0 && maxLength < [data length]) {`
	`3757`	`+ LogWarn(@"Cannot read: maxLength > 0 && maxLength < [data length]");`
	`3758`	`+ return;`
	`3759`	`+ }`
`3731`	`3760`
`3732`	`3761`	`GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer`
`3733`	`3762`	`startOffset:offset`
`3734`		`- maxLength:length`
	`3763`	`+ maxLength:maxLength`
`3735`	`3764`	`timeout:timeout`
`3736`	`3765`	`readLength:0`
`3737`	`3766`	`terminator:data`
`@@ -6659,8 +6688,7 @@ - (int)socketFD`
`6659`	`6688`	`{`
`6660`	`6689`	`if (dispatch_get_current_queue() != socketQueue)`
`6661`	`6690`	`{`
`6662`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6663`		`- THIS_FILE, THIS_METHOD);`
	`6691`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6664`	`6692`	`return SOCKET_NULL;`
`6665`	`6693`	`}`
`6666`	`6694`
`@@ -6674,8 +6702,7 @@ - (int)socket4FD`
`6674`	`6702`	`{`
`6675`	`6703`	`if (dispatch_get_current_queue() != socketQueue)`
`6676`	`6704`	`{`
`6677`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6678`		`- THIS_FILE, THIS_METHOD);`
	`6705`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6679`	`6706`	`return SOCKET_NULL;`
`6680`	`6707`	`}`
`6681`	`6708`
`@@ -6686,8 +6713,7 @@ - (int)socket6FD`
`6686`	`6713`	`{`
`6687`	`6714`	`if (dispatch_get_current_queue() != socketQueue)`
`6688`	`6715`	`{`
`6689`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6690`		`- THIS_FILE, THIS_METHOD);`
	`6716`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6691`	`6717`	`return SOCKET_NULL;`
`6692`	`6718`	`}`
`6693`	`6719`
`@@ -6700,8 +6726,7 @@ - (CFReadStreamRef)readStream`
`6700`	`6726`	`{`
`6701`	`6727`	`if (dispatch_get_current_queue() != socketQueue)`
`6702`	`6728`	`{`
`6703`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6704`		`- THIS_FILE, THIS_METHOD);`
	`6729`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6705`	`6730`	`return NULL;`
`6706`	`6731`	`}`
`6707`	`6732`
`@@ -6715,8 +6740,7 @@ - (CFWriteStreamRef)writeStream`
`6715`	`6740`	`{`
`6716`	`6741`	`if (dispatch_get_current_queue() != socketQueue)`
`6717`	`6742`	`{`
`6718`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6719`		`- THIS_FILE, THIS_METHOD);`
	`6743`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6720`	`6744`	`return NULL;`
`6721`	`6745`	`}`
`6722`	`6746`
`@@ -6743,7 +6767,6 @@ - (BOOL)enableBackgroundingOnSocketWithCaveat:(BOOL)caveat`
`6743`	`6767`
`6744`	`6768`	`if (!r1 \|\| !r2)`
`6745`	`6769`	`{`
`6746`		`- LogError(@"Error setting voip type");`
`6747`	`6770`	`return NO;`
`6748`	`6771`	`}`
`6749`	`6772`
`@@ -6764,8 +6787,7 @@ - (BOOL)enableBackgroundingOnSocket`
`6764`	`6787`
`6765`	`6788`	`if (dispatch_get_current_queue() != socketQueue)`
`6766`	`6789`	`{`
`6767`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6768`		`- THIS_FILE, THIS_METHOD);`
	`6790`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6769`	`6791`	`return NO;`
`6770`	`6792`	`}`
`6771`	`6793`
`@@ -6782,8 +6804,7 @@ - (BOOL)enableBackgroundingOnSocketWithCaveat // Deprecated in iOS 4.???`
`6782`	`6804`
`6783`	`6805`	`if (dispatch_get_current_queue() != socketQueue)`
`6784`	`6806`	`{`
`6785`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6786`		`- THIS_FILE, THIS_METHOD);`
	`6807`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6787`	`6808`	`return NO;`
`6788`	`6809`	`}`
`6789`	`6810`
`@@ -6796,8 +6817,7 @@ - (SSLContextRef)sslContext`
`6796`	`6817`	`{`
`6797`	`6818`	`if (dispatch_get_current_queue() != socketQueue)`
`6798`	`6819`	`{`
`6799`		`- LogWarn(@"%@: %@ - Method only available from within the context of a performBlock: invocation",`
`6800`		`- THIS_FILE, THIS_METHOD);`
	`6820`	`+ LogWarn(@"%@ - Method only available from within the context of a performBlock: invocation", THIS_METHOD);`
`6801`	`6821`	`return NULL;`
`6802`	`6822`	`}`
`6803`	`6823`