鸿蒙源码分析（十一）

ゞ浴缸里的玫瑰 2022-09-02 13:49 214阅读 0赞

# tcp\_session\_manager.c代码分析中篇 #

本篇主要分析tcp\_session\_manager.c中出现的函数

# 一、相关链接 #

和本篇代码相关的一些背景知识和该文件的上一部分代码详解：

1.  [tcp\_socket机制详解][tcp_socket]
2.  [互斥锁和消息队列详解][Link 1]
3.  [tcp\_session详解][tcp_session]
4.  [tcp\_session\_manager.c代码分析上篇][tcp_session_manager.c]

# 二、代码分析 #

static bool AssignValue2Session(TcpSession *session, cJSON *receiveObj)
    //标记值转换到session
    { 
        if (receiveObj == NULL) { 
            return false;
            //检查参数
        }
    
        char *recvBus = GetJsonString(receiveObj, "BUS_NAME");
        //通过参数获取jsonstring
        if (recvBus == NULL) { 
            return false;
            //检查上一步是否成功获取
        }
        if (strncpy_s(session->sessionName, NAME_LENGTH, recvBus, strlen(recvBus)) != 0) { 
            return false;
        }
    
        char *sessionKeyEncoded = GetJsonString(receiveObj, "SESSION_KEY");
        //获取sessionkey的json.string值
        if (sessionKeyEncoded == NULL) { 
            return false;//检查是否获取成功
        }
        size_t olen = 0;
        int ret = mbedtls_base64_decode((unsigned char *)session->sessionKey, SESSION_KEY_LENGTH,
            &olen, (unsigned char *)sessionKeyEncoded, strlen(sessionKeyEncoded));
        //基于base64进行编码
        if (ret != 0) { 
            SOFTBUS_PRINT("[TRANS] AssignValue2Session mbedtls_base64_decode error: %d\n", ret);
            return false;
            //用来检查是否编码成功
        }
    
        SOFTBUS_PRINT("[TRANS] AssignValue2Session busname=%s, fd=%d\n", session->sessionName, session->fd);
        return true;
    }
    
    static bool ResponseToClient(TcpSession *session)//客户端响应函数
    { 
        cJSON *jsonObj = cJSON_CreateObject();
        if (jsonObj == NULL) { 
            return false;
        }
    
        GetReplyMsg(jsonObj, session);//接受回复的消息
        char *msg = cJSON_PrintUnformatted(jsonObj);
        //将jsonObj转换为字符串数据
        if (msg == NULL) { 
            cJSON_Delete(jsonObj);
            return false;、
            //检查是否转换成功
        }
    
        int bufLen = 0;
        unsigned char *buf = PackBytes(msg, &bufLen);
        //打包数据
        if (buf == NULL) { 
            SOFTBUS_PRINT("[TRANS] ResponseToClient PackBytes fail\n");
    
            free(msg);
            cJSON_Delete(jsonObj);
            return false;
        }
    
        int dataLen = TcpSendData(session->fd, (char*)buf, bufLen, 0);
        //发送数据到tcp连接的另一端，datalen的值为发送的数据大小
        free(msg);
        cJSON_Delete(jsonObj);
        free(buf);
        if (dataLen <= 0) { 
            SOFTBUS_PRINT("[TRANS] ResponseToClient TcpSendData fail\n");
            return false;
            //检查数据是否发送到tcp另一端
        }
        return true;
    }
    
    static bool HandleRequestMsg(TcpSession *session)
    //用来处理用户请求消息
    { 
        char data[RECIVED_BUFF_SIZE] = {  0 };//初始化数组
        int size = TcpRecvData(session->fd, data, AUTH_PACKET_HEAD_SIZE, 0);
        //size为接收信息的数据大小
    	if (size != AUTH_PACKET_HEAD_SIZE) { 
    		return false;
            //检查接受的数据大小是否和用户数据包大小相同
    	}
        int identifier = GetIntFromBuf(data, 0); 用来将data中内容以offset=0的偏置进行复制信息
    
        if ((unsigned int)identifier != PKG_HEADER_IDENTIFIER) { 
            return false;
            //检查是否复制成功
        }
    	int dataLen = GetIntFromBuf(data, AUTH_PACKET_HEAD_SIZE - sizeof(int));
    	if (dataLen + AUTH_PACKET_HEAD_SIZE >= RECIVED_BUFF_SIZE) { 
    		return false;
    	}
    	int total = size;
    	int remain = dataLen;
    	while (remain > 0) { 
    		size = TcpRecvData(session->fd, data + total, remain, 0);
    		remain -= size;
    		total += size;
    	}
        //如果有接收到数据，就将用户发送的信息不断接收到data当中（位置为data首地址+total）
        cJSON *receiveObj = TransFirstPkg2Json(data, dataLen + AUTH_PACKET_HEAD_SIZE);
        if (receiveObj == NULL) { 
            return false;
        }
        int ret = AssignValue2Session(session, receiveObj);
        cJSON_Delete(receiveObj);
        if (ret != true) { 
            return false;
        }
        //以上为两种数据的类型转换
        SessionListenerMap *sessionListener = GetSessionListenerByName(session->sessionName, strlen(session->sessionName));
        //通过name来启动监听
        if (sessionListener == NULL) { 
            return false;
        }
        if (!ResponseToClient(session)) { 
            SOFTBUS_PRINT("[TRANS] HandleRequestMsg ResponseToClient fail\n");
            return false;
            //响应到客户端
        }
        if (sessionListener->listener == NULL) { 
            return false;
        }
        if (sessionListener->listener->onSessionOpened == NULL) { 
            return false;
        }
        if (sessionListener->listener->onSessionOpened(session->fd) != 0) { 
            return false;
        }
        //检测会话监听和相关session是否打开
        return true;
    }
    
    static void FreeSessionRecvMem(char* recvDataBuf, TcpSession* session)//释放会话接收成员
    { 
        if (recvDataBuf != NULL) { 
            free(recvDataBuf);
            //检查如果传入的数组recvDataBuf不为空，就释放空间。
        }
        if (session == NULL) { 
            return;
        }
    
        CloseSession(session->fd);//根据传入的session，获取套接字关闭相应文件设备
    }
    
    static int32_t TcpSessionRecv(TcpSession *session, const char* buf, uint32_t size, int timeout)
    { 
        if (buf == NULL || session == NULL || session->fd < 0 || size <= 0 || timeout < 0) { 
            return TRANS_FAILED;
            //参数检查
        }
    
        char *recvDataBuf = calloc(1, size + OVERHEAD_LEN);
        //calloc函数申请一个size+OVERHEAD_LEN大小的
        if (recvDataBuf == NULL) { 
            return TRANS_FAILED;
            //接收数据的缓冲区为空的话函数返回
        }
        int recvSize = TcpRecvData(session->fd, recvDataBuf, size + OVERHEAD_LEN, 0);
        //从tcp的另一端接收数据，返回接受数据的大小
        if (recvSize < TRANS_PACKET_HEAD_SIZE) { 
            FreeSessionRecvMem(recvDataBuf, session);
            return TRANS_FAILED;
            //接受的数据小于传输数据，就释放session会话成员
        }
    
        long long seq = 0;
        AesGcmCipherKey cipherKey = { 0};
        cipherKey.keybits = GCM_KEY_BITS_LEN_256;
        int ret = memcpy_s(&seq, SIZE_OF_LONG_LONG, recvDataBuf + TRANS_SEQ_NUM_OFFSET, SIZE_OF_LONG_LONG);//复制recvDataBuf + TRANS_SEQ_NUM_OFFSET开始的内容到seq
        ret += memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, session->sessionKey, SESSION_KEY_LENGTH);
        ret += memcpy_s(cipherKey.iv, IV_LEN, recvDataBuf + TRANS_PACKET_HEAD_SIZE, IV_LEN);
        //将接受的数据赋值进seq和cipherKey.iv，将对应session的键值复制进cipherKey.key
        if (ret != 0) { 
            FreeSessionRecvMem(recvDataBuf, session);
            return TRANS_FAILED;
            //同来检查前面的复制是否存在失败，只要存在失败便ret<0
        }
    
        SessionSeqNumNode* node = calloc(1, sizeof(SessionSeqNumNode));//申请一个sizeof(SessionSeqNumNode)大小的数组
        if (node == NULL) { 
            FreeSessionRecvMem(recvDataBuf, session);
            return TRANS_FAILED;
        }
        node->seqNum = seq;
        ListInsertTail(session->seqNumList, &(node->head));//将&(node->head)插入链表session->seqNumList
    
        int plainLen = DecryptTransData(&cipherKey, (unsigned char*)(recvDataBuf + TRANS_PACKET_HEAD_SIZE),
            recvSize - TRANS_PACKET_HEAD_SIZE, (unsigned char*)buf, size);
            //对cipherKey密钥进行加密
        free(recvDataBuf);//释放数据缓冲
        if (plainLen <= 0) { 
            return TRANS_FAILED;
        }
    
        return plainLen;
    }
    
    static bool OnProcessDataAvailable(TcpSession *session)
    { 
        if (session == NULL) { 
            return false;
        }
    
        if (strcmp(session->sessionName, "softbus_Lite_unknown") == 0) { 
            //比较会话名和softbus_Lite_unknown是否相同
            bool isSuccess = HandleRequestMsg(session);
            if (!isSuccess) { 
                //如果处理请求信息不成功就关闭session—>fd套接字对应设备
                CloseSession(session->fd);
            }
            return isSuccess;
        } else { //如果
            unsigned char* buf = calloc(1, RECIVED_BUFF_SIZE);
            if (buf == NULL) { 
                return false;
            }
            SOFTBUS_PRINT("[TRANS] OnProcessDataAvailable sessionName: %s, fd: %d\n", session->sessionName, session->fd);
            SessionListenerMap *sessionListener = GetSessionListenerByName(session->sessionName,
                strlen(session->sessionName));
            if (sessionListener != NULL && sessionListener->listener != NULL) { 
                int recvLen = TcpSessionRecv(session, (char *)buf, RECIVED_BUFF_SIZE, 0);
                if (recvLen < 0) { 
                    free(buf);
                    return false;
                }
                sessionListener->listener->onBytesReceived(session->fd, buf, recvLen);
                free(buf);
                return true;
            }
            free(buf);
        }
    
        return false;
    }
    
    static void ProcessSesssionData(const TcpSessionMgr *tsm, const fd_set *rfds)
    { 
        for (int i = 0; i < MAX_SESSION_SUM_NUM; i++) { 
            if (tsm->sessionMap_[i] != NULL && tsm->sessionMap_[i]->fd != -1 &&
                FD_ISSET(tsm->sessionMap_[i]->fd, rfds) > 0) { 
                if (!OnProcessDataAvailable(tsm->sessionMap_[i])) { 
                    return;
                }
            }
        }
    }
    
    static void ProcessData(TcpSessionMgr *tsm, fd_set *rfds)//来检查tsm变量的监听套接字是否在集合rfds中，在的话根据套接字连接监听的进程
    { 
        if (tsm == NULL || tsm->listenFd == -1) { 
            return;
        }
    
        if (FD_ISSET(tsm->listenFd, rfds)) { 
            ProcessConnection(tsm);
            return;
        }
    
        ProcessSesssionData(tsm, rfds);
    }
    
    static void FreeSessionMgr(void)//释放会话管理 
    { 
        free(g_sessionMgr);
        g_sessionMgr = NULL;
    }

[tcp_socket]: https://forum.trustie.net/forums/3397/detail
[Link 1]: https://forum.trustie.net/forums/3440/detail
[tcp_session]: https://forum.trustie.net/forums/3447/detail
[tcp_session_manager.c]: https://forum.trustie.net/forums/3471/detail