您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

iOS 即時通訊進階:CocoaAsyncSocket 源碼解析之 Read 篇

編輯:iOS 開發基礎

本文是 CocoaAsyncSocket 源碼系列的第二篇——Read 篇,重點關注框架如何借助緩衝區完成數據讀取、如何應對各種分包情形,以及普通讀取與基於 TLS 的讀取有何不同。

先提醒一句:這個框架源碼量龐大,且有大量相對抽象的內存操作邏輯,讀起來並不輕鬆。如果你只是想找點輕鬆的閱讀,這裡可以先止步了。

系列首篇 Connect 篇已經完結,有興趣可以回看。文中涉及代碼較多,建議對照源碼閱讀,理解會更透徹;我標註好注釋的版本可以作為參照。若對框架用法尚不熟悉,也可以先看看我此前的入門文章或粘包/斷包處理實例。

本文的推進路線:

  1. 淺析 Read 讀取,梳理數據從 socket 到用戶手中的完整流程;
  2. 說明兩種 TLS 建立連接的過程;
  3. 深入核心方法 doReadData 的實現。

一、Read 讀取與數據流向

用過這個框架的人都知道,每次讀數據前都要主動調一次:

[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,隨後開始讀數據。

GCDAsyncReadPacket 的結構

先看看它的屬性:

@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,再通過代理回傳給業務層。

maybeDequeueRead:讓任務出隊

// 讓讀任務離隊,開始執行這條讀任務
- (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];
                }
            }
        }
    }
}

細節看注釋即可,這裡提煉四條主幹:

  1. 先做一系列判斷:是否已連接、讀隊列任務是否大於 0 等。判斷失敗就不再讀取,直接返回。
  2. 從全局 readQueue 取出第一條任務並判斷類型:若是 GCDAsyncSpecialPacket,開啟 TLS 認證(後文細講);若是 GCDAsyncReadPacket,調用 doReadData 開始讀取——這將是整個 Read 篇的核心。
  3. 若隊列為空,則判斷是否命中「上次讀取超時未拿到數據」的標記,若是則斷開 socket。這正是應用層設置超時後、時間到仍未讀到數據時的落腳點。
  4. 若是基於 TLS 的安全連接,調用 flushSSLBuffers,把數據從 SSL 通道搬到全局緩衝區 preBuffer。

為幫助理解,這裡放一張流程圖:

圖中呈現的就是數據的完整流向。讀取分兩大類:普通讀取與基於 TLS 的讀取;而 TLS 讀取又分兩種——基於 CFStream 的,以及走 SecureTransport 安全通道的。兩者都在各自通道內完成解密,解密後的數據統一流向全局緩衝區 preBuffer。

可以把 preBuffer 想成一個蓄水池:只要不去讀,裡面的數據就會越積越多;把數據全部讀走,它就回到最初的狀態。我們用 currentRead 從 preBuffer 取數據,一旦讀到預期的位置,就回調代理,把數據交到業務層手裡。

二、兩種 TLS 的建立過程

說到這裡,不得不提框架開啟 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。關於這種基於流的實現與常規做法的區別,官方說明寫得很清楚:

  • GCDAsyncSocketUseCFStreamForTLS (iOS only)
  • The value must be of type NSNumber, encapsulating a BOOL value.
  • By default GCDAsyncSocket will use the SecureTransport layer to perform encryption.
  • This gives us more control over the security protocol (many more configuration options),
  • plus it allows us to optimize things like sys calls and buffer allocation.
  • However, if you absolutely must, you can instruct GCDAsyncSocket to use the old-fashioned encryption
  • technique by going through the CFStream instead. So instead of using SecureTransport, GCDAsyncSocket
  • will instead setup a CFRead/CFWriteStream. And then set the kCFStreamPropertySSLSettings property
  • (via CFReadStreamSetProperty / CFWriteStreamSetProperty) and will pass the given options to this method.
  • Thus all the other keys in the given dictionary will be ignored by GCDAsyncSocket,
  • and will passed directly CFReadStreamSetProperty / CFWriteStreamSetProperty.
  • For more infomation on these keys, please see the documentation for kCFStreamPropertySSLSettings.
  • If unspecified, the default value is NO.

也就是說:CFStream 形式的 TLS 僅適用於 iOS 平台,且屬於過時的加解密方式;沒有特殊理由,最好別用它。

startTLS 的實現

// 開啟 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 認證與握手;排在它前面的包,仍按明文正常收發。

maybeStartTLS:分流兩種 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。

ssl_startTLS:SecureTransport 通道

這個方法有 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_continueSSLHandshake:握手與狀態分支

// 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 認證就完成了。

cf_startTLS:CFStream 通道

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...");
}

三步走完:

  1. 掛起讀寫 source,重新初始化讀寫流、綁定回調並加入 runloop。這裡為何要「重新」來一遍?看過 Connect 篇就知道,連接成功後我們已經初始化過讀寫流。此處並不會重新創建,只是調整參數——關鍵在於下面這行傳入了 YES:
    if (![self registerForStreamCallbacksIncludingReadWrite:YES])
    這個參數會讓方法多註冊一種回調觸發方式 kCFStreamEventHasBytesAvailable,即有數據可讀時觸發 Stream 回調。
  2. 把 TLS 配置直接設置給讀寫流:
    BOOL r1 = CFReadStreamSetProperty(readStream, kCFStreamPropertySSLSettings, tlsSettings);
    BOOL r2 = CFWriteStreamSetProperty(writeStream, kCFStreamPropertySSLSettings, tlsSettings);
    注意這裡的判斷用的是 && 而非 ||——這是為繞過 Apple 的一個 bug 而刻意保留的寫法。
  3. 打開讀寫流,整個 CFStream 形式的 TLS 就完成了。

三種回調觸發途徑,別搞混

看到這裡,回調的來源可能讓人有點糊塗。梳理一下,目前一共存在三類:

讀寫 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 的脈絡應該就清晰了。

過了年,各種節後綜合症導致這個系列拖得久了些,接下來會加快節奏,早日把坑填完。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved