OpenHarmony模块二下文件samgr_server解析（5）_openharmony samgr

distributedschedule_samgr_lite/samgr_server/source/samgr_server.c

注册Samgr终端，设置一个sa管理器

static int RegisterSamgrEndpoint(const IpcContext* context, SvcIdentity* identity)
{
    int ret = SetSaManager(context, MAX_SA_SIZE);
    //若满足如下情况，则设置sa管理器失败
    if (ret != LITEIPC_OK) {
        HILOG_FATAL(HILOG_MODULE_SAMGR, "Set sa manager<%d> failed!", ret);
        //设置sa管理器失败！我们需要重新启动才能恢复
        exit(-ret);
    }
    identity->handle = SAMGR_HANDLE;
    identity->token = SAMGR_TOKEN;
    identity->cookie = SAMGR_COOKIE;
    return EC_SUCCESS;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在结束的进程终端退出时，

static int OnEndpointExit(const IpcContext *context, void* ipcMsg, IpcIo* data, void* argv)
{
    (void)data;
    if (ipcMsg != NULL) {
        FreeBuffer(context, ipcMsg); //设置一个自由缓冲区
    }
    pid_t pid = (pid_t)((uintptr_t)argv);
    Request request = {0};
    request.msgId = MSG_CLEAN;
    request.msgValue = pid;
    int retry = RETRY_TIMES;
    int ret = EC_INVALID;
    while (retry > 0) {
        ret = SAMGR_SendRequest(&g_server.identity, &request, NULL);
        if (ret == EC_SUCCESS) {
            break;
        }
        sleep(RETRY_INTERVAL);//延时操作
        --retry;
    }
#ifdef __LINUX__
    PidHandle handle;
    int err = SASTORA_FindHandleByPid(&g_server.store, pid, &handle);
    if (err != INVALID_INDEX) {
        BinderRelease(context, handle.handle);
    }
#endif
    //发送清除请求重试！
    HILOG_ERROR(HILOG_MODULE_SAMGR, "IPC pid<%d> exit! send clean request retry(%d), ret(%d)!", pid, retry, ret);
    return EC_SUCCESS;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Ipc身份验证接口

static IpcAuthInterface *GetIpcAuthInterface(void)
{
    IpcAuthInterface *ipcAuth = NULL;
    IUnknown *iUnknown = SAMGR_GetInstance()->GetFeatureApi(PERMISSION_SERVICE, IPCAUTH);
    //若指针iUnknown为空，则获取IPC身份验证接口为空
    if (iUnknown == NULL) {
        HILOG_ERROR(HILOG_MODULE_SAMGR, "Get IpcAuthInterface: IUnknown NULL");
        return NULL;
    }
    (void)iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&ipcAuth);
    return ipcAuth;
}
1
2
3
4
5
6
7
8
9
10
11
12

获取Json信息流

static cJSON *GetJsonStream()
{
    const char *path = "/etc/system_capability.json";
    struct stat fileInfo;
    int32_t size = 0;

    if (stat(path, &fileInfo) != 0 || (size = fileInfo.st_size) == 0) {
        return NULL;
    }

    int32_t fp = open(path, O_RDONLY, S_IRUSR); 
    if (fp < 0) {
        return NULL;
    }

    char *json = (char *)SAMGR_Malloc(size * sizeof(char)); //释放内存
    if (json == NULL) {
        close(fp);
        return NULL;
    }
    if (read(fp, json, size * sizeof(char)) != size * sizeof(char)) {
        SAMGR_Free(json);
        close(fp);
        return NULL;
    }
    close(fp);

    cJSON *root = cJSON_Parse(json);
    SAMGR_Free(json);
    json = NULL;
    return root;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

解析系统上限

static void ParseSysCap(void)
{
    cJSON *root = GetJsonStream();
    //解析系统CAP获取信息流失败
    if (root == NULL) {
        HILOG_ERROR(HILOG_MODULE_SAMGR, "ParseSysCap GetJsonStream failed!");
        return;
    }
    cJSON *sysCaps = cJSON_GetObjectItem(root, "systemCapability");//获取对象项
    if (!cJSON_IsArray(sysCaps)) {
        cJSON_Delete(root);
        HILOG_ERROR(HILOG_MODULE_SAMGR, "ParseSysCap format failed!");
        return;
    }
    int32_t size = cJSON_GetArraySize(sysCaps); //获取数组大小
    int32_t sysCapNum = 0;
    for (int32_t i = 0; i < size; i++) {
        if (sysCapNum >= MAX_SYSCAP_NUM) {  //解析的系统能力所占空间超过最大值，溢出
            HILOG_ERROR(HILOG_MODULE_SAMGR, "ParseSycCapMap system capability exceed");
            break;
        }
        cJSON *item = cJSON_GetArrayItem(sysCaps, i);   //获取数组项
        if (!cJSON_IsObject(item)) {
            continue;
        }
        cJSON *name = cJSON_GetObjectItem(item, "name");
        cJSON *isRegister = cJSON_GetObjectItem(item, "register-on-startup");   //启动时注册
        if (!cJSON_IsString(name) || !cJSON_IsBool(isRegister)) {
            continue;
        }
        char *nameStr = cJSON_GetStringValue(name);
        if (VECTOR_FindByKey(&(g_server.sysCapabilitys), nameStr) != INVALID_INDEX) {
            //复制系统能力寄存器！
            HILOG_WARN(HILOG_MODULE_SAMGR, "Duplicate system capability %s register!", nameStr);
            continue;
        }
        SysCapImpl *impl = (SysCapImpl *)SAMGR_Malloc(sizeof(SysCapImpl));
        if (impl == NULL) {
            continue;
        }
        //获取字符串值
        if (strcpy_s(impl->name, sizeof(impl->name), cJSON_GetStringValue(name)) != EC_SUCCESS) {
            SAMGR_Free(impl);
            continue;
        }
        impl->isRegister = cJSON_IsTrue(isRegister);
        //若满足以下条件，则系统能力注册失败
        if (VECTOR_Add(&(g_server.sysCapabilitys), impl) == INVALID_INDEX) {
            SAMGR_Free(impl);
            HILOG_ERROR(HILOG_MODULE_SAMGR, "system capability %s register failed!", impl->name);
            continue;
        }
        sysCapNum++;
    }
    cJSON_Delete(root);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

该文件的所有代码已经注释完，若有不赞同的地方可以留言探讨，望指正