
本文是 CocoaAsyncSocket 源碼系列的第二篇——Read 篇,重點關注框架如何借助緩衝區完成數據讀取、如何應對各種分包情形,以及普通讀取與基於 TLS 的讀取有何不同。
先提醒一句:這個框架源碼量龐大,且有大量相對抽象的內存操作邏輯,讀起來並不輕鬆。如果你只是想找點輕鬆的閱讀,這裡可以先止步了。
系列首篇 Connect 篇已經完結,有興趣可以回看。文中涉及代碼較多,建議對照源碼閱讀,理解會更透徹;我標註好注釋的版本可以作為參照。若對框架用法尚不熟悉,也可以先看看我此前的入門文章或粘包/斷包處理實例。
本文的推進路線:
doReadData 的實現。用過這個框架的人都知道,每次讀數據前都要主動調一次:
[gcdSocket readDataWithTimeout:-1 tag:110];
設置超時與 tag,之後在這個時間窗口內,到達當前 socket 的數據就會被讀出來。
順著這個方法點進框架:
- (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];
}
}});
}
邏輯很直白:最終創建一個 GCDAsyncReadPacket 對象用來標識本次讀取任務,把它加入讀取隊列,然後調用 [self maybeDequeueRead] 從隊列取出任務、真正開始讀。
還記得 Connect 篇提過的屬性嗎?其中有一個:
// 當前這次讀取數據任務包 GCDAsyncReadPacket *currentRead;
它標識著當前正在進行的讀取任務。當隊列中的 packet 被取出時,這個屬性就被賦值為該 packet,隨後開始讀數據。
先看看它的屬性:
@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;
}
內容不少,但理解起來並不難——它主要就是裝載當前任務的各項標識與數據,讓我們能準確完成預期的讀取。
這個類還有一批方法,涵蓋初始化與數據操作,作用如注釋:
// 初始化
- (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;
這些方法暫且按下不表,等真正用到時再展開。總之,憑藉這些屬性與方法,我們能把數據正確讀進 packet 的 buffer,再通過代理回傳給業務層。
// 讓讀任務離隊,開始執行這條讀任務
- (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
// 從 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];
}
}
}
}
}
細節看注釋即可,這裡提煉四條主幹:
readQueue 取出第一條任務並判斷類型:若是 GCDAsyncSpecialPacket,開啟 TLS 認證(後文細講);若是 GCDAsyncReadPacket,調用 doReadData 開始讀取——這將是整個 Read 篇的核心。flushSSLBuffers,把數據從 SSL 通道搬到全局緩衝區 preBuffer。為幫助理解,這裡放一張流程圖:

圖中呈現的就是數據的完整流向。讀取分兩大類:普通讀取與基於 TLS 的讀取;而 TLS 讀取又分兩種——基於 CFStream 的,以及走 SecureTransport 安全通道的。兩者都在各自通道內完成解密,解密後的數據統一流向全局緩衝區 preBuffer。
可以把 preBuffer 想成一個蓄水池:只要不去讀,裡面的數據就會越積越多;把數據全部讀走,它就回到最初的狀態。我們用 currentRead 從 preBuffer 取數據,一旦讀到預期的位置,就回調代理,把數據交到業務層手裡。
說到這裡,不得不提框架開啟 TLS 的方式。它對外暴露了這麼一個接口:
- (void)startTLS:(NSDictionary *)tlsSettings
通過一个字典就能開啟並配置 TLS。字典裡可以用這些 key:
// 配置 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
每個 key 的含義與取值可以查閱 Apple 文檔,限於篇幅這裡只挑重要的說。後半段是被廢棄的參數,一旦設置就會報錯並關閉連接。
除此之外,還有 3 個 key 是我們不能忽略的,它們由框架內部用來判斷並執行相應處理:
kCFStreamSSLIsServer // 判斷當前是否是服務端 GCDAsyncSocketManuallyEvaluateTrust // 判斷是否需要手動信任 SSL GCDAsyncSocketUseCFStreamForTLS // 判斷是否使用 CFStream 形式的 TLS
其中最重要的是 GCDAsyncSocketUseCFStreamForTLS:一旦設為 YES,就切換到 CFStream 形式的 TLS。關於這種基於流的實現與常規做法的區別,官方說明寫得很清楚:
也就是說:CFStream 形式的 TLS 僅適用於 iOS 平台,且屬於過時的加解密方式;沒有特殊理由,最好別用它。
// 開啟 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];
}
}});
}
它把傳入的字典封裝成一個 GCDAsyncSpecialPacket(該類內部只有一個 tlsSettings 字典屬性),同時加入讀寫隊列並打上標記,再觸發 maybeDequeueRead / maybeDequeueWrite。
要記住一個要點:只有讀到這個 GCDAsyncSpecialPacket 時,才真正開始 TLS 認證與握手;排在它前面的包,仍按明文正常收發。
回到 maybeDequeueRead:讀到 GCDAsyncSpecialPacket 走 TLS 認證,讀到 GCDAsyncReadPacket 走一次常規讀取;隊列為空時,先判斷是否命中「上次讀取失敗」標記以決定是否斷連;若是 TLS socket,則把 SSL 通道中的數據搬進 preBuffer,若仍為空就恢復 read source,等待下一次觸發。
當讀到的是 GCDAsyncSpecialPacket,會調用 maybeStartTLS:
// 可能開啟 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
}
}
}
先確認讀寫 TLS 標記都已置位,再從配置字典取出 GCDAsyncSocketUseCFStreamForTLS:為 YES 走 cf_startTLS,否則走 ssl_startTLS。
這個方法有 400 多行,下面保留骨架並以省略號標示細節,建議對照源碼閱讀:
// 開啟 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 連接
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.
status = SSLSetEnableCertVerify(sslContext, NO);
if (status != noErr) {
[self closeWithError:[self otherError:@"Error in SSLSetEnableCertVerify"]];
return;
}
#endif
}
// 配置 SSL 上下文的設置
id value;
// 1. kCFStreamSSLPeerName
// 這個參數是用來獲取證書名驗證,如果設置為 NULL,則不驗證
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;
}
}
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);
[preBuffer didRead:preBufferLength];
[sslPreBuffer didWrite:preBufferLength];
}
// 拿到上次錯誤的 code,並且讓上次錯誤 code = 沒錯
sslErrCode = lastSSLHandshakeError = noErr;
// Start the SSL Handshake process
// 開始 SSL 握手過程
[self ssl_continueSSLHandshake];
}
結構其實很清晰:建立 TLS 連接、配置 sslContext,為握手做準備。幾個值得單獨說說的 API:
創建 SSL 上下文
sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLServerSide, kSSLStreamType); sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);
後續所有 tlsSettings 中的參數都會設置到這個對象上,再憑它完成握手等操作。
設置讀寫回調
status = SSLSetIOFuncs(sslContext, &SSLReadFunction, &SSLWriteFunction);
兩個回調的實現:
// 讀函數
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];
}
它們分別轉調 sslReadWithBuffer 與 sslWriteWithBuffer,這兩個方法留待後文。
發起連接
status = SSLSetConnection(sslContext, (__bridge SSLConnectionRef)self);
前置準備到此完成,接下來是額外參數配置。根據 GCDAsyncSocketManuallyEvaluateTrust 判斷是否需要手動信任服務端證書:
status = SSLSetSessionOption(sslContext, kSSLSessionOptionBreakOnServerAuth, true);
這個 API 用於設置各類會話可選項(不止上面這一種,感興趣可以翻翻那個枚舉)。此後按字典逐項設置上下文,形如:
status = SSLSetPeerDomainName(sslContext, peer, peerLen);
有效項設置完畢,還要檢查那些已廢棄的 key,一旦發現就報錯處理。
接著初始化 TLS 專屬的緩衝區:
sslPreBuffer = [[GCDAsyncSocketPreBuffer alloc] initWithCapacity:(1024 * 4)];
然後把 preBuffer 中的數據整體搬到 sslPreBuffer。按流程圖,正常的流向應是 sslPreBuffer → preBuffer,這裡為何反向?我的理解是:初始化階段先把數據流向統一起來,真正開始讀取時就不必再做額外判斷。
至此,握手前的準備工作全部就緒。
// 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);
if (status != noErr) {
[self closeWithError:[self sslError:status]];
return;
}
int aStateIndex = stateIndex;
dispatch_queue_t theSocketQueue = socketQueue;
__weak GCDAsyncSocket *weakSelf = self;
void (^comletionHandler)(BOOL) = ^(BOOL shouldTrust){ @autoreleasepool {
dispatch_async(theSocketQueue, ^{ @autoreleasepool {
if (trust) { CFRelease(trust); trust = NULL; }
__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf) {
[strongSelf ssl_shouldTrustPeer:shouldTrust stateIndex:aStateIndex];
}
}});
}};
__strong id theDelegate = delegate;
if (delegateQueue && [theDelegate respondsToSelector:@selector(socket:didReceiveTrust:completionHandler:)]) {
dispatch_async(delegateQueue, ^{ @autoreleasepool {
// 調用代理,由我們自己去認證
[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...");
// This method will be called again from doReadData or doWriteData.
}
else {
// 其他錯誤直接關閉連接
[self closeWithError:[self sslError:status]];
}
}
這個方法只做一件事——調用 SSLHandshake(sslContext) 完成握手,然後按返回值分四種情況處理:
noErr:會話已可安全通信,握手成功。清除 TLS 起始標記、置上 kSocketSecure,回調 socketDidSecure:,結束當前的讀寫任務並繼續下一輪。errSSLWouldBlock:IO 阻塞,握手尚未完成,此方法會在 doReadData 或 doWriteData 中被再次調用。errSSLPeerAuthCompleted:需要由代理決定是否信任服務端證書,信任後再次調用握手以恢復流程。第二種情況本質上是「服務端結果還沒回來」,等數據到達時自然會再次觸發。第三種情況下,框架回調了:
[theDelegate socket:self didReceiveTrust:trust completionHandler:comletionHandler];
我們可以在代理裡自行校驗證書並決定信任與否,完成回調後流程會回到下面這個方法,繼續握手:
// 修改信息後再次進行 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]];
}
}
至此,SecureTransport 通道下的整套 TLS 認證就完成了。
CFStream 屬於上層 API,因此它的 TLS 流程簡單得多:
// 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...");
}
三步走完:
if (![self registerForStreamCallbacksIncludingReadWrite:YES])這個參數會讓方法多註冊一種回調觸發方式
kCFStreamEventHasBytesAvailable,即有數據可讀時觸發 Stream 回調。BOOL r1 = CFReadStreamSetProperty(readStream, kCFStreamPropertySSLSettings, tlsSettings); BOOL r2 = CFWriteStreamSetProperty(writeStream, kCFStreamPropertySSLSettings, tlsSettings);注意這裡的判斷用的是
&& 而非 ||——這是為繞過 Apple 的一個 bug 而刻意保留的寫法。看到這裡,回調的來源可能讓人有點糊塗。梳理一下,目前一共存在三類:
讀寫 source:與 socket 綁定,數據一到達就觸發事件句柄。但在 cf_startTLS 中我們調用了:
// 掛起讀寫 source [self suspendReadSource]; [self suspendWriteSource];
所以 CFStream 形式的 TLS,其讀寫並不由 source 觸發;而其他形式的讀寫,都是由 source 觸發的。
CFStream 綁定的讀寫回調:
static void CFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo) static void CFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo)
它與 CFStream 形式的 TLS 相關,負責該形式下的握手、流末尾等錯誤,以及數據到達的通知。由於連接完成時我們就已初始化過 stream,非 CFStream 形式下也會觸發這個回調,只是不會在「數據到達」時觸發。
SSL 安全通道綁定的讀寫函數:
static OSStatus SSLReadFunction(SSLConnectionRef connection, void *data, size_t *dataLength) static OSStatus SSLWriteFunction(SSLConnectionRef connection, const void *data, size_t *dataLength)
這兩個函數不由系統主動觸發,而需要我們主動調用 SSLRead / SSLWrite,回調才會被執行。
最後強調一個容易忽略的事實:無論是否調用框架的 Read 方法,數據到達後都會觸發回調,並經過一連串流動,最終匯入全局緩衝區 preBuffer。我們調用 Read,只不過是從這個緩衝區裡把數據取走而已。
受限於篇幅,本篇就停在這裡。如果有些地方讀起來仍不明朗,不必著急——等下一篇把核心方法 doReadData 講完,再回頭把整個流程串一遍,Read 的脈絡應該就清晰了。
過了年,各種節後綜合症導致這個系列拖得久了些,接下來會加快節奏,早日把坑填完。