iOS即时通讯之CocoaAsyncSocket源码解析五

接上篇：iOS即时通讯之CocoaAsyncSocket源码解析四         原文

前言：

本文为CocoaAsyncSocket Read篇终，将重点涉及该框架是如何利用缓冲区对数据进行读取、以及各种情况下的数据包处理，其中还包括普通的、和基于TLS的不同读取操作等等。

正文：

前文讲完了两次TLS建立连接的流程，接着就是本篇的重头戏了：doReadData方法。在这里我不准备直接把这个整个方法列出来，因为就光这一个方法，加上注释有1200行，整个贴过来也无法展开描述，所以在这里我打算对它分段进行讲解：

注：以下代码整个包括在doReadData大括号中：

//读取数据
- (void)doReadData
{
  ....
}

Part1.无法正常读取数据时的前置处理:

 //如果当前读取的包为空，或者flag为读取停止,这两种情况是不能去读取数据的
 if ((currentRead == nil) || (flags & kReadsPaused))
 {
      LogVerbose(@"No currentRead or kReadsPaused");

      // Unable to read at this time
      //如果是安全的通信，通过TLS/SSL
      if (flags & kSocketSecure)
      {
        //刷新SSLBuffer,把数据从链路上移到prebuffer中 (当前不读取数据的时候做)
           [self flushSSLBuffers];
      }

    //判断是否用的是 CFStream的TLS
      if ([self usingCFStreamForTLS])
      {

      }
      else
      {
        //挂起source
           if (socketFDBytesAvailable > )
           {
                [self suspendReadSource];
           }
      }
      return;
 }

当我们当前读取的包是空或者标记为读停止状态的时候，则不会去读取数据。
前者不难理解，因为我们要读取的数据最终是要传给currentRead中去的，所以如果currentRead为空，我们去读数据也没有意义。
后者kReadsPaused标记是从哪里加上的呢？我们全局搜索一下，发现它才read超时的时候被添加。
讲到这我们顺便来看这个读取超时的一个逻辑，我们每次做读取任务传进来的超时，都会调用这么一个方法：

[self setupReadTimerWithTimeout:currentRead->timeout];

 //初始化读的超时
 - (void)setupReadTimerWithTimeout:(NSTimeInterval)timeout
 {
     if (timeout >= 0.0)
     {
         //生成一个定时器source
         readTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, , , socketQueue);

         __weak GCDAsyncSocket *weakSelf = self;

         //句柄
         dispatch_source_set_event_handler(readTimer, ^{ @autoreleasepool {
         #pragma clang diagnostic push
         #pragma clang diagnostic warning "-Wimplicit-retain-self"

             __strong GCDAsyncSocket *strongSelf = weakSelf;
             if (strongSelf == nil) return_from_block;

             //执行超时操作
             [strongSelf doReadTimeout];

         #pragma clang diagnostic pop
         }});

         #if !OS_OBJECT_USE_OBJC
         dispatch_source_t theReadTimer = readTimer;

         //取消的句柄
         dispatch_source_set_cancel_handler(readTimer, ^{
         #pragma clang diagnostic push
         #pragma clang diagnostic warning "-Wimplicit-retain-self"

             LogVerbose(@"dispatch_release(readTimer)");
             dispatch_release(theReadTimer);

         #pragma clang diagnostic pop
         });
         #endif

         //定时器延时 timeout时间执行
         dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeout * NSEC_PER_SEC));
         //间隔为永远，即只执行一次
         dispatch_source_set_timer(readTimer, tt, DISPATCH_TIME_FOREVER, );
         dispatch_resume(readTimer);
     }
 } 

这个方法定义了一个GCD定时器，这个定时器只执行一次，间隔就是我们的超时，很显然这是一个延时执行，那小伙伴要问了，这里为什么我们不用NSTimer或者下面这种方式：

[self performSelector:<#(nonnull SEL)#> withObject:<#(nullable id)#> afterDelay:<#(NSTimeInterval)#>

原因很简单，performSelector是基于runloop才能使用的，它本质是转化成runloop基于非端口的源source0。很显然我们所在的socketQueue开辟出来的线程，并没有添加一个runloop。而NSTimer也是一样。

所以这里我们用GCD Timer，因为它是基于XNU内核来实现的，并不需要借助于runloop。

这里当超时时间间隔到达时，我们会执行超时操作：

[strongSelf doReadTimeout];

 /执行超时操作
 - (void)doReadTimeout
 {
     // This is a little bit tricky.
     // Ideally we'd like to synchronously query the delegate about a timeout extension.
     // But if we do so synchronously we risk a possible deadlock.
     // So instead we have to do so asynchronously, and callback to ourselves from within the delegate block.

     //因为这里用同步容易死锁，所以用异步从代理中回调

     //标记读暂停
     flags |= kReadsPaused;

     __strong id theDelegate = delegate;

     //判断是否实现了延时  补时的代理
     if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:shouldTimeoutReadWithTag:elapsed:bytesDone:)])
     {
         //拿到当前读的包
         GCDAsyncReadPacket *theRead = currentRead;

         //代理queue中回调
         dispatch_async(delegateQueue, ^{ @autoreleasepool {

             NSTimeInterval timeoutExtension = 0.0;

             //调用代理方法，拿到续的时长
             timeoutExtension = [theDelegate socket:self shouldTimeoutReadWithTag:theRead->tag
                                                                          elapsed:theRead->timeout
                                                                        bytesDone:theRead->bytesDone];

             //socketQueue中，做延时
             dispatch_async(socketQueue, ^{ @autoreleasepool {

                 [self doReadTimeoutWithExtension:timeoutExtension];
             }});
         }});
     }
     else
     {
         [self doReadTimeoutWithExtension:0.0];
     }
 }

//做读取数据延时
- (void)doReadTimeoutWithExtension:(NSTimeInterval)timeoutExtension
{
    if (currentRead)
    {
        if (timeoutExtension > 0.0)
        {
            //把超时加上
            currentRead->timeout += timeoutExtension;

            // Reschedule the timer
            //重新生成时间
            dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeoutExtension * NSEC_PER_SEC));
            //重置timer时间
            dispatch_source_set_timer(readTimer, tt, DISPATCH_TIME_FOREVER, );

            // Unpause reads, and continue
            //在把paused标记移除
            flags &= ~kReadsPaused;
            //继续去读取数据
            [self doReadData];
        }
        else
        {
            //输出读取超时，并断开连接
            LogVerbose(@"ReadTimeout");

            [self closeWithError:[self readTimeoutError]];
        }
    }
}

这里调用了续时代理，如果我们实现了这个代理，则可以增加这个超时时间，然后重新生成超时定时器，移除读取停止的标记kReadsPaused。继续去读取数据。
否则我们就断开socket。
注意：这个定时器会被取消，如果当前数据包被读取完成，这样就不会走到定时器超时的时间，则不会断开socket。讲到这是不是大家就有印象了？这个就是之前在楼主：
iOS即时通讯，从入门到“放弃”？中讲过的可以被用来做PingPong机制的原理。

我们接着回到doReadData中，我们讲到如果当前读取包为空或者状态为kReadsPaused，我们就去执行一些非读取数据的处理。
这里我们第一步去判断当前连接是否为kSocketSecure，也就是安全通道的TLS。如果是我们则调用

if (flags & kSocketSecure)
{
     //刷新,把TLS加密型的数据从链路上移到prebuffer中 (当前暂停的时候做)
     [self flushSSLBuffers];
}

按理说，我们有当前读取包的时候，在去从prebuffer、socket中去读取，但是这里为什么要提前去读呢？
我们来看看这个框架作者的解释：

// Here's the situation:
// We have an established secure connection.
// There may not be a currentRead, but there might be encrypted data sitting around for us.
// When the user does get around to issuing a read, that encrypted data will need to be decrypted.
// So why make the user wait?
// We might as well get a head start on decrypting some data now.
// The other reason we do this has to do with detecting a socket disconnection.
// The SSL/TLS protocol has it's own disconnection handshake.
// So when a secure socket is closed, a "goodbye" packet comes across the wire.
// We want to make sure we read the "goodbye" packet so we can properly detect the TCP disconnection.

简单来讲，就是我们用TLS类型的Socket，读取数据的时候需要解密的过程，而这个过程是费时的，我们没必要让用户在读取数据的时候去等待这个解密的过程，我们可以提前在数据一到达，就去读取解密。
而且这种方式，还能时刻根据TLS的goodbye包来准确的检测到TCP断开连接。

在我们来看flushSSLBuffers方法之前，我们先来看看这个一直提到的全局缓冲区prebuffer的定义，它其实就是下面这么一个类的实例：

Part3.GCDAsyncSocketPreBuffer的定义

@interface GCDAsyncSocketPreBuffer : NSObject
{
    //unsigned char
    //提前的指针，指向这块提前的缓冲区
    uint8_t *preBuffer;
    //size_t 它是一个与机器相关的unsigned类型，其大小足以保证存储内存中对象的大小。
    //它可以存储在理论上是可能的任何类型的数组的最大大小
    size_t preBufferSize;
    //读的指针
    uint8_t *readPointer;
    //写的指针
    uint8_t *writePointer;
}

里面存了3个指针，包括preBuffer起点指针、当前读写所处位置指针、以及一个preBufferSize，这个size为preBuffer所指向的位置，在内存中分配的空间大小。

我们来看看它的几个方法：

//初始化
- (id)initWithCapacity:(size_t)numBytes
{
    if ((self = [super init]))
    {
        //设置size
        preBufferSize = numBytes;
        //申请size大小的内存给preBuffer
        preBuffer = malloc(preBufferSize);

        //为同一个值
        readPointer = preBuffer;
        writePointer = preBuffer;
    }
    return self;
}

包括一个初始化方法，去初始化preBufferSize大小的一块内存空间。然后3个指针都指向这个空间。

- (void)dealloc
{
    if (preBuffer)
        free(preBuffer);
}

销毁的方法：释放preBuffer。

 //确认读的大小
 - (void)ensureCapacityForWrite:(size_t)numBytes
 {
     //拿到当前可用的空间大小
     size_t availableSpace = [self availableSpace];

     //如果申请的大小大于可用的大小
     if (numBytes > availableSpace)
     {
         //需要多出来的大小
         size_t additionalBytes = numBytes - availableSpace;
         //新的总大小
         size_t newPreBufferSize = preBufferSize + additionalBytes;
         //重新去分配preBuffer
         uint8_t *newPreBuffer = realloc(preBuffer, newPreBufferSize);

         //读的指针偏移量（已读大小）
         size_t readPointerOffset = readPointer - preBuffer;
         //写的指针偏移量（已写大小）
         size_t writePointerOffset = writePointer - preBuffer;
         //提前的Buffer重新复制
         preBuffer = newPreBuffer;
         //大小重新赋值
         preBufferSize = newPreBufferSize;

         //读写指针重新赋值 + 上偏移量
         readPointer = preBuffer + readPointerOffset;
         writePointer = preBuffer + writePointerOffset;
     }
 }

确保prebuffer可用空间的方法：这个方法会重新分配preBuffer，直到可用大小等于传递进来的numBytes，已用大小不会变。

 //仍然可读的数据，过程是先写后读，只有写的大于读的，才能让你继续去读，不然没数据可读了
 - (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;
     }
 }
 //prebuffer的剩余空间  = preBufferSize（总大小） - （写的头指针 - 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;
 }

然后就是对读写指针进行处理的方法，如果读了多少数据readPointer就后移多少，写也是一样。
而获取当前未读数据，则是用已写指针-已读指针，得到的差值，当已读=已写的时候，说明prebuffer数据读完，则重置读写指针的位置，还是指向初始化位置。

讲完全局缓冲区对于指针的处理，我们接着往下说

Part4.flushSSLBuffers方法：

 //缓冲ssl数据
 - (void)flushSSLBuffers
 {
      LogTrace();
      //断言为安全Socket
      NSAssert((flags & kSocketSecure), @"Cannot flush ssl buffers on non-secure socket");
      //如果preBuffer有数据可读,直接返回
      if ([preBuffer availableBytes] > )
      {
           return;
      }

      #if TARGET_OS_IPHONE
      //如果用的CFStream的TLS，把数据用CFStream的方式搬运到preBuffer中
      if ([self usingCFStreamForTLS])
      {
         //如果flag为kSecureSocketHasBytesAvailable，而且readStream有数据可读
           if ((flags & kSecureSocketHasBytesAvailable) && CFReadStreamHasBytesAvailable(readStream))
           {
                LogVerbose(@"%@ - Flushing ssl buffers into prebuffer...", THIS_METHOD);

             //默认一次读的大小为4KB？？
                CFIndex defaultBytesToRead = ( * );

             //用来确保有这么大的提前buffer缓冲空间
                [preBuffer ensureCapacityForWrite:defaultBytesToRead];
                //拿到写的buffer
                uint8_t *buffer = [preBuffer writeBuffer];

             //从readStream中去读， 一次就读4KB，读到数据后，把数据写到writeBuffer中去   如果读的大小小于readStream中数据流大小，则会不停的触发callback，直到把数据读完为止。
                CFIndex result = CFReadStreamRead(readStream, buffer, defaultBytesToRead);
             //打印结果
                LogVerbose(@"%@ - CFReadStreamRead(): result = %i", THIS_METHOD, (int)result);

             //大于0，说明读写成功
                if (result > )
                {
                 //把写的buffer头指针，移动result个偏移量
                     [preBuffer didWrite:result];
                }

             //把kSecureSocketHasBytesAvailable 仍然可读的标记移除
                flags &= ~kSecureSocketHasBytesAvailable;
           }

           return;
      }

      #endif

     //不用CFStream的处理方法

     //先设置一个预估可用的大小
      __block NSUInteger estimatedBytesAvailable = ;
      //更新预估可用的Block
      dispatch_block_t updateEstimatedBytesAvailable = ^{

         //预估大小 = 未读的大小 + SSL的可读大小
           estimatedBytesAvailable = socketFDBytesAvailable + [sslPreBuffer availableBytes];

           size_t sslInternalBufSize = ;
         //获取到ssl上下文的大小，从sslContext中
           SSLGetBufferedReadSize(sslContext, &sslInternalBufSize);
           //再加上下文的大小
           estimatedBytesAvailable += sslInternalBufSize;
      };

     //调用这个Block
      updateEstimatedBytesAvailable();

     //如果大于0，说明有数据可读
      if (estimatedBytesAvailable > )
      {

           LogVerbose(@"%@ - Flushing ssl buffers into prebuffer...", THIS_METHOD);

         //标志，循环是否结束,SSL的方式是会阻塞的，直到读的数据有estimatedBytesAvailable大小为止，或者出错
           BOOL done = NO;
           do
           {
                LogVerbose(@"%@ - estimatedBytesAvailable = %lu", THIS_METHOD, (unsigned long)estimatedBytesAvailable);

                // Make sure there's enough room in the prebuffer
                //确保有足够的空间给prebuffer
                [preBuffer ensureCapacityForWrite:estimatedBytesAvailable];

                // Read data into prebuffer
                //拿到写的buffer
                uint8_t *buffer = [preBuffer writeBuffer];
                size_t bytesRead = ;
                //用SSLRead函数去读，读到后，把数据写到buffer中，estimatedBytesAvailable为需要读的大小，bytesRead这一次实际读到字节大小，为sslContext上下文
                OSStatus result = SSLRead(sslContext, buffer, (size_t)estimatedBytesAvailable, &bytesRead);
                LogVerbose(@"%@ - read from secure socket = %u", THIS_METHOD, (unsigned)bytesRead);

             //把写指针后移bytesRead大小
                if (bytesRead > )
                {
                     [preBuffer didWrite:bytesRead];
                }

                LogVerbose(@"%@ - prebuffer.length = %zu", THIS_METHOD, [preBuffer availableBytes]);

             //如果读数据出现错误
                if (result != noErr)
                {
                     done = YES;
                }
                else
                {
                 //在更新一下可读的数据大小
                     updateEstimatedBytesAvailable();
                }

           }
         //只有done为NO,而且 estimatedBytesAvailable大于0才继续循环
         while (!done && estimatedBytesAvailable > );
      }
 }

这个方法有点略长，包含了两种SSL的数据处理：

1. CFStream类型：我们会调用下面这个函数去从stream并且读取数据并解密：

2. CFIndex result = CFReadStreamRead(readStream, buffer, defaultBytesToRead);

   数据被读取到后，直接转移到了prebuffer中，并且调用：

3. [preBuffer didWrite:result];

   让写指针后移读取到的数据大小。
   这里有两个关于CFReadStreamRead方法，需要注意的问题：
   1）就是我们调用它去读取4KB数据，并不仅仅是只读这么多，而是因为这个方法是会递归调用的，它每次只读4KB，直到把stream中的数据读完。
   2）我们之前设置的CFStream函数的回调，在数据来了之后只会被触发一次，以后数据再来都不会触发。直到我们调用这个方法，把stream中的数据读完，下次再来数据才会触发函数回调。这也是我们在使用CFStream的时候，不需要担心像source那样，有数据会不断的被触发回调，而需要挂起像source那样挂起stream（实际也没有这样的方法）。

2. SSL安全通道类型：这里我们主要是循环去调用下面这个函数去读取数据：

OSStatus result = SSLRead(sslContext, buffer, (size_t)estimatedBytesAvailable, &bytesRead);

其他的基本和CFStream一致

这里需要注意的是SSLRead这个方法，并不是直接从我们的socket中获取到的数据，而是从我们一开始绑定的SSL回调函数中，得到数据。而回调函数本身，也需要调用read函数从socket中获取到加密的数据。然后再经由SSLRead这个方法，数据被解密，并且传递给buffer。

至于SSLRead绑定的回调函数，是怎么处理数据读取的，因为它处理数据的流程，和我们doReadData后续数据读取处理基本相似，所以现在暂时不提。

我们绕了一圈，讲完了这个包为空或者当前暂停状态下的前置处理，总结一下：

1. 就是如果是SSL类型的数据，那么先解密了，缓冲到prebuffer中去。
2. 判断当前socket可读数据大于0，非CFStreamSSL类型，则挂起source，防止反复触发。

Part5.接着我们开始doReadData正常数据处理流程：

首先它大的方向，依然是分为3种类型的数据处理：
1.SSL安全通道； 2.CFStream类型SSL； 3.普通数据传输。
因为这3种类型的代码，重复部分较大，处理流程基本类似，只不过调用读取方法所有区别：

//1.
OSStatus result = SSLRead(sslContext, buffer, (size_t)estimatedBytesAvailable, &bytesRead);
//2.
CFIndex result = CFReadStreamRead(readStream, buffer, defaultBytesToRead);
//3.
ssize_t result = read(socketFD, buffer, (size_t)bytesToRead);

而SSLRead回调函数内部，也调用了第3种read读取，这个我们后面会说。
现在这里我们将跳过前两种（方法部分调用可以见上面的flushSSLBuffers方法），只讲第3种普通数据的读取操作，而SSL的读取操作，基本一致。

先来看看当前数据包任务是否完成，是如何定义的：

由于框架提供的对外read接口：

- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag;
- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;

将数据读取是否完成的操作，大致分为这3个类型：
1.全读；2读取一定的长度；3读取到某个标记符为止。

当且仅当上面3种类型对应的操作完成，才视作当前包任务完成，才会回调我们在类中声明的读取消息的代理：

- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag

否则就等待着，直到当前数据包任务完成。

然后我们读取数据的流程大致如下：

先从prebuffer中去读取，如果读完了，当前数据包任务仍未完成，那么再从socket中去读取。
而判断包是否读完，都是用我们上面的3种类型，来对应处理的。

讲了半天理论，想必大家看的有点不耐烦了，接下来看看代码实际是如何处理的吧：

step1：从prebuffer中读取数据：

 //先从提前缓冲区去读，如果缓冲区可读大小大于0
 if ([preBuffer availableBytes] > )
 {
      // There are 3 types of read packets:
      //
      // 1) Read all available data.
      // 2) Read a specific length of data.
      // 3) Read up to a particular terminator.
      //3种类型的读法，1、全读、2、读取特定长度、3、读取到一个明确的界限

      NSUInteger bytesToCopy;

    //如果当前读的数据界限不为空
      if (currentRead->term != nil)
      {
           // Read type #3 - read up to a terminator
           //直接读到界限
           bytesToCopy = [currentRead readLengthForTermWithPreBuffer:preBuffer found:&done];
      }
      else
      {
           // Read type #1 or #2
           //读取数据，读到指定长度或者数据包的长度为止
           bytesToCopy = [currentRead readLengthForNonTermWithHint:[preBuffer availableBytes]];
      }

      // Make sure we have enough room in the buffer for our read.
      //从上两步拿到我们需要读的长度，去看看有没有空间去存储
      [currentRead ensureCapacityForAdditionalDataOfLength:bytesToCopy];

      // Copy bytes from prebuffer into packet buffer

    //拿到我们需要追加数据的指针位置
 #pragma mark - 不明白
    //当前读的数据 + 开始偏移 + 已经读完的？？
      uint8_t *buffer = (uint8_t *)[currentRead->buffer mutableBytes] + currentRead->startOffset +
                                                                        currentRead->bytesDone;
      //从prebuffer处复制过来数据，bytesToCopy长度
      memcpy(buffer, [preBuffer readBuffer], bytesToCopy);

      // Remove the copied bytes from the preBuffer
    //从preBuffer移除掉已经复制的数据
      [preBuffer didRead:bytesToCopy];

      LogVerbose(@"copied(%lu) preBufferLength(%zu)", (unsigned long)bytesToCopy, [preBuffer availableBytes]);

      // Update totals

    //已读的数据加上
      currentRead->bytesDone += bytesToCopy;
    //当前已读的数据加上
      totalBytesReadForCurrentRead += bytesToCopy;

      // Check to see if the read operation is done
      //判断是不是读完了
      if (currentRead->readLength > )
      {
           // Read type #2 - read a specific length of data
           //如果已读 == 需要读的长度，说明已经读完
           done = (currentRead->bytesDone == currentRead->readLength);
      }
    //判断界限标记
      else if (currentRead->term != nil)
      {
           // Read type #3 - read up to a terminator

           // Our 'done' variable was updated via the readLengthForTermWithPreBuffer:found: method
           //如果没做完，且读的最大长度大于0，去判断是否溢出
           if (!done && currentRead->maxLength > )
           {
                // We're not done and there's a set maxLength.
                // Have we reached that maxLength yet?

            //如果已读的大小大于最大的大小，则报溢出错误
                if (currentRead->bytesDone >= currentRead->maxLength)
                {
                     error = [self readMaxedOutError];
                }
           }
      }
      else
      {
           // Read type #1 - read all available data
           //
           // We're done as soon as
           // - we've read all available data (in prebuffer and socket)
           // - we've read the maxLength of read packet.
           //判断已读大小和最大大小是否相同，相同则读完
           done = ((currentRead->maxLength > ) && (currentRead->bytesDone == currentRead->maxLength));
      }

 }

这个方法就是利用我们之前提到的3种类型，来判断数据包需要读取的长度，然后调用：

memcpy(buffer, [preBuffer readBuffer], bytesToCopy);

把数据从preBuffer中，移到了currentRead数据包中。

step2：从socket中读取数据：

 // 从socket中去读取

 //是否读到EOFException ，这个错误指的是文件结尾了还在继续读，就会导致这个错误被抛出
 BOOL socketEOF = (flags & kSocketHasReadEOF) ? YES : NO;  // Nothing more to read via socket (end of file)

 //如果没完成，且没错，没读到结尾，且没有可读数据了
 BOOL waiting   = !done && !error && !socketEOF && !hasBytesAvailable; // Ran out of data, waiting for more

 //如果没完成，且没错，没读到结尾，有可读数据
 if (!done && !error && !socketEOF && hasBytesAvailable)
 {
    //断言，有可读数据
      NSAssert(([preBuffer availableBytes] == ), @"Invalid logic");
    //是否读到preBuffer中去
    BOOL readIntoPreBuffer = NO;
      uint8_t *buffer = NULL;
      size_t bytesRead = ;

    //如果flag标记为安全socket
      if (flags & kSocketSecure)
      {
        //...类似flushSSLBuffer的一系列操作
      }
      else
      {
           // Normal socket operation
           //普通的socket 操作

           NSUInteger bytesToRead;

           // There are 3 types of read packets:
           //
           // 1) Read all available data.
           // 2) Read a specific length of data.
           // 3) Read up to a particular terminator.

        //和上面类似，读取到边界标记？？不是吧
           if (currentRead->term != nil)
           {
                // Read type #3 - read up to a terminator

            //读这个长度，如果到maxlength，就用maxlength。看如果可用空间大于需要读的空间，则不用prebuffer
                bytesToRead = [currentRead readLengthForTermWithHint:estimatedBytesAvailable
                                                     shouldPreBuffer:&readIntoPreBuffer];
           }

           else
           {
                // Read type #1 or #2
                //直接读这个长度，如果到maxlength，就用maxlength
                bytesToRead = [currentRead readLengthForNonTermWithHint:estimatedBytesAvailable];
           }

        //大于最大值，则先读最大值
           if (bytesToRead > SIZE_MAX) { // NSUInteger may be bigger than size_t (read param 3)
                bytesToRead = SIZE_MAX;
           }

           // Make sure we have enough room in the buffer for our read.
           //
           // We are either reading directly into the currentRead->buffer,
           // or we're reading into the temporary preBuffer.

           if (readIntoPreBuffer)
           {
                [preBuffer ensureCapacityForWrite:bytesToRead];

                buffer = [preBuffer writeBuffer];
           }
           else
           {
                [currentRead ensureCapacityForAdditionalDataOfLength:bytesToRead];

                buffer = (uint8_t *)[currentRead->buffer mutableBytes]
                       + currentRead->startOffset
                       + currentRead->bytesDone;
           }

           // Read data into buffer

           int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;
 #pragma mark - 开始读取数据，最普通的形式 read

        //读数据
           ssize_t result = read(socketFD, buffer, (size_t)bytesToRead);
           LogVerbose(@"read from socket = %i", (int)result);
        //读取错误
           if (result < )
           {
            //EWOULDBLOCK IO阻塞
                if (errno == EWOULDBLOCK)
                //先等待
                     waiting = YES;
                else
                //得到错误
                     error = [self errnoErrorWithReason:@"Error in read() function"];
                //把可读取的长度设置为0
                socketFDBytesAvailable = ;
           }
        //读到边界了
           else if (result == )
           {
                socketEOF = YES;
                socketFDBytesAvailable = ;
           }
        //正常
           else
           {
            //设置读到的数据长度
                bytesRead = result;

            //如果读到的数据小于应该读的长度，说明这个包没读完
                if (bytesRead < bytesToRead)
                {
                     // The read returned less data than requested.
                     // This means socketFDBytesAvailable was a bit off due to timing,
                     // because we read from the socket right when the readSource event was firing.
                     socketFDBytesAvailable = ;
                }
            //正常
                else
                {
                //如果 socketFDBytesAvailable比读了的数据小的话，直接置为0
                     if (socketFDBytesAvailable <= bytesRead)
                          socketFDBytesAvailable = ;
                //减去已读大小
                     else
                          socketFDBytesAvailable -= bytesRead;
                }
                //如果 socketFDBytesAvailable 可读数量为0，把读的状态切换为等待
                if (socketFDBytesAvailable == )
                {
                     waiting = YES;
                }
           }
      }

本来想讲点什么。。发现确实没什么好讲的，无非就是判断应该读取的长度，然后调用：

ssize_t result = read(socketFD, buffer, (size_t)bytesToRead);

从socket中得到读取的实际长度。

唯一需要讲一下的可能是数据流向的问题，这里调用：

bytesToRead = [currentRead readLengthForTermWithHint:estimatedBytesAvailable shouldPreBuffer:&readIntoPreBuffer];

来判断数据是否先流向prebuffer，还是直接流向currentRead，而SSL的读取中也有类似方法：

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

这个方法核心的思路就是，如果当前读取包，长度给明了，则直接流向currentRead，如果数据长度不清楚，那么则去判断这一次读取的长度，和currentRead可用空间长度去对比，如果长度比currentRead可用空间小，则流向currentRead，否则先用prebuffer来缓冲。

至于细节方面，大家对着github中的源码注释看看吧，这么大篇幅的业务代码，一行行讲确实没什么意义。

走完这两步读取，接着就是第三步：

step3：判断数据包完成程度：

这里有3种情况：

1.数据包刚好读完；2.数据粘包；3.数据断包；
注：这里判断粘包断包的长度，都是我们一开始调用read方法给的长度或者分界符得出的。

很显然，第一种就什么都不用处理，完美匹配。
第二种情况，我们把需要的长度放到currentRead，多余的长度放到prebuffer中去。
第三种情况，数据还没读完，我们暂时为未读完。

这里就不贴代码了。

就这样普通读取数据的整个流程就走完了，而SSL的两种模式，和上述基本一致。

我们接着根据之前读取的结果，来判断数据是否读完:

//检查是否读完
if (done)
{
    //完成这次数据的读取
    [self completeCurrentRead];
    //如果没出错，没有到边界，prebuffer中还有可读数据
    if (!error && (!socketEOF || [preBuffer availableBytes] > ))
    {
        //让读操作离队,继续进行下一次读取
        [self maybeDequeueRead];
    }
}

如果读完，则去做读完的操作，并且进行下一次读取。

我们来看看读完的操作：

 //完成了这次的读数据
 - (void)completeCurrentRead
 {
     LogTrace();
     //断言currentRead
     NSAssert(currentRead, @"Trying to complete current read when there is no current read.");

     //结果数据
     NSData *result = nil;

     //如果是我们自己创建的Buffer
     if (currentRead->bufferOwner)
     {
         // We created the buffer on behalf of the user.
         // Trim our buffer to be the proper size.
         //修剪buffer到合适的大小
         //把大小设置到我们读取到的大小
         [currentRead->buffer setLength:currentRead->bytesDone];
         //赋值给result
         result = currentRead->buffer;
     }
     else
     {
         // We did NOT create the buffer.
         // The buffer is owned by the caller.
         // Only trim the buffer if we had to increase its size.
         //这是调用者的data，我们只会去加大尺寸
         if ([currentRead->buffer length] > currentRead->originalBufferLength)
         {
             //拿到的读的size
             NSUInteger readSize = currentRead->startOffset + currentRead->bytesDone;
             //拿到原始尺寸
             NSUInteger origSize = currentRead->originalBufferLength;

             //取得最大的
             NSUInteger buffSize = MAX(readSize, origSize);
             //把buffer设置为较大的尺寸
             [currentRead->buffer setLength:buffSize];
         }
         //拿到数据的头指针
         uint8_t *buffer = (uint8_t *)[currentRead->buffer mutableBytes] + currentRead->startOffset;

         //reslut为，从头指针开始到长度为写的长度 freeWhenDone为YES，创建完就释放buffer
         result = [NSData dataWithBytesNoCopy:buffer length:currentRead->bytesDone freeWhenDone:NO];
     }

     __strong id theDelegate = delegate;

 #pragma mark -总算到调用代理方法，接受到数据了
     if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:didReadData:withTag:)])
     {
         //拿到当前的数据包
         GCDAsyncReadPacket *theRead = currentRead; // Ensure currentRead retained since result may not own buffer

         dispatch_async(delegateQueue, ^{ @autoreleasepool {
             //把result在代理queue中回调出去。
             [theDelegate socket:self didReadData:result withTag:theRead->tag];
         }});
     }
     //取消掉读取超时
     [self endCurrentRead];
 }

这里对currentRead的data做了个长度的设置。然后调用代理把最终包给回调出去。最后关掉我们之前提到的读取超时。

还是回到doReadData，就剩下最后一点处理了：

//如果这次读的数量大于0
else if (totalBytesReadForCurrentRead > )
{
    // We're not done read type #2 or #3 yet, but we have read in some bytes

    __strong id theDelegate = delegate;

    //如果响应读数据进度的代理
    if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:didReadPartialDataOfLength:tag:)])
    {
        long theReadTag = currentRead->tag;

        //代理queue中回调出去
        dispatch_async(delegateQueue, ^{ @autoreleasepool {

            [theDelegate socket:self didReadPartialDataOfLength:totalBytesReadForCurrentRead tag:theReadTag];
        }});
    }
}

这里未完成，如果这次读取大于0，如果响应读取进度的代理，则把当前进度回调出去。

最后检查错误：

 //检查错误
 if (error)
 {
     //如果有错直接报错断开连接
     [self closeWithError:error];
 }
 //如果是读到边界错误
 else if (socketEOF)
 {
     [self doReadEOF];
 }

 //如果是等待
 else if (waiting)
 {
     //如果用的是CFStream,则读取数据和source无关
     //非CFStream形式
     if (![self usingCFStreamForTLS])
     {
         // Monitor the socket for readability (if we're not already doing so)
         //重新恢复source
         [self resumeReadSource];
     }
 }

如果有错，直接断开socket，如果是边界错误，调用边界错误处理，如果是等待，说明当前包还没读完，如果非CFStream的TLS，则恢复source，等待下一次数据到达的触发。

关于这个读取边界错误EOF,这里我简单的提下，其实它就是服务端发出一个边界错误，说明不会再有数据发送给我们了。我们讲无法再接收到数据，但是我们其实还是可以写数据，发送给服务端的。

而doReadEOF这个方法的处理，就是做了这么一件事。判断我们是否需要这种不可读，只能写的连接。

我们来简单看看这个方法:

Part6.读取边界错误处理：

 //读到EOFException，边界错误
 - (void)doReadEOF
 {
     LogTrace();
    //这个方法可能被调用很多次，如果读到EOF的时候，还有数据在prebuffer中，在调用doReadData之后？？ 这个方法可能被持续的调用

     //标记为读EOF
     flags |= kSocketHasReadEOF;

     //如果是安全socket
     if (flags & kSocketSecure)
     {
         //去刷新sslbuffer中的数据
         [self flushSSLBuffers];
     }

     //标记是否应该断开连接
     BOOL shouldDisconnect = NO;
     NSError *error = nil;

     //如果状态为开始读写TLS
     if ((flags & kStartingReadTLS) || (flags & kStartingWriteTLS))
     {
         //我们得到EOF在开启TLS之前，这个TLS握手是不可能的，因此这是不可恢复的错误

         //标记断开连接
         shouldDisconnect = YES;
         //如果是安全的TLS，赋值错误
         if ([self usingSecureTransportForTLS])
         {
             error = [self sslError:errSSLClosedAbort];
         }
     }
     //如果是读流关闭状态
     else if (flags & kReadStreamClosed)
     {

         //不应该被关闭
         shouldDisconnect = NO;
     }
     else if ([preBuffer availableBytes] > )
     {
         //仍然有数据可读的时候不关闭
         shouldDisconnect = NO;
     }
     else if (config & kAllowHalfDuplexConnection)
     {

         //拿到socket
         int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;

         //轮询用的结构体

         /*
          struct pollfd {
          int fd;        //文件描述符
          short events;  //要求查询的事件掩码  监听的
          short revents; //返回的事件掩码   实际发生的
          };
          */

         struct pollfd pfd[];
         pfd[].fd = socketFD;
         //写数据不会导致阻塞。
         pfd[].events = POLLOUT;
         //这个为当前实际发生的事情
         pfd[].revents = ;

         /*
          poll函数使用pollfd类型的结构来监控一组文件句柄，ufds是要监控的文件句柄集合，nfds是监控的文件句柄数量，timeout是等待的毫秒数，这段时间内无论I/O是否准备好，poll都会返回。timeout为负数表示无线等待，timeout为0表示调用后立即返回。执行结果：为0表示超时前没有任何事件发生；-1表示失败；成功则返回结构体中revents不为0的文件描述符个数。pollfd结构监控的事件类型如下：
          int poll(struct pollfd *ufds, unsigned int nfds, int timeout);
          */
         //阻塞的，但是timeout为0，则不阻塞，直接返回
         poll(pfd, , );

         //如果被触发的事件是写数据
         if (pfd[].revents & POLLOUT)
         {
             // Socket appears to still be writeable

             //则标记为不关闭
             shouldDisconnect = NO;
             //标记为读流关闭
             flags |= kReadStreamClosed;

             // Notify the delegate that we're going half-duplex
             //通知代理，我们开始半双工
             __strong id theDelegate = delegate;

             //调用已经关闭读流的代理方法
             if (delegateQueue && [theDelegate respondsToSelector:@selector(socketDidCloseReadStream:)])
             {
                 dispatch_async(delegateQueue, ^{ @autoreleasepool {

                     [theDelegate socketDidCloseReadStream:self];
                 }});
             }
         }
         else
         {
             //标记为断开
             shouldDisconnect = YES;
         }
     }
     else
     {
         shouldDisconnect = YES;
     }

     //如果应该断开
     if (shouldDisconnect)
     {
         if (error == nil)
         {
             //判断是否是安全TLS传输
             if ([self usingSecureTransportForTLS])
             {
                 ///标记错误信息
                 if (sslErrCode != noErr && sslErrCode != errSSLClosedGraceful)
                 {
                     error = [self sslError:sslErrCode];
                 }
                 else
                 {
                     error = [self connectionClosedError];
                 }
             }
             else
             {
                 error = [self connectionClosedError];
             }
         }
         //关闭socket
         [self closeWithError:error];
     }
     //不断开
     else
     {
         //如果不是用CFStream流
         if (![self usingCFStreamForTLS])
         {
             // Suspend the read source (if needed)
             //挂起读source
             [self suspendReadSource];
         }
     }
 }

简单说一下，这个方法主要是对socket是否需要主动关闭进行了判断：这里仅仅以下3种情况，不会关闭socket：

1. 读流已经是关闭状态（如果加了这个标记，说明为半双工连接状态）。
2. preBuffer中还有可读数据，我们需要等数据读完才能关闭连接。
3. 配置标记为kAllowHalfDuplexConnection，我们则要开始半双工处理。我们调用了：

4. poll(pfd, , );

   函数，如果触发了写事件POLLOUT，说明我们半双工连接成功，则我们可以在读流关闭的状态下，仍然可以向服务器写数据。

其他情况下，一律直接关闭socket。
而不关闭的情况下，我们会挂起source。这样我们就只能可写不可读了。

最后还是提下SSL的回调方法，数据解密的地方。两种模式的回调；

Part7.两种SSL数据解密位置：

1.CFStream:当我们调用:

CFIndex result = CFReadStreamRead(readStream, buffer, defaultBytesToRead);

数据就会被解密。
2.SSL安全通道：当我们调用:

OSStatus result = SSLRead(sslContext, buffer, (size_t)estimatedBytesAvailable, &bytesRead);

会触发SSL绑定的函数回调：

//读函数
static OSStatus SSLReadFunction(SSLConnectionRef connection, void *data, size_t *dataLength)
{
    //拿到socket
    GCDAsyncSocket *asyncSocket = (__bridge GCDAsyncSocket *)connection;

    //断言当前为socketQueue
    NSCAssert(dispatch_get_specific(asyncSocket->IsOnSocketQueueOrTargetQueueKey), @"What the deuce?");

    //读取数据，并且返回状态码
    return [asyncSocket sslReadWithBuffer:data length:dataLength];
}

接着我们在下面的方法进行了数据读取：

//SSL读取数据最终方法
- (OSStatus)sslReadWithBuffer:(void *)buffer length:(size_t *)bufferLength
{
    //...
    ssize_t result = read(socketFD, buf, bytesToRead);
    //....
}

其实read这一步，数据是没有被解密的，然后传递回SSLReadFunction，在传递到SSLRead内部，数据被解密。

尾声：

这个系列就剩下最后一篇Write了。由于内容相对比较简单，预计就一篇写完了。
如果一直看到这里的朋友，会发现，相对之前有些内容，讲解没那么详细了。其实原因主要有两点，一是代码数量庞大，确实无法详细。二是楼主对这个系列写的有点不耐烦，想要尽快结束了..
不过至少整篇的源码注释在github上是有的，我觉得大家自己去对着源码去阅读理解同样重要，如果一直逐字逐行的去讲，那就真的没什么意义了。