Subversion Repositories Mobile Apps.GyroMouse

//

//  GCDAsyncSocket.m

//  

//  This class is in the public domain.

//  Originally created by Robbie Hanson in Q4 2010.

//  Updated and maintained by Deusty LLC and the Apple development community.

//

//  https://github.com/robbiehanson/CocoaAsyncSocket

//

#import "GCDAsyncSocket.h"

#if TARGET_OS_IPHONE

#import <CFNetwork/CFNetwork.h>

#endif

#import <TargetConditionals.h>

#import <arpa/inet.h>

#import <fcntl.h>

#import <ifaddrs.h>

#import <netdb.h>

#import <netinet/in.h>

#import <net/if.h>

#import <sys/socket.h>

#import <sys/types.h>

#import <sys/ioctl.h>

#import <sys/poll.h>

#import <sys/uio.h>

#import <sys/un.h>

#import <unistd.h>

#if ! __has_feature(objc_arc)

#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).

// For more information see: https://github.com/robbiehanson/CocoaAsyncSocket/wiki/ARC

#endif

#ifndef GCDAsyncSocketLoggingEnabled

#define GCDAsyncSocketLoggingEnabled 0

#endif

#if GCDAsyncSocketLoggingEnabled

// Logging Enabled - See log level below

// Logging uses the CocoaLumberjack framework (which is also GCD based).

// https://github.com/robbiehanson/CocoaLumberjack

//

// It allows us to do a lot of logging without significantly slowing down the code.

#import "DDLog.h"

#define LogAsync   YES

#define LogContext GCDAsyncSocketLoggingContext

#define LogObjc(flg, frmt, ...) LOG_OBJC_MAYBE(LogAsync, logLevel, flg, LogContext, frmt, ##__VA_ARGS__)

#define LogC(flg, frmt, ...)    LOG_C_MAYBE(LogAsync, logLevel, flg, LogContext, frmt, ##__VA_ARGS__)

#define LogError(frmt, ...)     LogObjc(LOG_FLAG_ERROR,   (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogWarn(frmt, ...)      LogObjc(LOG_FLAG_WARN,    (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogInfo(frmt, ...)      LogObjc(LOG_FLAG_INFO,    (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogVerbose(frmt, ...)   LogObjc(LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogCError(frmt, ...)    LogC(LOG_FLAG_ERROR,   (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogCWarn(frmt, ...)     LogC(LOG_FLAG_WARN,    (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogCInfo(frmt, ...)     LogC(LOG_FLAG_INFO,    (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogCVerbose(frmt, ...)  LogC(LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)

#define LogTrace()              LogObjc(LOG_FLAG_VERBOSE, @"%@: %@", THIS_FILE, THIS_METHOD)

#define LogCTrace()             LogC(LOG_FLAG_VERBOSE, @"%@: %s", THIS_FILE, __FUNCTION__)

#ifndef GCDAsyncSocketLogLevel

#define GCDAsyncSocketLogLevel LOG_LEVEL_VERBOSE

#endif

// Log levels : off, error, warn, info, verbose

static const int logLevel = GCDAsyncSocketLogLevel;

#else

// Logging Disabled

#define LogError(frmt, ...)     {}

#define LogWarn(frmt, ...)      {}

#define LogInfo(frmt, ...)      {}

#define LogVerbose(frmt, ...)   {}

#define LogCError(frmt, ...)    {}

#define LogCWarn(frmt, ...)     {}

#define LogCInfo(frmt, ...)     {}

#define LogCVerbose(frmt, ...)  {}

#define LogTrace()              {}

#define LogCTrace(frmt, ...)    {}

#endif

/**

 * Seeing a return statements within an inner block

 * can sometimes be mistaken for a return point of the enclosing method.

 * This makes inline blocks a bit easier to read.

**/

#define return_from_block  return

/**

 * A socket file descriptor is really just an integer.

 * It represents the index of the socket within the kernel.

 * This makes invalid file descriptor comparisons easier to read.

**/

#define SOCKET_NULL -1

NSString *const GCDAsyncSocketException = @"GCDAsyncSocketException";

NSString *const GCDAsyncSocketErrorDomain = @"GCDAsyncSocketErrorDomain";

NSString *const GCDAsyncSocketQueueName = @"GCDAsyncSocket";

NSString *const GCDAsyncSocketThreadName = @"GCDAsyncSocket-CFStream";

NSString *const GCDAsyncSocketManuallyEvaluateTrust = @"GCDAsyncSocketManuallyEvaluateTrust";

#if TARGET_OS_IPHONE

NSString *const GCDAsyncSocketUseCFStreamForTLS = @"GCDAsyncSocketUseCFStreamForTLS";

#endif

NSString *const GCDAsyncSocketSSLPeerID = @"GCDAsyncSocketSSLPeerID";

NSString *const GCDAsyncSocketSSLProtocolVersionMin = @"GCDAsyncSocketSSLProtocolVersionMin";

NSString *const GCDAsyncSocketSSLProtocolVersionMax = @"GCDAsyncSocketSSLProtocolVersionMax";

NSString *const GCDAsyncSocketSSLSessionOptionFalseStart = @"GCDAsyncSocketSSLSessionOptionFalseStart";

NSString *const GCDAsyncSocketSSLSessionOptionSendOneByteRecord = @"GCDAsyncSocketSSLSessionOptionSendOneByteRecord";

NSString *const GCDAsyncSocketSSLCipherSuites = @"GCDAsyncSocketSSLCipherSuites";

NSString *const GCDAsyncSocketSSLALPN = @"GCDAsyncSocketSSLALPN";

#if !TARGET_OS_IPHONE

NSString *const GCDAsyncSocketSSLDiffieHellmanParameters = @"GCDAsyncSocketSSLDiffieHellmanParameters";

#endif

enum GCDAsyncSocketFlags

{

        kSocketStarted                 = 1 <<  0,  // If set, socket has been started (accepting/connecting)

        kConnected                     = 1 <<  1,  // If set, the socket is connected

        kForbidReadsWrites             = 1 <<  2,  // If set, no new reads or writes are allowed

        kReadsPaused                   = 1 <<  3,  // If set, reads are paused due to possible timeout

        kWritesPaused                  = 1 <<  4,  // If set, writes are paused due to possible timeout

        kDisconnectAfterReads          = 1 <<  5,  // If set, disconnect after no more reads are queued

        kDisconnectAfterWrites         = 1 <<  6,  // If set, disconnect after no more writes are queued

        kSocketCanAcceptBytes          = 1 <<  7,  // If set, we know socket can accept bytes. If unset, it's unknown.

        kReadSourceSuspended           = 1 <<  8,  // If set, the read source is suspended

        kWriteSourceSuspended          = 1 <<  9,  // If set, the write source is suspended

        kQueuedTLS                     = 1 << 10,  // If set, we've queued an upgrade to TLS

        kStartingReadTLS               = 1 << 11,  // If set, we're waiting for TLS negotiation to complete

        kStartingWriteTLS              = 1 << 12,  // If set, we're waiting for TLS negotiation to complete

        kSocketSecure                  = 1 << 13,  // If set, socket is using secure communication via SSL/TLS

        kSocketHasReadEOF              = 1 << 14,  // If set, we have read EOF from socket

        kReadStreamClosed              = 1 << 15,  // If set, we've read EOF plus prebuffer has been drained

        kDealloc                       = 1 << 16,  // If set, the socket is being deallocated

#if TARGET_OS_IPHONE

        kAddedStreamsToRunLoop         = 1 << 17,  // If set, CFStreams have been added to listener thread

        kUsingCFStreamForTLS           = 1 << 18,  // If set, we're forced to use CFStream instead of SecureTransport

        kSecureSocketHasBytesAvailable = 1 << 19,  // If set, CFReadStream has notified us of bytes available

#endif

};

enum GCDAsyncSocketConfig

{

        kIPv4Disabled              = 1 << 0,  // If set, IPv4 is disabled

        kIPv6Disabled              = 1 << 1,  // If set, IPv6 is disabled

        kPreferIPv6                = 1 << 2,  // If set, IPv6 is preferred over IPv4

        kAllowHalfDuplexConnection = 1 << 3,  // If set, the socket will stay open even if the read stream closes

};

#if TARGET_OS_IPHONE

  static NSThread *cfstreamThread;  // Used for CFStreams

  static uint64_t cfstreamThreadRetainCount;   // setup & teardown

  static dispatch_queue_t cfstreamThreadSetupQueue; // setup & teardown

#endif

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma mark -

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * A PreBuffer is used when there is more data available on the socket

 * than is being requested by current read request.

 * In this case we slurp up all data from the socket (to minimize sys calls),

 * and store additional yet unread data in a "prebuffer".

 *

 * The prebuffer is entirely drained before we read from the socket again.

 * In other words, a large chunk of data is written is written to the prebuffer.

 * The prebuffer is then drained via a series of one or more reads (for subsequent read request(s)).

 *

 * A ring buffer was once used for this purpose.

 * But a ring buffer takes up twice as much memory as needed (double the size for mirroring).

 * In fact, it generally takes up more than twice the needed size as everything has to be rounded up to vm_page_size.

 * And since the prebuffer is always completely drained after being written to, a full ring buffer isn't needed.

 *

 * The current design is very simple and straight-forward, while also keeping memory requirements lower.

**/

@interface GCDAsyncSocketPreBuffer : NSObject

{

        uint8_t *preBuffer;

        size_t preBufferSize;

        uint8_t *readPointer;

        uint8_t *writePointer;

}

- (instancetype)initWithCapacity:(size_t)numBytes NS_DESIGNATED_INITIALIZER;

- (void)ensureCapacityForWrite:(size_t)numBytes;

- (size_t)availableBytes;

- (uint8_t *)readBuffer;

- (void)getReadBuffer:(uint8_t **)bufferPtr availableBytes:(size_t *)availableBytesPtr;

- (size_t)availableSpace;

- (uint8_t *)writeBuffer;

- (void)getWriteBuffer:(uint8_t **)bufferPtr availableSpace:(size_t *)availableSpacePtr;

- (void)didRead:(size_t)bytesRead;

- (void)didWrite:(size_t)bytesWritten;

- (void)reset;

@end

@implementation GCDAsyncSocketPreBuffer

// Cover the superclass' designated initializer

- (instancetype)init NS_UNAVAILABLE

{

        NSAssert(0, @"Use the designated initializer");

        return nil;

}

- (instancetype)initWithCapacity:(size_t)numBytes

{

        if ((self = [super init]))

        {

                preBufferSize = numBytes;

                preBuffer = malloc(preBufferSize);

                readPointer = preBuffer;

                writePointer = preBuffer;

        }

        return self;

}

- (void)dealloc

{

        if (preBuffer)

                free(preBuffer);

}

- (void)ensureCapacityForWrite:(size_t)numBytes

{

        size_t availableSpace = [self availableSpace];

        if (numBytes > availableSpace)

        {

                size_t additionalBytes = numBytes - availableSpace;

                size_t newPreBufferSize = preBufferSize + additionalBytes;

                uint8_t *newPreBuffer = realloc(preBuffer, newPreBufferSize);

                size_t readPointerOffset = readPointer - preBuffer;

                size_t writePointerOffset = writePointer - preBuffer;

                preBuffer = newPreBuffer;

                preBufferSize = newPreBufferSize;

                readPointer = preBuffer + readPointerOffset;

                writePointer = preBuffer + writePointerOffset;

        }

}

- (size_t)availableBytes

{

        return writePointer - readPointer;

}

- (uint8_t *)readBuffer

{

        return readPointer;

}

- (void)getReadBuffer:(uint8_t **)bufferPtr availableBytes:(size_t *)availableBytesPtr

{

        if (bufferPtr) *bufferPtr = readPointer;

        if (availableBytesPtr) *availableBytesPtr = [self availableBytes];

}

- (void)didRead:(size_t)bytesRead

{

        readPointer += bytesRead;

        if (readPointer == writePointer)

        {

                // The prebuffer has been drained. Reset pointers.

                readPointer  = preBuffer;

                writePointer = preBuffer;

        }

}

- (size_t)availableSpace

{

        return preBufferSize - (writePointer - preBuffer);

}

- (uint8_t *)writeBuffer

{

        return writePointer;

}

- (void)getWriteBuffer:(uint8_t **)bufferPtr availableSpace:(size_t *)availableSpacePtr

{

        if (bufferPtr) *bufferPtr = writePointer;

        if (availableSpacePtr) *availableSpacePtr = [self availableSpace];

}

- (void)didWrite:(size_t)bytesWritten

{

        writePointer += bytesWritten;

}

- (void)reset

{

        readPointer  = preBuffer;

        writePointer = preBuffer;

}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma mark -

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * The GCDAsyncReadPacket encompasses the instructions for any given read.

 * The content of a read packet allows the code to determine if we're:

 *  - reading to a certain length

 *  - reading to a certain separator

 *  - or simply reading the first chunk of available data

**/

@interface GCDAsyncReadPacket : NSObject

{

  @public

        NSMutableData *buffer;

        NSUInteger startOffset;

        NSUInteger bytesDone;

        NSUInteger maxLength;

        NSTimeInterval timeout;

        NSUInteger readLength;

        NSData *term;

        BOOL bufferOwner;

        NSUInteger originalBufferLength;

        long tag;

}

- (instancetype)initWithData:(NSMutableData *)d

                 startOffset:(NSUInteger)s

                   maxLength:(NSUInteger)m

                     timeout:(NSTimeInterval)t

                  readLength:(NSUInteger)l

                  terminator:(NSData *)e

                         tag:(long)i NS_DESIGNATED_INITIALIZER;

- (void)ensureCapacityForAdditionalDataOfLength:(NSUInteger)bytesToRead;

- (NSUInteger)optimalReadLengthWithDefault:(NSUInteger)defaultValue shouldPreBuffer:(BOOL *)shouldPreBufferPtr;

- (NSUInteger)readLengthForNonTermWithHint:(NSUInteger)bytesAvailable;

- (NSUInteger)readLengthForTermWithHint:(NSUInteger)bytesAvailable shouldPreBuffer:(BOOL *)shouldPreBufferPtr;

- (NSUInteger)readLengthForTermWithPreBuffer:(GCDAsyncSocketPreBuffer *)preBuffer found:(BOOL *)foundPtr;

- (NSInteger)searchForTermAfterPreBuffering:(ssize_t)numBytes;

@end

@implementation GCDAsyncReadPacket

// Cover the superclass' designated initializer

- (instancetype)init NS_UNAVAILABLE

{

        NSAssert(0, @"Use the designated initializer");

        return nil;

}

- (instancetype)initWithData:(NSMutableData *)d

                 startOffset:(NSUInteger)s

                   maxLength:(NSUInteger)m

                     timeout:(NSTimeInterval)t

                  readLength:(NSUInteger)l

                  terminator:(NSData *)e

                         tag:(long)i

{

        if((self = [super init]))

        {

                bytesDone = 0;

                maxLength = m;

                timeout = t;

                readLength = l;

                term = [e copy];

                tag = i;

                if (d)

                {

                        buffer = d;

                        startOffset = s;

                        bufferOwner = NO;

                        originalBufferLength = [d length];

                }

                else

                {

                        if (readLength > 0)

                                buffer = [[NSMutableData alloc] initWithLength:readLength];

                        else

                                buffer = [[NSMutableData alloc] initWithLength:0];

                        startOffset = 0;

                        bufferOwner = YES;

                        originalBufferLength = 0;

                }

        }

        return self;

}

/**

 * Increases the length of the buffer (if needed) to ensure a read of the given size will fit.

**/

- (void)ensureCapacityForAdditionalDataOfLength:(NSUInteger)bytesToRead

{

        NSUInteger buffSize = [buffer length];

        NSUInteger buffUsed = startOffset + bytesDone;

        NSUInteger buffSpace = buffSize - buffUsed;

        if (bytesToRead > buffSpace)

        {

                NSUInteger buffInc = bytesToRead - buffSpace;

                [buffer increaseLengthBy:buffInc];

        }

}

/**

 * This method is used when we do NOT know how much data is available to be read from the socket.

 * This method returns the default value unless it exceeds the specified readLength or maxLength.

 *

 * Furthermore, the shouldPreBuffer decision is based upon the packet type,

 * and whether the returned value would fit in the current buffer without requiring a resize of the buffer.

**/

- (NSUInteger)optimalReadLengthWithDefault:(NSUInteger)defaultValue shouldPreBuffer:(BOOL *)shouldPreBufferPtr

{

        NSUInteger result;

        if (readLength > 0)

        {

                // Read a specific length of data

                result = readLength - bytesDone;

                // There is no need to prebuffer since we know exactly how much data we need to read.

                // Even if the buffer isn't currently big enough to fit this amount of data,

                // it would have to be resized eventually anyway.

                if (shouldPreBufferPtr)

                        *shouldPreBufferPtr = NO;

        }

        else

        {

                // Either reading until we find a specified terminator,

                // or we're simply reading all available data.

                //

                // In other words, one of:

                //

                // - readDataToData packet

                // - readDataWithTimeout packet

                if (maxLength > 0)

                        result =  MIN(defaultValue, (maxLength - bytesDone));

                else

                        result = defaultValue;

                // Since we don't know the size of the read in advance,

                // the shouldPreBuffer decision is based upon whether the returned value would fit

                // in the current buffer without requiring a resize of the buffer.

                //

                // This is because, in all likelyhood, the amount read from the socket will be less than the default value.

                // Thus we should avoid over-allocating the read buffer when we can simply use the pre-buffer instead.

                if (shouldPreBufferPtr)

                {

                        NSUInteger buffSize = [buffer length];

                        NSUInteger buffUsed = startOffset + bytesDone;

                        NSUInteger buffSpace = buffSize - buffUsed;

                        if (buffSpace >= result)

                                *shouldPreBufferPtr = NO;

                        else

                                *shouldPreBufferPtr = YES;

                }

        }

        return result;

}

/**

 * For read packets without a set terminator, returns the amount of data

 * that can be read without exceeding the readLength or maxLength.

 *

 * The given parameter indicates the number of bytes estimated to be available on the socket,

 * which is taken into consideration during the calculation.

 *

 * The given hint MUST be greater than zero.

**/

- (NSUInteger)readLengthForNonTermWithHint:(NSUInteger)bytesAvailable

{

        NSAssert(term == nil, @"This method does not apply to term reads");

        NSAssert(bytesAvailable > 0, @"Invalid parameter: bytesAvailable");

        if (readLength > 0)

        {

                // Read a specific length of data

                return MIN(bytesAvailable, (readLength - bytesDone));

                // No need to avoid resizing the buffer.

                // If the user provided their own buffer,

                // and told us to read a certain length of data that exceeds the size of the buffer,

                // then it is clear that our code will resize the buffer during the read operation.

                //

                // This method does not actually do any resizing.

                // The resizing will happen elsewhere if needed.

        }

        else

        {

                // Read all available data

                NSUInteger result = bytesAvailable;

                if (maxLength > 0)

                {

                        result = MIN(result, (maxLength - bytesDone));

                }

                // No need to avoid resizing the buffer.

                // If the user provided their own buffer,

                // and told us to read all available data without giving us a maxLength,

                // then it is clear that our code might resize the buffer during the read operation.

                //

                // This method does not actually do any resizing.

                // The resizing will happen elsewhere if needed.

                return result;

        }

}

/**

 * For read packets with a set terminator, returns the amount of data

 * that can be read without exceeding the maxLength.

 *

 * The given parameter indicates the number of bytes estimated to be available on the socket,

 * which is taken into consideration during the calculation.

 *

 * To optimize memory allocations, mem copies, and mem moves

 * the shouldPreBuffer boolean value will indicate if the data should be read into a prebuffer first,

 * or if the data can be read directly into the read packet's buffer.

**/

- (NSUInteger)readLengthForTermWithHint:(NSUInteger)bytesAvailable shouldPreBuffer:(BOOL *)shouldPreBufferPtr

{

        NSAssert(term != nil, @"This method does not apply to non-term reads");

        NSAssert(bytesAvailable > 0, @"Invalid parameter: bytesAvailable");

        NSUInteger result = bytesAvailable;

        if (maxLength > 0)

        {

                result = MIN(result, (maxLength - bytesDone));

        }

        // Should the data be read into the read packet's buffer, or into a pre-buffer first?

        //

        // One would imagine the preferred option is the faster one.

        // So which one is faster?

        //

        // Reading directly into the packet's buffer requires:

        // 1. Possibly resizing packet buffer (malloc/realloc)

        // 2. Filling buffer (read)

        // 3. Searching for term (memcmp)

        // 4. Possibly copying overflow into prebuffer (malloc/realloc, memcpy)

        //

        // Reading into prebuffer first:

        // 1. Possibly resizing prebuffer (malloc/realloc)

        // 2. Filling buffer (read)

        // 3. Searching for term (memcmp)

        // 4. Copying underflow into packet buffer (malloc/realloc, memcpy)

        // 5. Removing underflow from prebuffer (memmove)

        //

        // Comparing the performance of the two we can see that reading

        // data into the prebuffer first is slower due to the extra memove.

        //

        // However:

        // The implementation of NSMutableData is open source via core foundation's CFMutableData.

        // Decreasing the length of a mutable data object doesn't cause a realloc.

        // In other words, the capacity of a mutable data object can grow, but doesn't shrink.

        //

        // This means the prebuffer will rarely need a realloc.

        // The packet buffer, on the other hand, may often need a realloc.

        // This is especially true if we are the buffer owner.

        // Furthermore, if we are constantly realloc'ing the packet buffer,

        // and then moving the overflow into the prebuffer,

        // then we're consistently over-allocating memory for each term read.

        // And now we get into a bit of a tradeoff between speed and memory utilization.

        //

        // The end result is that the two perform very similarly.

        // And we can answer the original question very simply by another means.

        //

        // If we can read all the data directly into the packet's buffer without resizing it first,

        // then we do so. Otherwise we use the prebuffer.

        if (shouldPreBufferPtr)

        {

                NSUInteger buffSize = [buffer length];

                NSUInteger buffUsed = startOffset + bytesDone;

                if ((buffSize - buffUsed) >= result)

                        *shouldPreBufferPtr = NO;

                else

                        *shouldPreBufferPtr = YES;

        }

        return result;

}

/**

 * For read packets with a set terminator,

 * returns the amount of data that can be read from the given preBuffer,

 * without going over a terminator or the maxLength.

 *

 * It is assumed the terminator has not already been read.

**/

- (NSUInteger)readLengthForTermWithPreBuffer:(GCDAsyncSocketPreBuffer *)preBuffer found:(BOOL *)foundPtr

{

        NSAssert(term != nil, @"This method does not apply to non-term reads");

        NSAssert([preBuffer availableBytes] > 0, @"Invoked with empty pre buffer!");

        // We know that the terminator, as a whole, doesn't exist in our own buffer.

        // But it is possible that a _portion_ of it exists in our buffer.

        // So we're going to look for the terminator starting with a portion of our own buffer.

        //

        // Example:

        //

        // term length      = 3 bytes

        // bytesDone        = 5 bytes

        // preBuffer length = 5 bytes

        //

        // If we append the preBuffer to our buffer,

        // it would look like this:

        //

        // ---------------------

        // |B|B|B|B|B|P|P|P|P|P|

        // ---------------------

        //

        // So we start our search here:

        //

        // ---------------------

        // |B|B|B|B|B|P|P|P|P|P|

        // -------^-^-^---------

        //

        // And move forwards...

        //

        // ---------------------

        // |B|B|B|B|B|P|P|P|P|P|

        // ---------^-^-^-------

        //

        // Until we find the terminator or reach the end.

        //

        // ---------------------

        // |B|B|B|B|B|P|P|P|P|P|

        // ---------------^-^-^-

        BOOL found = NO;

        NSUInteger termLength = [term length];

        NSUInteger preBufferLength = [preBuffer availableBytes];

        if ((bytesDone + preBufferLength) < termLength)

        {

                // Not enough data for a full term sequence yet

                return preBufferLength;

        }

        NSUInteger maxPreBufferLength;

        if (maxLength > 0) {

                maxPreBufferLength = MIN(preBufferLength, (maxLength - bytesDone));

                // Note: maxLength >= termLength

        }

        else {

                maxPreBufferLength = preBufferLength;

        }

        uint8_t seq[termLength];

        const void *termBuf = [term bytes];

        NSUInteger bufLen = MIN(bytesDone, (termLength - 1));

        uint8_t *buf = (uint8_t *)[buffer mutableBytes] + startOffset + bytesDone - bufLen;

        NSUInteger preLen = termLength - bufLen;

        const uint8_t *pre = [preBuffer readBuffer];

        NSUInteger loopCount = bufLen + maxPreBufferLength - termLength + 1; // Plus one. See example above.

        NSUInteger result = maxPreBufferLength;

        NSUInteger i;

        for (i = 0; i < loopCount; i++)

        {

                if (bufLen > 0)

                {

                        // Combining bytes from buffer and preBuffer

                        memcpy(seq, buf, bufLen);

                        memcpy(seq + bufLen, pre, preLen);

                        if (memcmp(seq, termBuf, termLength) == 0)

                        {

                                result = preLen;

                                found = YES;

                                break;

                        }

                        buf++;

                        bufLen--;

                        preLen++;

                }

                else

                {

                        // Comparing directly from preBuffer

                        if (memcmp(pre, termBuf, termLength) == 0)

                        {

                                NSUInteger preOffset = pre - [preBuffer readBuffer]; // pointer arithmetic

                                result = preOffset + termLength;

                                found = YES;

                                break;

                        }

                        pre++;

                }

        }

        // There is no need to avoid resizing the buffer in this particular situation.

        if (foundPtr) *foundPtr = found;

        return result;

}

/**

 * For read packets with a set terminator, scans the packet buffer for the term.

 * It is assumed the terminator had not been fully read prior to the new bytes.

 *

 * If the term is found, the number of excess bytes after the term are returned.

 * If the term is not found, this method will return -1.

 *

 * Note: A return value of zero means the term was found at the very end.

 *

 * Prerequisites:

 * The given number of bytes have been added to the end of our buffer.

 * Our bytesDone variable has NOT been changed due to the prebuffered bytes.

**/

- (NSInteger)searchForTermAfterPreBuffering:(ssize_t)numBytes

{

        NSAssert(term != nil, @"This method does not apply to non-term reads");

        // The implementation of this method is very similar to the above method.

        // See the above method for a discussion of the algorithm used here.

        uint8_t *buff = [buffer mutableBytes];

        NSUInteger buffLength = bytesDone + numBytes;

        const void *termBuff = [term bytes];

        NSUInteger termLength = [term length];

        // Note: We are dealing with unsigned integers,

        // so make sure the math doesn't go below zero.

        NSUInteger i = ((buffLength - numBytes) >= termLength) ? (buffLength - numBytes - termLength + 1) : 0;

        while (i + termLength <= buffLength)

        {

                uint8_t *subBuffer = buff + startOffset + i;

                if (memcmp(subBuffer, termBuff, termLength) == 0)

                {

                        return buffLength - (i + termLength);

                }

                i++;

        }

        return -1;

}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma mark -

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * The GCDAsyncWritePacket encompasses the instructions for any given write.

**/

@interface GCDAsyncWritePacket : NSObject

{

  @public

        NSData *buffer;

        NSUInteger bytesDone;

        long tag;

        NSTimeInterval timeout;

}

- (instancetype)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i NS_DESIGNATED_INITIALIZER;

@end

@implementation GCDAsyncWritePacket

// Cover the superclass' designated initializer

- (instancetype)init NS_UNAVAILABLE

{

        NSAssert(0, @"Use the designated initializer");

        return nil;

}

- (instancetype)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i

{

        if((self = [super init]))

        {

                buffer = d; // Retain not copy. For performance as documented in header file.

                bytesDone = 0;

                timeout = t;

                tag = i;

        }

        return self;

}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma mark -

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * The GCDAsyncSpecialPacket encompasses special instructions for interruptions in the read/write queues.

 * This class my be altered to support more than just TLS in the future.

**/

@interface GCDAsyncSpecialPacket : NSObject

{

  @public

        NSDictionary *tlsSettings;

}

- (instancetype)initWithTLSSettings:(NSDictionary <NSString*,NSObject*>*)settings NS_DESIGNATED_INITIALIZER;

@end

@implementation GCDAsyncSpecialPacket

// Cover the superclass' designated initializer

- (instancetype)init NS_UNAVAILABLE

{

        NSAssert(0, @"Use the designated initializer");

        return nil;

}

- (instancetype)initWithTLSSettings:(NSDictionary <NSString*,NSObject*>*)settings

{

        if((self = [super init]))

        {

                tlsSettings = [settings copy];

        }

        return self;

}

@end

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma mark -

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

@implementation GCDAsyncSocket

{

        uint32_t flags;

        uint16_t config;

        __weak id<GCDAsyncSocketDelegate> delegate;

        dispatch_queue_t delegateQueue;

        int socket4FD;

        int socket6FD;

        int socketUN;

        NSURL *socketUrl;

        int stateIndex;

        NSData * connectInterface4;

        NSData * connectInterface6;

        NSData * connectInterfaceUN;

        dispatch_queue_t socketQueue;

        dispatch_source_t accept4Source;

        dispatch_source_t accept6Source;

        dispatch_source_t acceptUNSource;

        dispatch_source_t connectTimer;

        dispatch_source_t readSource;

        dispatch_source_t writeSource;

        dispatch_source_t readTimer;

        dispatch_source_t writeTimer;

        NSMutableArray *readQueue;

        NSMutableArray *writeQueue;

        GCDAsyncReadPacket *currentRead;

        GCDAsyncWritePacket *currentWrite;

        unsigned long socketFDBytesAvailable;

        GCDAsyncSocketPreBuffer *preBuffer;

#if TARGET_OS_IPHONE

        CFStreamClientContext streamContext;

        CFReadStreamRef readStream;

        CFWriteStreamRef writeStream;

#endif

        SSLContextRef sslContext;

        GCDAsyncSocketPreBuffer *sslPreBuffer;

        size_t sslWriteCachedLength;

        OSStatus sslErrCode;

    OSStatus lastSSLHandshakeError;

        void *IsOnSocketQueueOrTargetQueueKey;

        id userData;

    NSTimeInterval alternateAddressDelay;

}