iOS即时通讯进阶 - CocoaAsyncSocket源码解析(Read篇)

HeiUWSH 8年前
   <p><img src="https://simg.open-open.com/show/9f956dd41d266d315551a0febbba582a.png"></p>    <h3>前言:</h3>    <p>本篇 ,将重点涉及该框架是如何利用缓冲区对数据进行读取、以及各种情况下的数据包处理,其中还包括普通的、和基于 TLS 的不同读取操作等等。</p>    <p>注:由于该框架源码篇幅过大,且有大部分相对抽象的数据操作逻辑,尽管楼主竭力想要简单的去陈述相关内容,但是阅读起来仍会有一定的难度。如果不是诚心想学习 IM 相关知识,在这里就可以离场了...</p>    <p>注:文中涉及代码比较多,建议大家结合源码一起阅读比较容易能加深理解。</p>    <p>或者自行查阅。</p>    <h3>目录:</h3>    <ul>     <li>1.浅析 Read 读取,并阐述数据从 socket 到用户手中的流程。</li>     <li>2.讲讲两种 TLS 建立连接的过程。</li>     <li>3.深入讲解 Read 的核心方法--- doReadData 的实现。</li>    </ul>    <h3>正文:</h3>    <h2>一.浅析 Read 读取,并阐述数据从 socket 到用户手中的流程</h2>    <p>大家用过这个框架就知道,我们每次读取数据之前都需要主动调用这么一个 Read 方法:</p>    <pre>  <code class="language-objectivec">[gcdSocket readDataWithTimeout:-1 tag:110];</code></pre>    <p>设置一个超时和 tag 值,这样我们就可以在这个超时的时间里,去读取到达当前 socket 的数据了。</p>    <p>那么本篇 Read 就从这个方法开始说起,我们点进框架里,来到这个方法:</p>    <pre>  <code class="language-objectivec">- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag  {       [self readDataWithTimeout:timeout buffer:nil bufferOffset:0 maxLength:0 tag:tag];  }    - (void)readDataWithTimeout:(NSTimeInterval)timeout                       buffer:(NSMutableData *)buffer                 bufferOffset:(NSUInteger)offset                          tag:(long)tag  {       [self readDataWithTimeout:timeout buffer:buffer bufferOffset:offset maxLength:0 tag:tag];  }    //用偏移量 maxLength 读取数据  - (void)readDataWithTimeout:(NSTimeInterval)timeout                       buffer:(NSMutableData *)buffer                 bufferOffset:(NSUInteger)offset                    maxLength:(NSUInteger)length                          tag:(long)tag  {       if (offset > [buffer length]) {            LogWarn(@"Cannot read: offset > [buffer length]");            return;       }         GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer                                                                 startOffset:offset                                                                   maxLength:length                                                                     timeout:timeout                                                                  readLength:0                                                                  terminator:nil                                                                         tag:tag];         dispatch_async(socketQueue, ^{ @autoreleasepool {              LogTrace();              if ((flags & kSocketStarted) && !(flags & kForbidReadsWrites))            {              //往读的队列添加任务,任务是包的形式                 [readQueue addObject:packet];                 [self maybeDequeueRead];            }       }});  }</code></pre>    <p>这个方法很简单。最终调用,去创建了一个 GCDAsyncReadPacket 类型的对象 packet ,简单来说这个对象是用来标识读取任务的。然后把这个 packet 对象添加到读取队列中。然后去调用:</p>    <pre>  <code class="language-objectivec">[self maybeDequeueRead];</code></pre>    <p>去从队列中取出读取任务包,做读取操作。</p>    <p>还记得我们之前 Connect 篇讲到的 GCDAsyncSocket 这个类的一些属性,其中有这么一个:</p>    <pre>  <code class="language-objectivec">//当前这次读取数据任务包  GCDAsyncReadPacket *currentRead;</code></pre>    <p>这个属性标识了我们当前这次读取的任务,当读取到 packet 任务时,其实这个属性就被赋值成 packet ,做数据读取。</p>    <p>接着来看看 GCDAsyncReadPacket 这个类,同样我们先看看属性:</p>    <pre>  <code class="language-objectivec">@interface GCDAsyncReadPacket : NSObject  {    @public      //当前包的数据 ,(容器,有可能为空)      NSMutableData *buffer;      //开始偏移 (数据在容器中开始写的偏移)      NSUInteger startOffset;      //已读字节数 (已经写了个字节数)      NSUInteger bytesDone;        //想要读取数据的最大长度 (有可能没有)      NSUInteger maxLength;      //超时时长      NSTimeInterval timeout;      //当前需要读取总长度  (这一次read读取的长度,不一定有,如果没有则可用maxLength)      NSUInteger readLength;        //包的边界标识数据 (可能没有)      NSData *term;      //判断buffer的拥有者是不是这个类,还是用户。      //跟初始化传不传一个buffer进来有关,如果传了,则拥有者为用户 NO, 否则为YES      BOOL bufferOwner;      //原始传过来的data长度      NSUInteger originalBufferLength;      //数据包的tag      long tag;  }</code></pre>    <p>这个类的内容还是比较多的,但是其实理解起来也很简单, 它主要是来装当前任务的一些标识和数据,使我们能够正确的完成我们预期的读取任务。</p>    <p>这些属性,大家同样过一个眼熟即可,后面大家就能理解它们了。</p>    <p>这个类还有一堆方法,包括初始化的、和一些数据的操作方法,其具体作用如下注释:</p>    <pre>  <code class="language-objectivec">//初始化  - (id)initWithData:(NSMutableData *)d         startOffset:(NSUInteger)s           maxLength:(NSUInteger)m             timeout:(NSTimeInterval)t          readLength:(NSUInteger)l          terminator:(NSData *)e                 tag:(long)i;    //确保容器大小给多余的长度  - (void)ensureCapacityForAdditionalDataOfLength:(NSUInteger)bytesToRead;  ////预期中读的大小,决定是否走preBuffer  - (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;  ////查找终结符,在prebuffer之后,返回值为该包的确定长度  - (NSInteger)searchForTermAfterPreBuffering:(ssize_t)numBytes;</code></pre>    <p>这里暂时仍然不准备去讲这些方法,等我们用到了在去讲它。</p>    <p>我们通过上述的属性和这些方法,能够把数据正确的读取到 packet 的属性 buffer 中,再用代理回传给用户。</p>    <p>这个 GCDAsyncReadPacket 类暂时就先这样了,我们接着往下看,前面讲到调用 maybeDequeueRead 开始读取任务,我们接下来就看看这个方法:</p>    <pre>  <code class="language-objectivec">//让读任务离队,开始执行这条读任务  - (void)maybeDequeueRead  {      LogTrace();      NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");        // If we're not currently processing a read AND we have an available read stream        //如果当前读的包为空,而且flag为已连接      if ((currentRead == nil) && (flags & kConnected))      {          //如果读的queue大于0 (里面装的是我们封装的GCDAsyncReadPacket数据包)          if ([readQueue count] > 0)          {              // Dequeue the next object in the write queue              //使得下一个对象从写的queue中离开                //从readQueue中拿到第一个写的数据              currentRead = [readQueue objectAtIndex:0];              //移除              [readQueue removeObjectAtIndex:0];                //我们的数据包,如果是GCDAsyncSpecialPacket这种类型,这个包里装了TLS的一些设置              //如果是这种类型的数据,那么我们就进行TLS              if ([currentRead isKindOfClass:[GCDAsyncSpecialPacket class]])              {                  LogVerbose(@"Dequeued GCDAsyncSpecialPacket");                    // Attempt to start TLS                  //标记flag为正在读取TLS                  flags |= kStartingReadTLS;                    // This method won't do anything unless both kStartingReadTLS and kStartingWriteTLS are set                  //只有读写都开启了TLS,才会做TLS认证                  [self maybeStartTLS];              }              else              {                  LogVerbose(@"Dequeued GCDAsyncReadPacket");                    // Setup read timer (if needed)                  //设置读的任务超时,每次延时的时候还会调用 [self doReadData];                  [self setupReadTimerWithTimeout:currentRead->timeout];                    // Immediately read, if possible                  //读取数据                  [self doReadData];              }          }            //读的队列没有数据,标记flag为,读了没有数据则断开连接状态          else if (flags & kDisconnectAfterReads)          {              //如果标记有写然后断开连接              if (flags & kDisconnectAfterWrites)              {                  //如果写的队列为0,而且写为空                  if (([writeQueue count] == 0) && (currentWrite == nil))                  {                      //断开连接                      [self closeWithError:nil];                  }              }              else              {                  //断开连接                  [self closeWithError:nil];              }          }          //如果有安全socket。          else if (flags & kSocketSecure)          {              [self flushSSLBuffers];                //如果可读字节数为0              if ([preBuffer availableBytes] == 0)              {                  //                  if ([self usingCFStreamForTLS]) {                      // Callbacks never disabled                  }                  else {                      //重新恢复读的source。因为每次开始读数据的时候,都会挂起读的source                      [self resumeReadSource];                  }              }          }      }  }</code></pre>    <p>详细的细节看注释即可,这里我们讲讲主要的作用:</p>    <ol>     <li>我们首先做了一些是否连接,读队列任务是否大于0等等一些判断。当然,如果判断失败,那么就不在读取,直接返回。</li>     <li> <p>接着我们从全局的 readQueue 中,拿到第一条任务,去做读取,我们来判断这个任务的类型,如果是 GCDAsyncSpecialPacket 类型的,我们将开启 TLS 认证。(后面再来详细讲)</p> <p>如果是是我们之前加入队列中的 GCDAsyncReadPacket 类型,我们则开始读取操作,调用 doReadData ,这个方法将是整个 Read 篇的核心方法。</p> </li>     <li>如果队列中没有任务,我们先去判断,是否是上一次是读取了数据,但是没有数据的标记,如果是的话我们则断开 socket 连接(注:还记得么, 我们之前应用篇有说过,调取读取任务时给一个超时,如果超过这个时间,还没读取到任务,则会断开连接,就是在这触发的 )。</li>     <li>如果我们是安全的连接(基于TLS的 Socket ),我们就去调用 flushSSLBuffers ,把数据从 SSL 通道中,移到我们的全局缓冲区 preBuffer 中。</li>    </ol>    <p>讲到这,大家可能觉得有些迷糊,为了能帮助大家理解,这里我准备了一张流程图,来讲讲整个框架读取数据的流程:</p>    <p><img src="https://simg.open-open.com/show/acf9d44b54cc4bdf150b26f3c8df65b3.png"></p>    <ol>     <li>这张图就是整个数据的流向了,这里我们读取数据分为两种情况,一种是基于 TLS ,一种是普通的数据读取。</li>     <li>而基于 TLS 的数据读取,又分为两种,一种是基于 CFStream ,另一种则是安全通道 SecureTransport 形式。</li>     <li>这两种类型的 TLS 都会在各自的通道内,完成数据的解密,然后解密后的数据又流向了全局缓冲区 prebuffer 。</li>     <li>这个全局缓冲区 prebuffer 就像一个蓄水池,如果我们一直不去做读取任务的话,它里面的数据会越来越多,当我们读取其中所有数据,它就会回归最初的状态。</li>     <li>我们用 currentRead 的方式,从 prebuffer 中读取数据,当读到我们想要的位置时,就会回调代理,用户得到数据。</li>    </ol>    <h2>二.讲讲两种TLS建立连接的过程</h2>    <p>讲到这里,就不得不提一下,这里个框架开启 TLS 的过程。它对外提供了这么一个方法来开启 TLS :</p>    <pre>  <code class="language-objectivec">- (void)startTLS:(NSDictionary *)tlsSettings</code></pre>    <p>可以根据一个字典,去开启并且配置 TLS ,那么这个字典里包含什么内容呢?</p>    <p>一共包含以下这些 key :</p>    <pre>  <code class="language-objectivec">//配置SSL上下文的设置  // Configure SSLContext from given settings  //   // Checklist:  //  1. kCFStreamSSLPeerName  //证书名  //  2. kCFStreamSSLCertificates //证书数组  //  3. GCDAsyncSocketSSLPeerID  //证书ID  //  4. GCDAsyncSocketSSLProtocolVersionMin  //SSL最低版本  //  5. GCDAsyncSocketSSLProtocolVersionMax  //SSL最高版本  //  6. GCDAsyncSocketSSLSessionOptionFalseStart    //  7. GCDAsyncSocketSSLSessionOptionSendOneByteRecord  //  8. GCDAsyncSocketSSLCipherSuites  //  9. GCDAsyncSocketSSLDiffieHellmanParameters (Mac)  //  // Deprecated (throw error): //被废弃的参数,如果设置了就会报错关闭socket  // 10. kCFStreamSSLAllowsAnyRoot  // 11. kCFStreamSSLAllowsExpiredRoots  // 12. kCFStreamSSLAllowsExpiredCertificates  // 13. kCFStreamSSLValidatesCertificateChain  // 14. kCFStreamSSLLevel</code></pre>    <p>其中有些 Key 的值,具体是什么意思,value如何设置,可以查查苹果文档,限于篇幅,我们就不赘述了,只需要了解重要的几个参数即可。</p>    <p>后面一部分是被废弃的参数,如果我们设置了,就会报错关闭 socket 连接。</p>    <p>除此之外,还有这么3个 key 被我们遗漏了,这3个key,是框架内部用来判断,并且做一些处理的标识:</p>    <pre>  <code class="language-objectivec">kCFStreamSSLIsServer  //判断当前是否是服务端  GCDAsyncSocketManuallyEvaluateTrust //判断是否需要手动信任SSL  GCDAsyncSocketUseCFStreamForTLS //判断是否使用CFStream形式的TLS</code></pre>    <p>这3个key的大意如注释,后面我们还会讲到,其中最重要的是 GCDAsyncSocketUseCFStreamForTLS 这个 key ,一旦我们设置为YES,将开启 CFStream 的TLS,关于这种基于流的 TLS 与普通的 TLS 的区别,我们来看看官方说明:</p>    <ul>     <li>      <ul>       <li>GCDAsyncSocketUseCFStreamForTLS (iOS only)</li>       <li>The value must be of type NSNumber, encapsulating a BOOL value.</li>       <li>By default GCDAsyncSocket will use the SecureTransport layer to perform encryption.</li>       <li>This gives us more control over the security protocol (many more configuration options),</li>       <li>plus it allows us to optimize things like sys calls and buffer allocation.</li>       <li>However, if you absolutely must, you can instruct GCDAsyncSocket to use the old-fashioned encryption</li>       <li>technique by going through the CFStream instead. So instead of using SecureTransport, GCDAsyncSocket</li>       <li>will instead setup a CFRead/CFWriteStream. And then set the kCFStreamPropertySSLSettings property</li>       <li>(via CFReadStreamSetProperty / CFWriteStreamSetProperty) and will pass the given options to this method.</li>       <li>Thus all the other keys in the given dictionary will be ignored by GCDAsyncSocket,</li>       <li>and will passed directly CFReadStreamSetProperty / CFWriteStreamSetProperty.</li>       <li>For more infomation on these keys, please see the documentation for kCFStreamPropertySSLSettings.<br> *</li>       <li>If unspecified, the default value is NO.</li>      </ul> </li>    </ul>    <p>从上述说明中,我们可以得知, CFStream 形式的 TLS 仅仅可以被用于 iOS 平台,并且它是一种过时的加解密技术,如果我们没有必要,最好还是不要用这种方式的 TLS 。</p>    <p>至于它的实现,我们接着往下看。</p>    <pre>  <code class="language-objectivec">//开启TLS  - (void)startTLS:(NSDictionary *)tlsSettings  {       LogTrace();         if (tlsSettings == nil)      {            tlsSettings = [NSDictionary dictionary];      }       //新生成一个TLS特殊的包       GCDAsyncSpecialPacket *packet = [[GCDAsyncSpecialPacket alloc] initWithTLSSettings:tlsSettings];           dispatch_async(socketQueue, ^{ @autoreleasepool {              if ((flags & kSocketStarted) && !(flags & kQueuedTLS) && !(flags & kForbidReadsWrites))            {              //添加到读写Queue中去                 [readQueue addObject:packet];                 [writeQueue addObject:packet];                 //把TLS标记加上                 flags |= kQueuedTLS;                 //开始读取TLS的任务,读到这个包会做TLS认证。在这之前的包还是不用认证就可以传送完                 [self maybeDequeueRead];                 [self maybeDequeueWrite];            }       }});    }</code></pre>    <p>这个方法就是对外提供的开启 TLS 的方法,它把传进来的字典,包成一个TLS的特殊包,这个 GCDAsyncSpecialPacket 类包里面就一个字典属性:</p>    <pre>  <code class="language-objectivec">- (id)initWithTLSSettings:(NSDictionary *)settings;</code></pre>    <p>然后我们把这个包添加到读写 queue 中去,并且标记当前的状态,然后去执行 maybeDequeueRead 或 maybeDequeueWrite 。</p>    <p>需要注意的是,这里只有读到这个 GCDAsyncSpecialPacket 时,才开始TLS认证和握手。</p>    <p>接着我们就来到了 maybeDequeueRead 这个方法,这个方法我们在前面第一条中讲到过,忘了的可以往上拉一下页面就可以看到。</p>    <p>它就是让我们的 ReadQueue 中的读任务离队,并且开始执行这条读任务。</p>    <ul>     <li>当我们读到的是 GCDAsyncSpecialPacket 类型的包,则开始进行TLS认证。</li>     <li>当我们读到的是 GCDAsyncReadPacket 类型的包,则开始进行一次读取数据的任务。</li>     <li>如果 ReadQueue 为空,则对几种情况进行判断,是否是读取上一次数据失败,则断开连接。<br> 如果是基于 TLS 的 Socket ,则把 SSL 安全通道的数据,移到全局缓冲区 preBuffer 中。如果数据仍然为空,则恢复读 source ,等待下一次读 source 的触发。</li>    </ul>    <p>接着我们来看看这其中第一条,当读到的是一个 GCDAsyncSpecialPacket 类型的包,我们会调用 maybeStartTLS 这个方法:</p>    <pre>  <code class="language-objectivec">//可能开启TLS  - (void)maybeStartTLS  {        //只有读和写TLS都开启       if ((flags & kStartingReadTLS) && (flags & kStartingWriteTLS))       {          //需要安全传输            BOOL useSecureTransport = YES;              #if TARGET_OS_IPHONE            {              //拿到当前读的数据                 GCDAsyncSpecialPacket *tlsPacket = (GCDAsyncSpecialPacket *)currentRead;              //得到设置字典                 NSDictionary *tlsSettings = tlsPacket->tlsSettings;                //拿到Key为CFStreamTLS的 value                 NSNumber *value = [tlsSettings objectForKey:GCDAsyncSocketUseCFStreamForTLS];                   if (value && [value boolValue])                  //如果是用CFStream的,则安全传输为NO                      useSecureTransport = NO;            }            #endif            //如果使用安全通道            if (useSecureTransport)            {              //开启TLS                 [self ssl_startTLS];            }          //CFStream形式的Tls            else            {            #if TARGET_OS_IPHONE                 [self cf_startTLS];            #endif            }       }  }</code></pre>    <p>这里根据我们之前添加标记,判断是否读写TLS状态,是才继续进行接下来的 TLS 认证。</p>    <p>接着我们拿到当前 GCDAsyncSpecialPacket ,取得配置字典中 key 为 GCDAsyncSocketUseCFStreamForTLS 的值:</p>    <p>如果为 YES 则说明使用 CFStream 形式的 TLS ,否则使用 SecureTransport 安全通道形式的 TLS 。关于这个配置项,还有二者的区别,我们前面就讲过了。</p>    <p>接着我们分别来看看这两个方法,先来看看 ssl_startTLS 。</p>    <p>这个方法非常长,大概有400多行,所以为了篇幅和大家阅读体验,楼主简化了一部分内容用省略号+注释的形式表示。大家可以参照着源码来阅读。</p>    <pre>  <code class="language-objectivec">//开启TLS  - (void)ssl_startTLS  {       LogTrace();         LogVerbose(@"Starting TLS (via SecureTransport)...");        //状态标记       OSStatus status;        //拿到当前读的数据包       GCDAsyncSpecialPacket *tlsPacket = (GCDAsyncSpecialPacket *)currentRead;       if (tlsPacket == nil) // Code to quiet the analyzer       {            NSAssert(NO, @"Logic error");              [self closeWithError:[self otherError:@"Logic error"]];            return;       }      //拿到设置       NSDictionary *tlsSettings = tlsPacket->tlsSettings;         // Create SSLContext, and setup IO callbacks and connection ref        //根据key来判断,当前包是否是服务端的       BOOL isServer = [[tlsSettings objectForKey:(__bridge NSString *)kCFStreamSSLIsServer] boolValue];        //创建SSL上下文       #if TARGET_OS_IPHONE || (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1080)       {          //如果是服务端的创建服务端上下文,否则是客户端的上下文,用stream形式            if (isServer)                 sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLServerSide, kSSLStreamType);            else                 sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);            //为空则报错返回            if (sslContext == NULL)            {                 [self closeWithError:[self otherError:@"Error in SSLCreateContext"]];                 return;            }       }         #else // (__MAC_OS_X_VERSION_MIN_REQUIRED < 1080)       {            status = SSLNewContext(isServer, &sslContext);            if (status != noErr)            {                 [self closeWithError:[self otherError:@"Error in SSLNewContext"]];                 return;            }       }       #endif        //给SSL上下文设置 IO回调 分别为SSL 读写函数       status = SSLSetIOFuncs(sslContext, &SSLReadFunction, &SSLWriteFunction);      //设置出错       if (status != noErr)       {            [self closeWithError:[self otherError:@"Error in SSLSetIOFuncs"]];            return;       }         //在握手之调用,建立SSL连接 ,第一次连接 1       status = SSLSetConnection(sslContext, (__bridge SSLConnectionRef)self);      //连接出错       if (status != noErr)       {            [self closeWithError:[self otherError:@"Error in SSLSetConnection"]];            return;       }        //是否应该手动的去信任SSL       BOOL shouldManuallyEvaluateTrust = [[tlsSettings objectForKey:GCDAsyncSocketManuallyEvaluateTrust] boolValue];      //如果需要手动去信任       if (shouldManuallyEvaluateTrust)       {          //是服务端的话,不需要,报错返回            if (isServer)            {                 [self closeWithError:[self otherError:@"Manual trust validation is not supported for server sockets"]];                 return;            }            //第二次连接 再去连接用kSSLSessionOptionBreakOnServerAuth的方式,去连接一次,这种方式可以直接信任服务端证书            status = SSLSetSessionOption(sslContext, kSSLSessionOptionBreakOnServerAuth, true);          //错误直接返回            if (status != noErr)            {                 [self closeWithError:[self otherError:@"Error in SSLSetSessionOption"]];                 return;            }              #if !TARGET_OS_IPHONE && (__MAC_OS_X_VERSION_MIN_REQUIRED < 1080)              // Note from Apple's documentation:            //            // It is only necessary to call SSLSetEnableCertVerify on the Mac prior to OS X 10.8.            // On OS X 10.8 and later setting kSSLSessionOptionBreakOnServerAuth always disables the            // built-in trust evaluation. All versions of iOS behave like OS X 10.8 and thus            // SSLSetEnableCertVerify is not available on that platform at all.              //为了防止kSSLSessionOptionBreakOnServerAuth这种情况下,产生了不受信任的环境            status = SSLSetEnableCertVerify(sslContext, NO);            if (status != noErr)            {                 [self closeWithError:[self otherError:@"Error in SSLSetEnableCertVerify"]];                 return;            }              #endif       }        //配置SSL上下文的设置         id value;      //这个参数是用来获取证书名验证,如果设置为NULL,则不验证       // 1. kCFStreamSSLPeerName         value = [tlsSettings objectForKey:(__bridge NSString *)kCFStreamSSLPeerName];       if ([value isKindOfClass:[NSString class]])       {            NSString *peerName = (NSString *)value;              const char *peer = [peerName UTF8String];            size_t peerLen = strlen(peer);            //把证书名设置给SSL            status = SSLSetPeerDomainName(sslContext, peer, peerLen);            if (status != noErr)            {                 [self closeWithError:[self otherError:@"Error in SSLSetPeerDomainName"]];                 return;            }       }      //不是string就错误返回       else if (value)       {          //这个断言啥用也没有啊。。            NSAssert(NO, @"Invalid value for kCFStreamSSLPeerName. Value must be of type NSString.");              [self closeWithError:[self otherError:@"Invalid value for kCFStreamSSLPeerName."]];            return;       }         //  2. kCFStreamSSLCertificates        ...       //  3. GCDAsyncSocketSSLPeerID        ...       //  4. GCDAsyncSocketSSLProtocolVersionMin        ...       //  5. GCDAsyncSocketSSLProtocolVersionMax        ...       //  6. GCDAsyncSocketSSLSessionOptionFalseStart        ...       //  7. GCDAsyncSocketSSLSessionOptionSendOneByteRecord        ...       //  8. GCDAsyncSocketSSLCipherSuites        ...       //  9. GCDAsyncSocketSSLDiffieHellmanParameters (Mac)        ...         //弃用key的检查,如果有下列key对应的value,则都报弃用的错误         // 10. kCFStreamSSLAllowsAnyRoot          ...       // 11. kCFStreamSSLAllowsExpiredRoots        ...       // 12. kCFStreamSSLAllowsExpiredCertificates        ...       // 13. kCFStreamSSLValidatesCertificateChain        ...       // 14. kCFStreamSSLLevel        ...         // Setup the sslPreBuffer       //        // Any data in the preBuffer needs to be moved into the sslPreBuffer,       // as this data is now part of the secure read stream.        //初始化SSL提前缓冲 也是4Kb       sslPreBuffer = [[GCDAsyncSocketPreBuffer alloc] initWithCapacity:(1024 * 4)];       //获取到preBuffer可读大小       size_t preBufferLength  = [preBuffer availableBytes];        //如果有可读内容       if (preBufferLength > 0)       {          //确保SSL提前缓冲的大小            [sslPreBuffer ensureCapacityForWrite:preBufferLength];            //从readBuffer开始读,读这个长度到 SSL提前缓冲的writeBuffer中去            memcpy([sslPreBuffer writeBuffer], [preBuffer readBuffer], preBufferLength);          //移动提前的读buffer            [preBuffer didRead:preBufferLength];          //移动sslPreBuffer的写buffer            [sslPreBuffer didWrite:preBufferLength];       }       //拿到上次错误的code,并且让上次错误code = 没错       sslErrCode = lastSSLHandshakeError = noErr;         // Start the SSL Handshake process       //开始SSL握手过程       [self ssl_continueSSLHandshake];  }</code></pre>    <p>这个方法的结构也很清晰,主要就是建立 TLS 连接,并且配置 SSL 上下文对象: sslContext ,为 TLS 握手做准备。</p>    <p>这里我们就讲讲几个重要的关于 SSL 的函数,其余细节可以看看注释:</p>    <ol>     <li>创建SSL上下文对象: <pre>  <code class="language-objectivec">sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLServerSide, kSSLStreamType);  sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);</code></pre> 这个函数用来创建一个SSL上下文,我们接下来会把配置字典 tlsSettings 中所有的参数,都设置到这个 sslContext 中去,然后用这个 sslContext 进行 TLS 后续操作,握手等。</li>     <li> <p>给SSL设置读写回调:</p> <pre>  <code class="language-objectivec">status = SSLSetIOFuncs(sslContext, &SSLReadFunction, &SSLWriteFunction);</code></pre> <p>这两个回调函数如下:</p> <pre>  <code class="language-objectivec">//读函数  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];  }  //写函数  static OSStatus SSLWriteFunction(SSLConnectionRef connection, const void *data, size_t *dataLength)  {   GCDAsyncSocket *asyncSocket = (__bridge GCDAsyncSocket *)connection;     NSCAssert(dispatch_get_specific(asyncSocket->IsOnSocketQueueOrTargetQueueKey), @"What the deuce?");     return [asyncSocket sslWriteWithBuffer:data length:dataLength];  }</code></pre> <p>他们分别调用了 sslReadWithBuffer 和 sslWriteWithBuffer 两个函数进行 SSL 的读写处理,关于这两个函数,我们后面再来说。</p> </li>     <li>发起 SSL 连接: <pre>  <code class="language-objectivec">status = SSLSetConnection(sslContext, (__bridge SSLConnectionRef)self);</code></pre> </li>    </ol>    <p>到这一步,前置的重要操作就完成了,接下来我们是对 SSL 进行一些额外的参数配置:</p>    <p>我们根据 tlsSettings 中 GCDAsyncSocketManuallyEvaluateTrust 字段,去判断是否需要手动信任服务端证书,调用如下函数</p>    <pre>  <code class="language-objectivec">status = SSLSetSessionOption(sslContext, kSSLSessionOptionBreakOnServerAuth, true);</code></pre>    <p>这个函数是用来设置一些可选项的,当然不止 kSSLSessionOptionBreakOnServerAuth 这一种,还有许多种类型的可选项,感兴趣的朋友可以自行点进去看看这个枚举。</p>    <p>接着我们按照字典中的设置项,一项一项去设置ssl上下文,类似:</p>    <pre>  <code class="language-objectivec">status = SSLSetPeerDomainName(sslContext, peer, peerLen);</code></pre>    <p>设置完这些有效的,我们还需要去检查无效的 key ,万一我们设置了这些废弃的api,我们需要报错处理。</p>    <p>做完这些操作后,我们初始化了一个 sslPreBuffer ,这个 ssl 安全通道下的全局缓冲区:</p>    <pre>  <code class="language-objectivec">sslPreBuffer = [[GCDAsyncSocketPreBuffer alloc] initWithCapacity:(1024 * 4)];</code></pre>    <p>然后把 prebuffer 全局缓冲区中的数据全部挪到 sslPreBuffer 中去,这里为什么要这么做呢?按照我们上面的流程图来说,正确的数据流向应该是从 sslPreBuffer -> prebuffer 的,楼主在这里也思考了很久,最后我的想法是,就是初始化的时候,数据的流向的统一,在我们真正数据读取的时候,就不需要做额外的判断了。</p>    <p>到这里我们所有的握手前初始化工作都做完了。</p>    <p>接着我们调用了 ssl_continueSSLHandshake 方法开始 SSL 握手:</p>    <pre>  <code class="language-objectivec">//SSL的握手  - (void)ssl_continueSSLHandshake  {       LogTrace();         //用我们的SSL上下文对象去握手       OSStatus status = SSLHandshake(sslContext);      //拿到握手的结果,赋值给上次握手的结果       lastSSLHandshakeError = status;        //如果没错       if (status == noErr)       {            LogVerbose(@"SSLHandshake complete");            //把开始读写TLS,从标记中移除            flags &= ~kStartingReadTLS;            flags &= ~kStartingWriteTLS;              //把Socket安全通道标记加上            flags |=  kSocketSecure;            //拿到代理            __strong id theDelegate = delegate;              if (delegateQueue && [theDelegate respondsToSelector:@selector(socketDidSecure:)])            {                 dispatch_async(delegateQueue, ^{ @autoreleasepool {                      //调用socket已经开启安全通道的代理方法                      [theDelegate socketDidSecure:self];                 }});            }            //停止读取            [self endCurrentRead];          //停止写            [self endCurrentWrite];            //开始下一次读写任务            [self maybeDequeueRead];            [self maybeDequeueWrite];       }      //如果是认证错误       else if (status == errSSLPeerAuthCompleted)       {            LogVerbose(@"SSLHandshake peerAuthCompleted - awaiting delegate approval");              __block SecTrustRef trust = NULL;          //从sslContext拿到证书相关的细节            status = SSLCopyPeerTrust(sslContext, &trust);          //SSl证书赋值出错            if (status != noErr)            {                 [self closeWithError:[self sslError:status]];                 return;            }            //拿到状态值            int aStateIndex = stateIndex;          //socketQueue            dispatch_queue_t theSocketQueue = socketQueue;              __weak GCDAsyncSocket *weakSelf = self;            //创建一个完成Block            void (^comletionHandler)(BOOL) = ^(BOOL shouldTrust){ @autoreleasepool {            #pragma clang diagnostic push            #pragma clang diagnostic warning "-Wimplicit-retain-self"                   dispatch_async(theSocketQueue, ^{ @autoreleasepool {                        if (trust) {                           CFRelease(trust);                           trust = NULL;                      }                        __strong GCDAsyncSocket *strongSelf = weakSelf;                      if (strongSelf)                      {                           [strongSelf ssl_shouldTrustPeer:shouldTrust stateIndex:aStateIndex];                      }                 }});              #pragma clang diagnostic pop            }};              __strong id theDelegate = delegate;              if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:didReceiveTrust:completionHandler:)])            {                 dispatch_async(delegateQueue, ^{ @autoreleasepool {    #pragma mark - 调用代理我们自己去https认证                      [theDelegate socket:self didReceiveTrust:trust completionHandler:comletionHandler];                 }});            }          //没实现代理直接报错关闭连接。            else            {                 if (trust) {                      CFRelease(trust);                      trust = NULL;                 }                   NSString *msg = @"GCDAsyncSocketManuallyEvaluateTrust specified in tlsSettings,"                                 @" but delegate doesn't implement socket:shouldTrustPeer:";                   [self closeWithError:[self otherError:msg]];                 return;            }       }        //握手错误为 IO阻塞的       else if (status == errSSLWouldBlock)       {            LogVerbose(@"SSLHandshake continues...");              // Handshake continues...            //             // This method will be called again from doReadData or doWriteData.       }       else       {          //其他错误直接关闭连接            [self closeWithError:[self sslError:status]];       }  }</code></pre>    <p>这个方法就做了一件事,就是 SSL 握手,我们调用了这个函数完成握手:</p>    <pre>  <code class="language-objectivec">OSStatus status = SSLHandshake(sslContext);</code></pre>    <p>然后握手的结果分为4种情况:</p>    <ol>     <li>如果返回为 noErr ,这个会话已经准备好了安全的通信,握手成功。</li>     <li>如果返回的 value 为 errSSLWouldBlock ,握手方法必须再次调用。</li>     <li>如果返回为 errSSLServerAuthCompleted ,如果我们要调用代理,我们需要相信服务器,然后再次调用握手,去恢复握手或者关闭连接。</li>     <li>否则,返回的 value 表明了错误的 code 。</li>    </ol>    <p>其中需要说说的是 errSSLWouldBlock ,这个是 IO 阻塞下的错误,也就是服务器的结果还没来得及返回,当握手结果返回的时候,这个方法会被再次触发。</p>    <p>还有就是 errSSLServerAuthCompleted 下,我们回调了代理:</p>    <pre>  <code class="language-objectivec">[theDelegate socket:self didReceiveTrust:trust completionHandler:comletionHandler];</code></pre>    <p>我们可以去手动对证书进行认证并且信任,当完成回调后,会调用到这个方法里来,再次进行握手:</p>    <pre>  <code class="language-objectivec">//修改信息后再次进行SSL握手  - (void)ssl_shouldTrustPeer:(BOOL)shouldTrust stateIndex:(int)aStateIndex  {      LogTrace();        if (aStateIndex != stateIndex)      {          return;      }        // Increment stateIndex to ensure completionHandler can only be called once.      stateIndex++;        if (shouldTrust)      {          NSAssert(lastSSLHandshakeError == errSSLPeerAuthCompleted, @"ssl_shouldTrustPeer called when last error is %d and not errSSLPeerAuthCompleted", (int)lastSSLHandshakeError);          [self ssl_continueSSLHandshake];      }      else      {            [self closeWithError:[self sslError:errSSLPeerBadCert]];      }  }</code></pre>    <p>到这里,我们就整个完成安全通道下的 TLS 认证。</p>    <p>接着我们来看看基于 CFStream 的 TLS :</p>    <p>因为 CFStream 是上层API,所以它的 TLS 流程相当简单,我们来看看 cf_startTLS 这个方法:</p>    <pre>  <code class="language-objectivec">//CF流形式的TLS  - (void)cf_startTLS  {       LogTrace();         LogVerbose(@"Starting TLS (via CFStream)...");        //如果preBuffer的中可读数据大于0,错误关闭       if ([preBuffer availableBytes] > 0)       {            NSString *msg = @"Invalid TLS transition. Handshake has already been read from socket.";              [self closeWithError:[self otherError:msg]];            return;       }        //挂起读写source       [self suspendReadSource];       [self suspendWriteSource];        //把未读的数据大小置为0       socketFDBytesAvailable = 0;      //去掉下面两种flag       flags &= ~kSocketCanAcceptBytes;       flags &= ~kSecureSocketHasBytesAvailable;        //标记为CFStream       flags |=  kUsingCFStreamForTLS;        //如果创建读写stream失败       if (![self createReadAndWriteStream])       {            [self closeWithError:[self otherError:@"Error in CFStreamCreatePairWithSocket"]];            return;       }       //注册回调,这回监听可读数据了!!       if (![self registerForStreamCallbacksIncludingReadWrite:YES])       {            [self closeWithError:[self otherError:@"Error in CFStreamSetClient"]];            return;       }       //添加runloop       if (![self addStreamsToRunLoop])       {            [self closeWithError:[self otherError:@"Error in CFStreamScheduleWithRunLoop"]];            return;       }         NSAssert([currentRead isKindOfClass:[GCDAsyncSpecialPacket class]], @"Invalid read packet for startTLS");       NSAssert([currentWrite isKindOfClass:[GCDAsyncSpecialPacket class]], @"Invalid write packet for startTLS");        //拿到当前包       GCDAsyncSpecialPacket *tlsPacket = (GCDAsyncSpecialPacket *)currentRead;      //拿到ssl配置       CFDictionaryRef tlsSettings = (__bridge CFDictionaryRef)tlsPacket->tlsSettings;         // Getting an error concerning kCFStreamPropertySSLSettings ?       // You need to add the CFNetwork framework to your iOS application.        //直接设置给读写stream       BOOL r1 = CFReadStreamSetProperty(readStream, kCFStreamPropertySSLSettings, tlsSettings);       BOOL r2 = CFWriteStreamSetProperty(writeStream, kCFStreamPropertySSLSettings, tlsSettings);            //设置失败       if (!r1 && !r2) // Yes, the && is correct - workaround for apple bug.       {            [self closeWithError:[self otherError:@"Error in CFStreamSetProperty"]];            return;       }        //打开流       if (![self openStreams])       {            [self closeWithError:[self otherError:@"Error in CFStreamOpen"]];            return;       }         LogVerbose(@"Waiting for SSL Handshake to complete...");  }</code></pre>    <p>1.这个方法很简单,首先它挂起了读写 source ,然后重新初始化了读写流,并且绑定了回调,和添加了 runloop 。</p>    <p>这里我们为什么要用重新这么做?看过之前 connect 篇的同学就知道,我们在连接成功之后,去初始化过读写流,这些操作之前都做过。而在这里重新初始化,并不会重新创建,只是修改读写流的一些参数,其中主要是下面这个方法,传递了一个 YES 过去:</p>    <pre>  <code class="language-objectivec">if (![self registerForStreamCallbacksIncludingReadWrite:YES])</code></pre>    <p>这个参数会使方法里多添加一种触发回调的方式: kCFStreamEventHasBytesAvailable 。</p>    <p>当有数据可读时候,触发 Stream 回调。</p>    <p>2.接着我们用下面这个函数把TLS的配置参数,设置给读写stream:</p>    <pre>  <code class="language-objectivec">//直接设置给读写stream  BOOL r1 = CFReadStreamSetProperty(readStream, kCFStreamPropertySSLSettings, tlsSettings);  BOOL r2 = CFWriteStreamSetProperty(writeStream, kCFStreamPropertySSLSettings, tlsSettings);</code></pre>    <p>3.最后打开读写流,整个 CFStream 形式的 TLS 就完成了。</p>    <p>看到这,大家可能对数据触发的问题有些迷惑。总结一下,我们到现在一共有3种触发的回调:</p>    <ol>     <li>读写 source :这个和 socket 绑定在一起,一旦有数据到达,就会触发事件句柄。</li>     <li>CFStream 绑定的几种事件的读写回调函数: <pre>  <code class="language-objectivec">static void CFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo)  static void CFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo)</code></pre> 这个只和 CFStream 形式的 TLS 相关,会触发这种形式的握手,流末尾等出现的错误,还有该形式下数据到达。</li>     <li>SSL 安全通道形式,绑定的 SSL 读写函数: <pre>  <code class="language-objectivec">static OSStatus SSLReadFunction(SSLConnectionRef connection, void *data, size_t *dataLength)  static OSStatus SSLWriteFunction(SSLConnectionRef connection, const void *data, size_t *dataLength)</code></pre> 这个函数并不是由系统触发,而是需要我们主动去调用 SSLRead 和 SSLWrite 两个函数,回调才能被触发。</li>    </ol>    <p>这里我们需要讲一下的是, 无论我们是否去调用该框架的 Read 方法,数据始终是到达后,触发回调,然后经过一系列的流动,最后总是流向全局缓冲区 prebuffer 。</p>    <p>而我们调用 Read ,只是从这个全局缓冲区去读取数据而已。</p>    <p>暂时的结尾:</p>    <p>篇幅原因,本篇断在这里。如果大家对本文内容有些地方不明白的话,也没关系,等我们下篇把核心方法 doReadData 讲完,在整个梳理一遍,或许大家就会对整个框架的 Read 流程有一个清晰的认识。</p>    <p> </p>    <p> </p>    <p>来自:http://www.jianshu.com/p/fdd3d429bdb3</p>    <p> </p>