OpenHarmony轻量系统服务管理|进程间通信的核心机制详解(四)-CSDN博客

本文链接：https://blog.csdn.net/MNxiaona666/article/details/142064493

往期知识点记录：

函数实现详解

更新指定router的访问策略

//为指定的router添加访问策略信息
static int AddPolicyToRouter(const Endpoint *endpoint, const SvcIdentity *saInfo,
                             const PolicyTrans *policy, uint32 policyNum)
{
    //参数检查
    if (endpoint == NULL || saInfo == NULL || policy == NULL)
    {
        return EC_INVALID;
    }
    //根据token从本地endpoint的routers中获取对应的router
    Router *router = VECTOR_At((Vector *)&endpoint->routers, saInfo->token);
    if (router == NULL)
    {
        HILOG_ERROR(HILOG_MODULE_SAMGR, "Router <%s, %u> is NULL", endpoint->name, saInfo->token);
        return EC_INVALID;
    }
    //若router的访问策略不为NULL，则不需要更新，返回EC_SUCCESS
    if (router->policy != NULL)
    {
        return EC_SUCCESS;
    }//访问策略为NULL
    //保存访问策略信息
    router->policyNum = policyNum;
    if (policyNum == 0)
    {
        //访问策略的数目为0，程序异常，返回EC_INVALID
        return EC_INVALID;
    }
    //申请内存，用于存储访问策略信息
    router->policy = (PolicyTrans *)SAMGR_Malloc(sizeof(PolicyTrans) * policyNum);
    if (router->policy == NULL)
    {
        return EC_NOMEMORY;
    }
    //拷贝访问策略信息
    if (memcpy_s(router->policy, sizeof(PolicyTrans) * policyNum, policy, sizeof(PolicyTrans) * policyNum) != EOK)
    {
        //拷贝失败，回收资源
        SAMGR_Free(router->policy);
        router->policy = NULL;
        HILOG_ERROR(HILOG_MODULE_SAMGR, "Add Policy <%s, %s, %s> Failed!",
                    endpoint->name, router->saName.service, router->saName.feature);
        return EC_FAILURE;
    }
    HILOG_DEBUG(HILOG_MODULE_SAMGR, "Add Policy <%s, %s, %s> Success",
                endpoint->name, router->saName.service, router->saName.feature);
    return EC_SUCCESS;
}

获取远端的访问策略

/*
    函数功能：从响应消息中获取访问策略信息
    函数参数：@reply：响应消息
             @policy：访问策略
             @policyNum：访问策略的数目
    函数描述：从响应消息中解析访问策略信息，根据不同的policy类型选择不同的数据解析方式。
*/
static void GetRemotePolicy(IpcIo *reply, PolicyTrans **policy, uint32 *policyNum)
{
    if (reply == NULL)
    {
        return;
    }
    uint32 i;
    uint32 j;
    //从reply中获取policy数目
    *policyNum = IpcIoPopUint32(reply);
    if (*policyNum > MAX_POLICY_NUM)
    {
        //policyNum超出最大值
        *policyNum = MAX_POLICY_NUM;
    }
    //释放旧的policy资源
    SAMGR_Free(*policy);
    if (*policyNum == 0)
    {
        *policy = NULL;
        return;
    }
    //为policy申请新的空间
    *policy = (PolicyTrans *)SAMGR_Malloc(sizeof(PolicyTrans) * (*policyNum));
    if (*policy == NULL)
    {
        return;
    }
    //循环执行policyNum次，读取policy的信息
    for (i = 0; i < *policyNum; i++)
    {
        //从reply中读消息，获取policy[i]的类型
        (*policy)[i].type = IpcIoPopInt32(reply);
        //根据类型进行不同的读取操作
        switch ((*policy)[i].type)
        {
        case RANGE:
            //按照范围值，读取最小值和最大值
            (*policy)[i].uidMin = IpcIoPopInt32(reply);
            (*policy)[i].uidMax = IpcIoPopInt32(reply);
            break;
        case FIXED:
            //按照固定值，循环读取
            for (j = 0; j < UID_SIZE; j++)
            {
                (*policy)[i].fixedUid[j] = IpcIoPopInt32(reply);
            }
            break;
        case BUNDLENAME://只允许特定应用
            (*policy)[i].fixedUid[0] = IpcIoPopInt32(reply);
            break;
        default:
            break;
        }
    }
}

校验调用者是否合法

//判断callingUid值是否合法
static boolean JudgePolicy(uid_t callingUid, const PolicyTrans *policy, uint32 policyNum)
{
    if (policy == NULL)
    {
        //参数检查，未配置访问策略，返回FALSE
        HILOG_ERROR(HILOG_MODULE_SAMGR, "Policy is NULL! Num is %u", policyNum);
        return FALSE;
    }
    uint32 i;
    //遍历访问策略，合法返回true
    for (i = 0; i < policyNum; i++)
    {
        //policy类型是范围值，且uid在最小和最大值之间属于合法，返回true
        if (policy[i].type == RANGE && callingUid >= policy[i].uidMin && callingUid <= policy[i].uidMax)
        {
            return TRUE;
        }
        //policy类型是固定值，则判断policy的fixedUid集合中是否存在callingUid，若存在则返回true
        if (policy[i].type == FIXED && SearchFixedPolicy(callingUid, policy[i]))
        {
            return TRUE;
        }
    }
    return FALSE;
}

校验访问策略类型为FIXED的用户权限

//判断policy的fixedUid集合中是否存在callingUid
//若存在 返回true 否则返回 false
static boolean SearchFixedPolicy(uid_t callingUid, PolicyTrans policy)
{
    int i;
    //遍历fixedUid数组
    for (i = 0; i < UID_SIZE; i++)
    {
        //若callinguid在fixedUid数组中，则返回true
        if (callingUid == policy.fixedUid[i])
        {
            return TRUE;
        }
    }
    return FALSE;
}