> 文档中心 > OpenHarmony解读之设备认证：数据接收管理-消息处理(2)

OpenHarmony解读之设备认证：数据接收管理-消息处理(2)

文档中心

一、概述

本文将继续介绍HiChain本端接收数据的处理过程中的消息处理阶段的剩余内容。

二、源码分析

这一模块的源码位于：/base/security/deviceauth。

检查消息为系统可支持并合法之后，调用build_object函数构建HiChain子对象，具体分析如下：

/*函数功能：构建HiChain子对象函数参数：    hichain：HiChain实例    modular：消息模块类型    is_client：是否是client    params：构建参数函数返回值：    成功：返回0 HC_OK    失败：返回错误码详细：*/int32_t build_object(struct hichain *hichain, int32_t modular, bool is_client, const void *params){    //初始化HC对象表map    const struct object_map map[] = { { PAKE_MODULAR, true, (void **)&hichain->pake_client },//pake客户端   { PAKE_MODULAR, false, (void **)&hichain->pake_server },//pake服务端   { STS_MODULAR, true, (void **)&hichain->sts_client },//sts客户端   { STS_MODULAR, false, (void **)&hichain->sts_server },//sts服务端   { ADD_MODULAR, true, (void **)&hichain->auth_info },//认证信息   { REMOVE_MODULAR, true, (void **)&hichain->auth_info },//认证信息   { SEC_CLONE_MODULAR, false, (void **)&hichain->sec_clone_server } };//安全克隆服务端    void **object = get_object(map, sizeof(map) / sizeof(map[0]), modular, is_client);//根据消息模块类型获取HC对象    if ((object == NULL) || (*object != NULL)) {//获取失败 DBG_OUT("No sub-objects need to be applied for"); return HC_OK;    }    if (check_mutex_object_is_null(map, sizeof(map) / sizeof(map[0]), modular, is_client) == false) {//检查互斥对象是否为空??? LOGE("The mutex sub-object have been created, create %d:%d sub-object failed", modular, is_client); return HC_REPEATED_REFERENCE;    }    if (check_depend_object_is_not_null(map, sizeof(map) / sizeof(map[0]), modular, is_client) == false) {//检查依赖对象是否为非空??? LOGE("The depend sub-object is not created, create %d:%d sub-object failed", modular, is_client); return HC_NEED_DEPEND;    }    *object = build_object_by_modular(hichain, modular, is_client, params);//根据消息模块类型构建子对象    if (*object == NULL) { LOGE("Create %d:%d sub-object failed", modular, is_client); return HC_BUILD_OBJECT_FAILED;//构建失败    }    DBG_OUT("Create %d:%d sub-object success", modular, is_client);    return HC_OK;}//根据消息模块类型获取对象static void **get_object(const struct object_map *map, uint32_t n, int32_t modular, bool is_client){    for (uint32_t i = 0; i < n; i++) {//遍历对象表，查询指定对象类型 if ((modular == map[i].modular) && (is_client == map[i].is_client)) {     return map[i].object; }    }    return NULL;}//检查互斥对象是否为空，若为空返回true，否则返回falsestatic bool check_mutex_object_is_null(const struct object_map *map, uint32_t n, int32_t modular, bool is_client){    //初始化对象关系互斥表    const struct object_relation mutex_map[] = { { PAKE_MODULAR, STS_MODULAR, true, false },{ STS_MODULAR, PAKE_MODULAR, false, true },{ PAKE_MODULAR, STS_MODULAR, true, true },{ STS_MODULAR, PAKE_MODULAR, true, true },{ PAKE_MODULAR, STS_MODULAR, false, false },{ STS_MODULAR, PAKE_MODULAR, false, false },{ PAKE_MODULAR, STS_MODULAR, false, true },{ STS_MODULAR, PAKE_MODULAR, true, false },{ STS_MODULAR, STS_MODULAR, true, false },{ STS_MODULAR, STS_MODULAR, false, true },{ ADD_MODULAR, STS_MODULAR, true, false },{ STS_MODULAR, ADD_MODULAR, false, true },{ REMOVE_MODULAR, STS_MODULAR, true, false },{ STS_MODULAR, REMOVE_MODULAR, false, true },{ PAKE_MODULAR, SEC_CLONE_MODULAR, false, false },{ SEC_CLONE_MODULAR, PAKE_MODULAR, false, false } };    object_relation_ptr select_map[sizeof(mutex_map) / sizeof(mutex_map[0])] = {0};//定义并初始化一个select_map    uint32_t count = select_relation_map(mutex_map, sizeof(mutex_map) / sizeof(mutex_map[0]), modular, is_client, select_map);//根据modular和is_client从关系互斥表中查找对应的项并赋值给select_map，用count记录数量并返回    if (count == 0) { /* no muutex sub object 无互斥子对象*/ return true;    }    for (uint32_t i = 0; i < n; i++) { if ((map[i].modular == modular) && (map[i].is_client == is_client)) { /* skip sub object that will be created 跳过即将被创建的子对象*/     continue; } if (*map[i].object == NULL) { /* null sub object is correct even mutex */     continue; } for (uint32_t j = 0; j < count; j++) {     if ((map[i].modular == select_map[j]->dst_modular) && (map[i].is_client == select_map[j]->dst_is_client)) {  return false; /* mutex sub object and not null 互斥子对象为非空*/     } }    }    return true;}/*函数功能：检查依赖对象是否为非空函数参数：    map：对象表    n：对象个数    modular：消息模块    is_client：是否是客户端函数返回值：*/static bool check_depend_object_is_not_null(const struct object_map *map, uint32_t n, int32_t modular, bool is_client){    const struct object_relation depend_map[] = { { ADD_MODULAR, STS_MODULAR, true, true }, { REMOVE_MODULAR, STS_MODULAR, true, true }, { SEC_CLONE_MODULAR, STS_MODULAR, false, false } };//依赖对象关系表    object_relation_ptr select_map[sizeof(depend_map) / sizeof(depend_map[0])] = {0};    uint32_t count = select_relation_map(depend_map, sizeof(depend_map) / sizeof(depend_map[0]),      modular, is_client, select_map);    if (count == 0) { /* no dependent sub object 无依赖子对象*/ return true;    }    for (uint32_t i = 0; i < n; i++) { if ((map[i].modular == modular) && (map[i].is_client == is_client)) { /* skip sub object that will be created 跳过即将被创建的子对象*/     continue; } if (*map[i].object != NULL) { /* null sub object is correct even dependent */     continue; } for (uint32_t j = 0; j < count; j++) {     if ((map[i].modular == select_map[j]->dst_modular) && (map[i].is_client == select_map[j]->dst_is_client)) {  return false; /* depentend sub object and not null 依赖子对象为非空*/     } }    }    return true;}//根据modular和is_client从关系表中查找对应的项并赋值给select_map，用count记录数量并返回static uint32_t select_relation_map(const struct object_relation *map, uint32_t n, int32_t modular, bool is_client,    object_relation_ptr *select_map){    uint32_t count = 0;    for (uint32_t i = 0; i < n; i++) { if ((modular == map[i].src_modular) && (is_client == map[i].src_is_client)) {     select_map[count] = &map[i];     count++;//记录数量 }    }    return count;}

然后根据消息模块类型构建子对象，在函数build_object_by_modular中实现，具体分析如下：

//根据消息模块类型构建子对象static void *build_object_by_modular(struct hichain *hichain, int32_t modular, bool is_client, const void *params){    //初始化子对象表    const struct build_sub_object_map map[] = { { PAKE_MODULAR, true, build_pake_client_object },//构建pake客户端对象      { PAKE_MODULAR, false, build_pake_server_object },//构建pake服务端对象      { STS_MODULAR, true, build_sts_client_object },//构建sts客户端对象      { STS_MODULAR, false, build_sts_server_object },//构建sts服务端对象      { ADD_MODULAR, true, build_auth_info_client_object },//构建认证信息客户端对象      { REMOVE_MODULAR, true, build_auth_info_client_object },//构建认证信息客户端对象      { SEC_CLONE_MODULAR, false, build_sec_clone_server_object } };//构建安全克隆服务端对象    for (uint32_t i = 0; i < sizeof(map) / sizeof(map[0]); i++) {//遍历子对象构建表，根据modular及is_client查询对应子对象的回调函数 if ((map[i].modular == modular) && (map[i].is_client == is_client)) {     return map[i].build_func(hichain, params);//执行对应回调函数构建子对象!!! }    }    return NULL;}

紧接着回到函数receive_data中，执行proc_message函数处理消息：

/*函数功能：根据modular和is_request_msg查询全局分布式消息表，找到对应的消息处理函数并执行函数参数：    handle：HiChain处理实例    nav：导航消息头    receive：接收到的解析后的消息    send：传出参数，保存处理后的回复消息函数返回值：*/int32_t proc_message(struct hichain *handle, struct header_analysis *nav,    struct message *receive, struct message *send){    for (uint32_t i = 0; i < sizeof(G_DISTRIBUTION_MESSAGE) / sizeof(G_DISTRIBUTION_MESSAGE[0]); i++) {//遍历全局分布式消息表 if ((nav->modular == G_DISTRIBUTION_MESSAGE[i].modular) &&     (nav->is_request_msg == G_DISTRIBUTION_MESSAGE[i].is_request_msg)) {     int32_t ret = G_DISTRIBUTION_MESSAGE[i].func(handle, nav, receive, send);//处理消息     LOGI("Proc_message return code is %d", ret);     return ret; }    }    return HC_UNKNOW_MESSAGE;}

最后调用connect_message函数：

/*函数功能：连接消息函数参数：    handle：hichain实例对象    nav：导航消息    send：发送消息函数返回值：    成功：返回0    失败：返回错误码*/int32_t connect_message(struct hichain *handle, struct header_analysis *nav, struct message *send){    if (nav->modular != STS_MODULAR && nav->modular != PAKE_MODULAR) {//如果消息既不属于pake协议也不属于sts协议，则直接返回 return HC_OK;    }    if (nav->msg_type != STS_END_MSG) {//如果消息类型不是sts结束消息，则直接返回 return HC_OK;    }    if (nav->is_request_msg) { /* server does not need message connection 服务端不需要消息连接*/ return HC_OK;    }    int32_t ret;    switch (handle->operation_code) {//根据操作码进行不同的处理 case BIND:     ret = send_exchange_request(handle, send);//发送交换信息请求     LOGI("Client build exchange request message return value is %d", ret);     return ret; case AUTHENTICATE:     send->msg_code = INVALID_MESSAGE;     return HC_OK; case ADD_AUTHINFO:     ret = send_add_request(handle, send);//发送添加认证信息请求     LOGI("Client build add auth info request message return value is %d", ret);     return ret; case REMOVE_AUTHINFO:     ret = send_remove_request(handle, send);//发送移除请求     LOGI("Client build remove auth info request message return value is %d", ret);     return ret; default:     return HC_INNER_ERROR;    }    return HC_OK;}

三、小结

至此，HiChain本端接收数据的处理过程结束，至于具体的不同协议的处理过程及响应过程，将在接下来的博客中进行介绍。