1/*
2 * Copyright (C) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *    http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "ipc_sdk.h"
17
18#include "common_defs.h"
19#include "device_auth_defines.h"
20#include "device_auth.h"
21#include "hc_log.h"
22#include "hc_mutex.h"
23
24#include "ipc_adapt.h"
25#include "securec.h"
26
27#ifdef __cplusplus
28extern "C" {
29#endif
30
31#define IPC_DATA_CACHES_1 1
32#define IPC_DATA_CACHES_3 3
33#define IPC_DATA_CACHES_4 4
34#define REPLAY_CACHE_NUM(caches) (sizeof(caches) / sizeof(IpcDataInfo))
35#define IPC_APPID_LEN 128
36
37#define IS_COMM_DATA_VALID(dPtr, dLen) (((dPtr) != NULL) && ((dLen) > 0) && ((dLen) <= 4096))
38
39static const int32_t IPC_RESULT_NUM_1 = 1;
40static const int32_t IPC_RESULT_NUM_2 = 2;
41
42typedef struct {
43    uintptr_t inst;
44    char appId[IPC_APPID_LEN];
45} IpcProxyCbInfo;
46static IpcProxyCbInfo g_ipcProxyCbList = { 0 };
47static IpcProxyCbInfo g_ipcListenerCbList = { 0 };
48static HcMutex g_ipcMutex;
49
50static bool IsStrInvalid(const char *str)
51{
52    return (str == NULL || str[0] == 0);
53}
54
55static void DelIpcCliCallbackCtx(const char *appId, IpcProxyCbInfo *cbCache)
56{
57    int32_t ret;
58
59    if (cbCache->appId[0] == 0) {
60        return;
61    }
62    (void)LockHcMutex(&g_ipcMutex);
63    ret = memcmp(appId, cbCache->appId, HcStrlen(cbCache->appId) + 1);
64    if (ret == 0) {
65        cbCache->appId[0] = 0;
66    }
67    UnlockHcMutex(&g_ipcMutex);
68    return;
69}
70
71static void AddIpcCliCallbackCtx(const char *appId, uintptr_t cbInst, IpcProxyCbInfo *cbCache)
72{
73    errno_t eno;
74
75    (void)LockHcMutex(&g_ipcMutex);
76    eno = memcpy_s(cbCache->appId, IPC_APPID_LEN, appId, HcStrlen(appId) + 1);
77    if (eno != EOK) {
78        UnlockHcMutex(&g_ipcMutex);
79        LOGE("memory copy failed");
80        return;
81    }
82    cbCache->inst = cbInst;
83    UnlockHcMutex(&g_ipcMutex);
84}
85
86static void GetIpcReplyByType(const IpcDataInfo *ipcData,
87    int32_t dataNum, int32_t type, uint8_t *outCache, int32_t *cacheLen)
88{
89    int32_t i;
90    errno_t eno;
91
92    for (i = 0; i < dataNum; i++) {
93        if (ipcData[i].type != type) {
94            continue;
95        }
96        switch (type) {
97            case PARAM_TYPE_REG_INFO:
98            case PARAM_TYPE_DEVICE_INFO:
99            case PARAM_TYPE_GROUP_INFO:
100            case PARAM_TYPE_RETURN_DATA:
101                *(uint8_t **)outCache = ipcData[i].val;
102                break;
103            case PARAM_TYPE_IPC_RESULT:
104            case PARAM_TYPE_IPC_RESULT_NUM:
105            case PARAM_TYPE_COMM_DATA:
106            case PARAM_TYPE_DATA_NUM:
107                eno = memcpy_s(outCache, *cacheLen, ipcData[i].val, ipcData[i].valSz);
108                if (eno != EOK) {
109                    break;
110                }
111                *cacheLen = ipcData[i].valSz;
112                break;
113            default:
114                LOGE("un-expectation type case");
115                break;
116        }
117    }
118    return;
119}
120
121static int32_t IpcGmRegCallback(const char *appId, const DeviceAuthCallback *callback)
122{
123    uintptr_t callCtx = 0x0;
124    int32_t ret;
125
126    LOGI("starting ...");
127    if (IsStrInvalid(appId) || callback == NULL) {
128        LOGE("invalid params");
129        return HC_ERR_INVALID_PARAMS;
130    }
131    ret = CreateCallCtx(&callCtx, NULL);
132    if (ret != HC_SUCCESS) {
133        LOGE("CreateCallCtx failed, ret %d", ret);
134        return HC_ERR_IPC_INIT;
135    }
136
137    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
138    if (ret != HC_SUCCESS) {
139        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_APPID);
140        DestroyCallCtx(&callCtx, NULL);
141        return HC_ERR_IPC_BUILD_PARAM;
142    }
143    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
144    if (ret != HC_SUCCESS) {
145        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
146        DestroyCallCtx(&callCtx, NULL);
147        return HC_ERR_IPC_BUILD_PARAM;
148    }
149    SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
150    ret = DoBinderCall(callCtx, IPC_CALL_ID_REG_CB, true);
151    if (ret == HC_SUCCESS) {
152        AddIpcCliCallbackCtx(appId, 0, &g_ipcProxyCbList);
153    }
154    DestroyCallCtx(&callCtx, NULL);
155    LOGI("process done, ret %d", ret);
156    return (ret == HC_SUCCESS) ? HC_SUCCESS : HC_ERR_IPC_PROC_FAILED;
157}
158
159static int32_t IpcGmUnRegCallback(const char *appId)
160{
161    uintptr_t callCtx = 0x0;
162    int32_t ret;
163
164    LOGI("starting ...");
165    if (IsStrInvalid(appId)) {
166        LOGE("invalid params");
167        return HC_ERR_INVALID_PARAMS;
168    }
169    ret = CreateCallCtx(&callCtx, NULL);
170    if (ret != HC_SUCCESS) {
171        LOGE("CreateCallCtx failed, ret %d", ret);
172        return HC_ERR_IPC_INIT;
173    }
174
175    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
176    if (ret != HC_SUCCESS) {
177        LOGE("set request param failed, ret %d", ret);
178        DestroyCallCtx(&callCtx, NULL);
179        return HC_ERR_IPC_BUILD_PARAM;
180    }
181    ret = DoBinderCall(callCtx, IPC_CALL_ID_UNREG_CB, true);
182    if (ret == HC_SUCCESS) {
183        DelIpcCliCallbackCtx(appId, &g_ipcProxyCbList);
184    }
185    DestroyCallCtx(&callCtx, NULL);
186    LOGI("process done, ret %d", HC_SUCCESS);
187    return HC_SUCCESS;
188}
189
190static int32_t IpcGmRegDataChangeListener(const char *appId, const DataChangeListener *listener)
191{
192    uintptr_t callCtx = 0x0;
193    int32_t ret;
194
195    LOGI("starting ...");
196    if (IsStrInvalid(appId) || (listener == NULL)) {
197        LOGE("invalid params");
198        return HC_ERR_INVALID_PARAMS;
199    }
200    ret = CreateCallCtx(&callCtx, NULL);
201    if (ret != HC_SUCCESS) {
202        LOGE("CreateCallCtx failed, ret %d", ret);
203        return HC_ERR_IPC_INIT;
204    }
205
206    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
207    if (ret != HC_SUCCESS) {
208        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_APPID);
209        DestroyCallCtx(&callCtx, NULL);
210        return HC_ERR_IPC_BUILD_PARAM;
211    }
212    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_LISTERNER, (const uint8_t *)listener, sizeof(*listener));
213    if (ret != HC_SUCCESS) {
214        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_LISTERNER);
215        DestroyCallCtx(&callCtx, NULL);
216        return HC_ERR_IPC_BUILD_PARAM;
217    }
218    SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
219    ret = DoBinderCall(callCtx, IPC_CALL_ID_REG_LISTENER, true);
220    if (ret == HC_SUCCESS) {
221        AddIpcCliCallbackCtx(appId, 0, &g_ipcListenerCbList);
222    }
223    DestroyCallCtx(&callCtx, NULL);
224    LOGI("process done, ret %d", ret);
225    return (ret == HC_SUCCESS) ? HC_SUCCESS : HC_ERR_IPC_PROC_FAILED;
226}
227
228static int32_t IpcGmUnRegDataChangeListener(const char *appId)
229{
230    uintptr_t callCtx = 0x0;
231    int32_t ret;
232
233    LOGI("starting ...");
234    if (IsStrInvalid(appId)) {
235        LOGE("invalid params");
236        return HC_ERR_INVALID_PARAMS;
237    }
238    ret = CreateCallCtx(&callCtx, NULL);
239    if (ret != HC_SUCCESS) {
240        LOGE("CreateCallCtx failed, ret %d", ret);
241        return HC_ERR_IPC_INIT;
242    }
243
244    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
245    if (ret != HC_SUCCESS) {
246        LOGE("set request param failed, ret %d", ret);
247        DestroyCallCtx(&callCtx, NULL);
248        return HC_ERR_IPC_BUILD_PARAM;
249    }
250    ret = DoBinderCall(callCtx, IPC_CALL_ID_UNREG_LISTENER, true);
251    if (ret == HC_SUCCESS) {
252        DelIpcCliCallbackCtx(appId, &g_ipcListenerCbList);
253    }
254    DestroyCallCtx(&callCtx, NULL);
255    LOGI("process done");
256    return HC_SUCCESS;
257}
258
259static int32_t EncodeCreateGroupParams(uintptr_t callCtx, int32_t osAccountId, int64_t requestId,
260    const char *appId, const char *createParams)
261{
262    int32_t ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
263        sizeof(osAccountId));
264    if (ret != HC_SUCCESS) {
265        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
266        return HC_ERR_IPC_BUILD_PARAM;
267    }
268    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
269    if (ret != HC_SUCCESS) {
270        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
271        return HC_ERR_IPC_BUILD_PARAM;
272    }
273    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
274    if (ret != HC_SUCCESS) {
275        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
276        return HC_ERR_IPC_BUILD_PARAM;
277    }
278    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_CREATE_PARAMS,
279                                  (const uint8_t *)createParams, HcStrlen(createParams) + 1);
280    if (ret != HC_SUCCESS) {
281        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_CREATE_PARAMS);
282        return HC_ERR_IPC_BUILD_PARAM;
283    }
284    return HC_SUCCESS;
285}
286
287static int32_t IpcGmCreateGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams)
288{
289    uintptr_t callCtx = 0x0;
290    int32_t ret;
291    int32_t inOutLen;
292    IpcDataInfo replyCache = { 0 };
293
294    LOGI("starting ...");
295    if (IsStrInvalid(createParams) || IsStrInvalid(appId)) {
296        LOGE("invalid params");
297        return HC_ERR_INVALID_PARAMS;
298    }
299    ret = CreateCallCtx(&callCtx, NULL);
300    if (ret != HC_SUCCESS) {
301        LOGE("CreateCallCtx failed, ret %d", ret);
302        return HC_ERR_IPC_INIT;
303    }
304    ret = EncodeCreateGroupParams(callCtx, osAccountId, requestId, appId, createParams);
305    if (ret != HC_SUCCESS) {
306        DestroyCallCtx(&callCtx, NULL);
307        return ret;
308    }
309    ret = DoBinderCall(callCtx, IPC_CALL_ID_CREATE_GROUP, true);
310    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
311        LOGE("ipc call failed");
312        DestroyCallCtx(&callCtx, NULL);
313        return HC_ERR_IPC_PROC_FAILED;
314    }
315    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
316    ret = HC_ERR_IPC_UNKNOW_REPLY;
317    inOutLen = sizeof(int32_t);
318    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
319    DestroyCallCtx(&callCtx, NULL);
320    LOGI("process done, ret %d", ret);
321    return ret;
322}
323
324static int32_t EncodeDeleteGroupParams(uintptr_t callCtx, int32_t osAccountId, int64_t requestId,
325    const char *appId, const char *delParams)
326{
327    int32_t ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
328        sizeof(osAccountId));
329    if (ret != HC_SUCCESS) {
330        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
331        return HC_ERR_IPC_BUILD_PARAM;
332    }
333    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
334    if (ret != HC_SUCCESS) {
335        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
336        return HC_ERR_IPC_BUILD_PARAM;
337    }
338    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEL_PARAMS, (const uint8_t *)delParams, HcStrlen(delParams) + 1);
339    if (ret != HC_SUCCESS) {
340        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_DEL_PARAMS);
341        return HC_ERR_IPC_BUILD_PARAM;
342    }
343    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
344    if (ret != HC_SUCCESS) {
345        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
346        return HC_ERR_IPC_BUILD_PARAM;
347    }
348    return HC_SUCCESS;
349}
350
351static int32_t IpcGmDeleteGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *delParams)
352{
353    uintptr_t callCtx = 0x0;
354    int32_t ret;
355    int32_t inOutLen;
356    IpcDataInfo replyCache = { 0 };
357
358    LOGI("starting ...");
359    if (IsStrInvalid(delParams) || IsStrInvalid(appId)) {
360        LOGE("invalid params");
361        return HC_ERR_INVALID_PARAMS;
362    }
363    ret = CreateCallCtx(&callCtx, NULL);
364    if (ret != HC_SUCCESS) {
365        LOGE("CreateCallCtx failed, ret %d", ret);
366        return HC_ERR_IPC_INIT;
367    }
368    ret = EncodeDeleteGroupParams(callCtx, osAccountId, requestId, appId, delParams);
369    if (ret != HC_SUCCESS) {
370        DestroyCallCtx(&callCtx, NULL);
371        return ret;
372    }
373    ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_GROUP, true);
374    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
375        LOGE("ipc call failed");
376        DestroyCallCtx(&callCtx, NULL);
377        return HC_ERR_IPC_PROC_FAILED;
378    }
379    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
380    ret = HC_ERR_IPC_UNKNOW_REPLY;
381    inOutLen = sizeof(int32_t);
382    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
383    DestroyCallCtx(&callCtx, NULL);
384    LOGI("process done, ret %d", ret);
385    return ret;
386}
387
388static int32_t EncodeAddMemberParams(uintptr_t callCtx, int32_t osAccountId, int64_t requestId,
389    const char *appId, const char *addParams)
390{
391    int32_t ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
392        sizeof(osAccountId));
393    if (ret != HC_SUCCESS) {
394        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
395        return HC_ERR_IPC_BUILD_PARAM;
396    }
397    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
398    if (ret != HC_SUCCESS) {
399        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
400        return HC_ERR_IPC_BUILD_PARAM;
401    }
402    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
403    if (ret != HC_SUCCESS) {
404        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
405        return HC_ERR_IPC_BUILD_PARAM;
406    }
407    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_ADD_PARAMS, (const uint8_t *)addParams, HcStrlen(addParams) + 1);
408    if (ret != HC_SUCCESS) {
409        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_ADD_PARAMS);
410        return HC_ERR_IPC_BUILD_PARAM;
411    }
412    return HC_SUCCESS;
413}
414
415static int32_t IpcGmAddMemberToGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams)
416{
417    uintptr_t callCtx = 0x0;
418    int32_t ret;
419    int32_t inOutLen;
420    IpcDataInfo replyCache = { 0 };
421
422    LOGI("starting ...");
423    if (IsStrInvalid(appId) || IsStrInvalid(addParams)) {
424        LOGE("invalid params");
425        return HC_ERR_INVALID_PARAMS;
426    }
427    ret = CreateCallCtx(&callCtx, NULL);
428    if (ret != HC_SUCCESS) {
429        LOGE("CreateCallCtx failed, ret %d", ret);
430        return HC_ERR_IPC_INIT;
431    }
432    ret = EncodeAddMemberParams(callCtx, osAccountId, requestId, appId, addParams);
433    if (ret != HC_SUCCESS) {
434        DestroyCallCtx(&callCtx, NULL);
435        return ret;
436    }
437    ret = DoBinderCall(callCtx, IPC_CALL_ID_ADD_GROUP_MEMBER, true);
438    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
439        LOGE("ipc call failed");
440        DestroyCallCtx(&callCtx, NULL);
441        return HC_ERR_IPC_PROC_FAILED;
442    }
443    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
444    ret = HC_ERR_IPC_UNKNOW_REPLY;
445    inOutLen = sizeof(int32_t);
446    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
447    DestroyCallCtx(&callCtx, NULL);
448    LOGI("process done, ret %d", ret);
449    return ret;
450}
451
452static int32_t EncodeDeleteMemberParams(uintptr_t callCtx, int32_t osAccountId, int64_t requestId,
453    const char *appId, const char *delParams)
454{
455    int32_t ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
456        sizeof(osAccountId));
457    if (ret != HC_SUCCESS) {
458        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
459        return HC_ERR_IPC_BUILD_PARAM;
460    }
461    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
462    if (ret != HC_SUCCESS) {
463        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
464        return HC_ERR_IPC_BUILD_PARAM;
465    }
466    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
467    if (ret != HC_SUCCESS) {
468        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
469        return HC_ERR_IPC_BUILD_PARAM;
470    }
471    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEL_PARAMS, (const uint8_t *)delParams, HcStrlen(delParams) + 1);
472    if (ret != HC_SUCCESS) {
473        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_DEL_PARAMS);
474        return HC_ERR_IPC_BUILD_PARAM;
475    }
476    return HC_SUCCESS;
477}
478
479static int32_t IpcGmDelMemberFromGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *delParams)
480{
481    uintptr_t callCtx = 0x0;
482    int32_t ret;
483    int32_t inOutLen;
484    IpcDataInfo replyCache = { 0 };
485
486    LOGI("starting ...");
487    if (IsStrInvalid(appId) || IsStrInvalid(delParams)) {
488        LOGE("invalid params");
489        return HC_ERR_INVALID_PARAMS;
490    }
491    ret = CreateCallCtx(&callCtx, NULL);
492    if (ret != HC_SUCCESS) {
493        LOGE("CreateCallCtx failed, ret %d", ret);
494        return HC_ERR_IPC_INIT;
495    }
496    ret = EncodeDeleteMemberParams(callCtx, osAccountId, requestId, appId, delParams);
497    if (ret != HC_SUCCESS) {
498        DestroyCallCtx(&callCtx, NULL);
499        return ret;
500    }
501    ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_GROUP_MEMBER, true);
502    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
503        LOGE("ipc call failed");
504        DestroyCallCtx(&callCtx, NULL);
505        return HC_ERR_IPC_PROC_FAILED;
506    }
507    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
508    ret = HC_ERR_IPC_UNKNOW_REPLY;
509    inOutLen = sizeof(int32_t);
510    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
511    DestroyCallCtx(&callCtx, NULL);
512    LOGI("process done, ret %d", ret);
513    return ret;
514}
515
516static int32_t IpcGmAddMultiMembersToGroup(int32_t osAccountId, const char *appId, const char *addParams)
517{
518    LOGI("starting ...");
519    if (IsStrInvalid(appId) || IsStrInvalid(addParams)) {
520        LOGE("Invalid params");
521        return HC_ERR_INVALID_PARAMS;
522    }
523    uintptr_t callCtx = 0x0;
524    int32_t ret = CreateCallCtx(&callCtx, NULL);
525    if (ret != HC_SUCCESS) {
526        LOGE("CreateCallCtx failed, ret %d", ret);
527        return HC_ERR_IPC_INIT;
528    }
529    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
530        sizeof(osAccountId));
531    if (ret != HC_SUCCESS) {
532        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
533        DestroyCallCtx(&callCtx, NULL);
534        return HC_ERR_IPC_BUILD_PARAM;
535    }
536    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
537    if (ret != HC_SUCCESS) {
538        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
539        DestroyCallCtx(&callCtx, NULL);
540        return HC_ERR_IPC_BUILD_PARAM;
541    }
542    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_ADD_PARAMS, (const uint8_t *)addParams, HcStrlen(addParams) + 1);
543    if (ret != HC_SUCCESS) {
544        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_ADD_PARAMS);
545        DestroyCallCtx(&callCtx, NULL);
546        return HC_ERR_IPC_BUILD_PARAM;
547    }
548    ret = DoBinderCall(callCtx, IPC_CALL_ID_ADD_MULTI_GROUP_MEMBERS, true);
549    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
550        LOGE("ipc call failed");
551        DestroyCallCtx(&callCtx, NULL);
552        return HC_ERR_IPC_PROC_FAILED;
553    }
554    IpcDataInfo replyCache = { 0 };
555    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
556    ret = HC_ERR_IPC_UNKNOW_REPLY;
557    int32_t inOutLen = sizeof(int32_t);
558    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
559    DestroyCallCtx(&callCtx, NULL);
560    LOGI("process done, ret %d", ret);
561    return ret;
562}
563
564static int32_t IpcGmDelMultiMembersFromGroup(int32_t osAccountId, const char *appId, const char *delParams)
565{
566    LOGI("starting ...");
567    if (IsStrInvalid(appId) || IsStrInvalid(delParams)) {
568        LOGE("Invalid params");
569        return HC_ERR_INVALID_PARAMS;
570    }
571    uintptr_t callCtx = 0x0;
572    int32_t ret = CreateCallCtx(&callCtx, NULL);
573    if (ret != HC_SUCCESS) {
574        LOGE("CreateCallCtx failed, ret %d", ret);
575        return HC_ERR_IPC_INIT;
576    }
577    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
578        sizeof(osAccountId));
579    if (ret != HC_SUCCESS) {
580        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
581        DestroyCallCtx(&callCtx, NULL);
582        return HC_ERR_IPC_BUILD_PARAM;
583    }
584    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
585    if (ret != HC_SUCCESS) {
586        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
587        DestroyCallCtx(&callCtx, NULL);
588        return HC_ERR_IPC_BUILD_PARAM;
589    }
590    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEL_PARAMS, (const uint8_t *)delParams, HcStrlen(delParams) + 1);
591    if (ret != HC_SUCCESS) {
592        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_DEL_PARAMS);
593        DestroyCallCtx(&callCtx, NULL);
594        return HC_ERR_IPC_BUILD_PARAM;
595    }
596    ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_MULTI_GROUP_MEMBERS, true);
597    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
598        LOGE("ipc call failed");
599        DestroyCallCtx(&callCtx, NULL);
600        return HC_ERR_IPC_PROC_FAILED;
601    }
602    IpcDataInfo replyCache = { 0 };
603    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
604    ret = HC_ERR_IPC_UNKNOW_REPLY;
605    int32_t inOutLen = sizeof(int32_t);
606    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
607    DestroyCallCtx(&callCtx, NULL);
608    LOGI("process done, ret %d", ret);
609    return ret;
610}
611
612static int32_t IpcGmProcessData(int64_t requestId, const uint8_t *data, uint32_t dataLen)
613{
614    uintptr_t callCtx = 0x0;
615    int32_t ret;
616    int32_t inOutLen;
617    IpcDataInfo replyCache = { 0 };
618
619    LOGI("starting ...");
620    if (!IS_COMM_DATA_VALID(data, dataLen)) {
621        LOGE("invalid params");
622        return HC_ERR_INVALID_PARAMS;
623    }
624    ret = CreateCallCtx(&callCtx, NULL);
625    if (ret != HC_SUCCESS) {
626        LOGE("CreateCallCtx failed, ret %d", ret);
627        return HC_ERR_IPC_INIT;
628    }
629    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
630    if (ret != HC_SUCCESS) {
631        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
632        DestroyCallCtx(&callCtx, NULL);
633        return HC_ERR_IPC_BUILD_PARAM;
634    }
635    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
636    if (ret != HC_SUCCESS) {
637        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_COMM_DATA);
638        DestroyCallCtx(&callCtx, NULL);
639        return HC_ERR_IPC_BUILD_PARAM;
640    }
641    ret = DoBinderCall(callCtx, IPC_CALL_ID_GM_PROC_DATA, true);
642    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
643        LOGE("ipc call failed");
644        DestroyCallCtx(&callCtx, NULL);
645        return HC_ERR_IPC_PROC_FAILED;
646    }
647    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
648    ret = HC_ERR_IPC_UNKNOW_REPLY;
649    inOutLen = sizeof(int32_t);
650    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
651    DestroyCallCtx(&callCtx, NULL);
652    LOGI("process done, ret %d", ret);
653    return ret;
654}
655
656static int32_t IpcGmGetRegisterInfo(const char *reqJsonStr, char **registerInfo)
657{
658    uintptr_t callCtx = 0x0;
659    int32_t inOutLen;
660    IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
661    char *outInfo = NULL;
662
663    if (IsStrInvalid(reqJsonStr) || (registerInfo == NULL)) {
664        LOGE("Invalid params.");
665        return HC_ERR_INVALID_PARAMS;
666    }
667    int32_t ret = CreateCallCtx(&callCtx, NULL);
668    if (ret != HC_SUCCESS) {
669        LOGE("CreateCallCtx failed, ret %d", ret);
670        return HC_ERR_IPC_INIT;
671    }
672    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQ_JSON, (const uint8_t *)reqJsonStr, HcStrlen(reqJsonStr) + 1);
673    if (ret != HC_SUCCESS) {
674        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQ_JSON);
675        DestroyCallCtx(&callCtx, NULL);
676        return HC_ERR_IPC_BUILD_PARAM;
677    }
678    ret = DoBinderCall(callCtx, IPC_CALL_ID_APPLY_REG_INFO, true);
679    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
680        DestroyCallCtx(&callCtx, NULL);
681        return HC_ERR_IPC_PROC_FAILED;
682    }
683    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
684    ret = HC_ERR_IPC_UNKNOW_REPLY;
685    inOutLen = sizeof(int32_t);
686    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
687    if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) {
688        DestroyCallCtx(&callCtx, NULL);
689        return HC_ERR_IPC_BAD_PARAM;
690    }
691    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
692    if ((ret < IPC_RESULT_NUM_1) || (inOutLen != sizeof(int32_t))) {
693        LOGE("done, ret %d", HC_ERR_IPC_OUT_DATA_NUM);
694        DestroyCallCtx(&callCtx, NULL);
695        return HC_ERR_IPC_OUT_DATA_NUM;
696    }
697    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_REG_INFO, (uint8_t *)&outInfo, NULL);
698    if ((outInfo == NULL) || (HcStrlen(outInfo) == 0)) {
699        LOGE("done, ret %d", HC_ERR_IPC_OUT_DATA);
700        DestroyCallCtx(&callCtx, NULL);
701        return HC_ERR_IPC_OUT_DATA;
702    }
703    *registerInfo = strdup(outInfo);
704    DestroyCallCtx(&callCtx, NULL);
705    return (*registerInfo != NULL) ? HC_SUCCESS : HC_ERR_NULL_PTR;
706}
707
708static int32_t IpcGmCheckAccessToGroup(int32_t osAccountId, const char *appId, const char *groupId)
709{
710    uintptr_t callCtx = 0x0;
711    int32_t ret;
712    int32_t inOutLen;
713    IpcDataInfo replyCache = { 0 };
714
715    LOGI("starting ...");
716    if (IsStrInvalid(appId) || IsStrInvalid(groupId)) {
717        LOGE("Invalid params.");
718        return HC_ERR_INVALID_PARAMS;
719    }
720    ret = CreateCallCtx(&callCtx, NULL);
721    if (ret != HC_SUCCESS) {
722        LOGE("CreateCallCtx failed, ret %d", ret);
723        return HC_ERR_IPC_INIT;
724    }
725    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
726        sizeof(osAccountId));
727    if (ret != HC_SUCCESS) {
728        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
729        DestroyCallCtx(&callCtx, NULL);
730        return HC_ERR_IPC_BUILD_PARAM;
731    }
732    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
733    if (ret != HC_SUCCESS) {
734        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
735        DestroyCallCtx(&callCtx, NULL);
736        return HC_ERR_IPC_BUILD_PARAM;
737    }
738    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, HcStrlen(groupId) + 1);
739    if (ret != HC_SUCCESS) {
740        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
741        DestroyCallCtx(&callCtx, NULL);
742        return HC_ERR_IPC_BUILD_PARAM;
743    }
744    ret = DoBinderCall(callCtx, IPC_CALL_ID_CHECK_ACCESS_TO_GROUP, true);
745    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
746        LOGE("ipc call failed");
747        DestroyCallCtx(&callCtx, NULL);
748        return HC_ERR_IPC_PROC_FAILED;
749    }
750    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
751    ret = HC_ERR_IPC_UNKNOW_REPLY;
752    inOutLen = sizeof(int32_t);
753    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
754    LOGI("process done, ret %d", ret);
755    DestroyCallCtx(&callCtx, NULL);
756    return ret;
757}
758
759static int32_t ParseReturnResult(const IpcDataInfo *replies, int32_t cacheNum, char **returnData, uint32_t *returnNum)
760{
761    int32_t ret;
762    int32_t inOutLen;
763
764    inOutLen = sizeof(int32_t);
765    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
766    if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
767        return HC_ERR_IPC_OUT_DATA_NUM;
768    }
769    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_RETURN_DATA, (uint8_t *)returnData, NULL);
770    if (*returnData == NULL) {
771        return HC_ERR_IPC_OUT_DATA;
772    }
773    *returnData = strdup(*returnData);
774    if (*returnData == NULL) {
775        return HC_ERR_ALLOC_MEMORY;
776    }
777    inOutLen = sizeof(int32_t);
778    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)returnNum, &inOutLen);
779    return HC_SUCCESS;
780}
781
782static int32_t IpcGmGetPkInfoList(int32_t osAccountId, const char *appId, const char *queryParams,
783                                  char **returnInfoList, uint32_t *returnInfoNum)
784{
785    uintptr_t callCtx = 0x0;
786    int32_t ret;
787    int32_t inOutLen;
788    IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
789
790    if (IsStrInvalid(appId) || IsStrInvalid(queryParams) || (returnInfoList == NULL) || (returnInfoNum == NULL)) {
791        LOGE("Invalid params.");
792        return HC_ERR_INVALID_PARAMS;
793    }
794    ret = CreateCallCtx(&callCtx, NULL);
795    if (ret != HC_SUCCESS) {
796        return HC_ERR_IPC_INIT;
797    }
798    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID,
799        (const uint8_t *)&osAccountId, sizeof(osAccountId));
800    if (ret != HC_SUCCESS) {
801        DestroyCallCtx(&callCtx, NULL);
802        return HC_ERR_IPC_BUILD_PARAM;
803    }
804    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
805    if (ret != HC_SUCCESS) {
806        DestroyCallCtx(&callCtx, NULL);
807        return HC_ERR_IPC_BUILD_PARAM;
808    }
809    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_QUERY_PARAMS,
810        (const uint8_t *)queryParams, HcStrlen(queryParams) + 1);
811    if (ret != HC_SUCCESS) {
812        DestroyCallCtx(&callCtx, NULL);
813        return HC_ERR_IPC_BUILD_PARAM;
814    }
815    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_PK_INFO_LIST, true);
816    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
817        DestroyCallCtx(&callCtx, NULL);
818        return HC_ERR_IPC_PROC_FAILED;
819    }
820    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
821    ret = HC_ERR_IPC_UNKNOW_REPLY;
822    inOutLen = sizeof(int32_t);
823    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
824    if (ret != HC_SUCCESS) {
825        DestroyCallCtx(&callCtx, NULL);
826        return ret;
827    }
828    ret = ParseReturnResult(replyCache, REPLAY_CACHE_NUM(replyCache), returnInfoList, returnInfoNum);
829    DestroyCallCtx(&callCtx, NULL);
830    return ret;
831}
832
833static int32_t GroupInfoIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outGroupInfo)
834{
835    int32_t inOutLen;
836    int32_t ret;
837
838    inOutLen = sizeof(int32_t);
839    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
840    if ((ret < IPC_RESULT_NUM_1) || (inOutLen != sizeof(int32_t))) {
841        return HC_ERR_IPC_OUT_DATA_NUM;
842    }
843    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupInfo, NULL);
844    if (*outGroupInfo == NULL) {
845        return HC_ERR_IPC_OUT_DATA;
846    }
847    *outGroupInfo = strdup(*outGroupInfo);
848    if (*outGroupInfo == NULL) {
849        return HC_ERR_ALLOC_MEMORY;
850    }
851    return HC_SUCCESS;
852}
853
854static int32_t IpcGmGetGroupInfoById(int32_t osAccountId, const char *appId, const char *groupId, char **outGroupInfo)
855{
856    uintptr_t callCtx = 0x0;
857    int32_t inOutLen;
858    IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
859
860    if (IsStrInvalid(groupId) || IsStrInvalid(appId) || (outGroupInfo == NULL)) {
861        LOGE("Invalid params.");
862        return HC_ERR_INVALID_PARAMS;
863    }
864    int32_t ret = CreateCallCtx(&callCtx, NULL);
865    if (ret != HC_SUCCESS) {
866        LOGE("CreateCallCtx failed, ret %d", ret);
867        return HC_ERR_IPC_INIT;
868    }
869    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
870        sizeof(osAccountId));
871    if (ret != HC_SUCCESS) {
872        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
873        DestroyCallCtx(&callCtx, NULL);
874        return HC_ERR_IPC_BUILD_PARAM;
875    }
876    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
877    if (ret != HC_SUCCESS) {
878        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
879        DestroyCallCtx(&callCtx, NULL);
880        return HC_ERR_IPC_BUILD_PARAM;
881    }
882    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, HcStrlen(groupId) + 1);
883    if (ret != HC_SUCCESS) {
884        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
885        DestroyCallCtx(&callCtx, NULL);
886        return HC_ERR_IPC_BUILD_PARAM;
887    }
888    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_GROUP_INFO, true);
889    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
890        DestroyCallCtx(&callCtx, NULL);
891        return HC_ERR_IPC_PROC_FAILED;
892    }
893    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
894    ret = HC_ERR_IPC_UNKNOW_REPLY;
895    inOutLen = sizeof(int32_t);
896    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
897    if (ret != HC_SUCCESS) {
898        DestroyCallCtx(&callCtx, NULL);
899        return ret;
900    }
901    ret = GroupInfoIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupInfo);
902    DestroyCallCtx(&callCtx, NULL);
903    return ret;
904}
905
906static int32_t SearchGroupsIpcResult(const IpcDataInfo *replies,
907    int32_t cacheNum, char **outGroupVec, uint32_t *groupNum)
908{
909    int32_t ret;
910    int32_t inOutLen;
911
912    inOutLen = sizeof(int32_t);
913    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
914    if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
915        return HC_ERR_IPC_OUT_DATA_NUM;
916    }
917    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupVec, NULL);
918    if (*outGroupVec == NULL) {
919        return HC_ERR_IPC_OUT_DATA;
920    }
921    *outGroupVec = strdup(*outGroupVec);
922    if (*outGroupVec == NULL) {
923        return HC_ERR_ALLOC_MEMORY;
924    }
925    inOutLen = sizeof(int32_t);
926    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)groupNum, &inOutLen);
927    return HC_SUCCESS;
928}
929
930static int32_t IpcGmGetGroupInfo(int32_t osAccountId, const char *appId, const char *queryParams,
931    char **outGroupVec, uint32_t *groupNum)
932{
933    uintptr_t callCtx = 0x0;
934    IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
935
936    if (IsStrInvalid(queryParams) || IsStrInvalid(appId) || (outGroupVec == NULL) || (groupNum == NULL)) {
937        LOGE("Invalid params.");
938        return HC_ERR_INVALID_PARAMS;
939    }
940    int32_t ret = CreateCallCtx(&callCtx, NULL);
941    if (ret != HC_SUCCESS) {
942        LOGE("CreateCallCtx failed, ret %d", ret);
943        return HC_ERR_IPC_INIT;
944    }
945    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
946        sizeof(osAccountId));
947    if (ret != HC_SUCCESS) {
948        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
949        DestroyCallCtx(&callCtx, NULL);
950        return HC_ERR_IPC_BUILD_PARAM;
951    }
952    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
953    if (ret != HC_SUCCESS) {
954        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
955        DestroyCallCtx(&callCtx, NULL);
956        return HC_ERR_IPC_BUILD_PARAM;
957    }
958    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_QUERY_PARAMS,
959        (const uint8_t *)queryParams, HcStrlen(queryParams) + 1);
960    if (ret != HC_SUCCESS) {
961        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_QUERY_PARAMS);
962        DestroyCallCtx(&callCtx, NULL);
963        return HC_ERR_IPC_BUILD_PARAM;
964    }
965    ret = DoBinderCall(callCtx, IPC_CALL_ID_SEARCH_GROUPS, true);
966    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
967        DestroyCallCtx(&callCtx, NULL);
968        return HC_ERR_IPC_PROC_FAILED;
969    }
970    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
971    ret = HC_ERR_IPC_UNKNOW_REPLY;
972    int32_t inOutLen = sizeof(int32_t);
973    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
974    if (ret != HC_SUCCESS) {
975        DestroyCallCtx(&callCtx, NULL);
976        return ret;
977    }
978    ret = SearchGroupsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupVec, groupNum);
979    DestroyCallCtx(&callCtx, NULL);
980    return ret;
981}
982
983static int32_t JoinedGroupsIpcResult(const IpcDataInfo *replies,
984    int32_t cacheNum, char **outGroupVec, uint32_t *groupNum)
985{
986    int32_t ret;
987    int32_t inOutLen;
988
989    inOutLen = sizeof(int32_t);
990    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
991    if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
992        return HC_ERR_IPC_OUT_DATA_NUM;
993    }
994    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupVec, NULL);
995    if (*outGroupVec == NULL) {
996        return HC_ERR_IPC_OUT_DATA;
997    }
998    *outGroupVec = strdup(*outGroupVec);
999    if (*outGroupVec == NULL) {
1000        return HC_ERR_ALLOC_MEMORY;
1001    }
1002    inOutLen = sizeof(int32_t);
1003    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)groupNum, &inOutLen);
1004    return HC_SUCCESS;
1005}
1006
1007static int32_t IpcGmGetJoinedGroups(int32_t osAccountId, const char *appId, int32_t groupType,
1008    char **outGroupVec, uint32_t *groupNum)
1009{
1010    uintptr_t callCtx = 0x0;
1011    int32_t inOutLen;
1012    IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
1013
1014    if (IsStrInvalid(appId) || (outGroupVec == NULL) || (groupNum == NULL)) {
1015        LOGE("Invalid params.");
1016        return HC_ERR_INVALID_PARAMS;
1017    }
1018    int32_t ret = CreateCallCtx(&callCtx, NULL);
1019    if (ret != HC_SUCCESS) {
1020        LOGE("CreateCallCtx failed, ret %d", ret);
1021        return HC_ERR_IPC_INIT;
1022    }
1023    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1024        sizeof(osAccountId));
1025    if (ret != HC_SUCCESS) {
1026        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1027        DestroyCallCtx(&callCtx, NULL);
1028        return HC_ERR_IPC_BUILD_PARAM;
1029    }
1030    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1031    if (ret != HC_SUCCESS) {
1032        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1033        DestroyCallCtx(&callCtx, NULL);
1034        return HC_ERR_IPC_BUILD_PARAM;
1035    }
1036    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUP_TYPE, (const uint8_t *)&groupType, sizeof(groupType));
1037    if (ret != HC_SUCCESS) {
1038        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUP_TYPE);
1039        DestroyCallCtx(&callCtx, NULL);
1040        return HC_ERR_IPC_BUILD_PARAM;
1041    }
1042    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_JOINED_GROUPS, true);
1043    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1044        DestroyCallCtx(&callCtx, NULL);
1045        return HC_ERR_IPC_PROC_FAILED;
1046    }
1047    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1048    ret = HC_ERR_IPC_UNKNOW_REPLY;
1049    inOutLen = sizeof(int32_t);
1050    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1051    if (ret != HC_SUCCESS) {
1052        DestroyCallCtx(&callCtx, NULL);
1053        return ret;
1054    }
1055    ret = JoinedGroupsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupVec, groupNum);
1056    DestroyCallCtx(&callCtx, NULL);
1057    return ret;
1058}
1059
1060static int32_t RelatedGroupsIpcResult(const IpcDataInfo *replies,
1061    int32_t cacheNum, char **outGroupVec, uint32_t *groupNum)
1062{
1063    int32_t ret;
1064    int32_t inOutLen;
1065
1066    inOutLen = sizeof(int32_t);
1067    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
1068    if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
1069        return HC_ERR_IPC_OUT_DATA_NUM;
1070    }
1071    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupVec, NULL);
1072    if (*outGroupVec == NULL) {
1073        return HC_ERR_IPC_OUT_DATA;
1074    }
1075    *outGroupVec = strdup(*outGroupVec);
1076    if (*outGroupVec == NULL) {
1077        return HC_ERR_ALLOC_MEMORY;
1078    }
1079    inOutLen = sizeof(int32_t);
1080    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)groupNum, &inOutLen);
1081    return HC_SUCCESS;
1082}
1083
1084static int32_t IpcGmGetRelatedGroups(int32_t osAccountId, const char *appId, const char *peerUdid,
1085    char **outGroupVec, uint32_t *groupNum)
1086{
1087    uintptr_t callCtx = 0x0;
1088    int32_t ret;
1089    int32_t inOutLen;
1090    IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
1091
1092    if (IsStrInvalid(appId) || IsStrInvalid(peerUdid) || (outGroupVec == NULL) || (groupNum == NULL)) {
1093        LOGE("Invalid params.");
1094        return HC_ERR_INVALID_PARAMS;
1095    }
1096    ret = CreateCallCtx(&callCtx, NULL);
1097    if (ret != HC_SUCCESS) {
1098        LOGE("CreateCallCtx failed, ret %d", ret);
1099        return HC_ERR_IPC_INIT;
1100    }
1101    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, sizeof(int32_t));
1102    if (ret != HC_SUCCESS) {
1103        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1104        DestroyCallCtx(&callCtx, NULL);
1105        return HC_ERR_IPC_BUILD_PARAM;
1106    }
1107    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1108    if (ret != HC_SUCCESS) {
1109        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1110        DestroyCallCtx(&callCtx, NULL);
1111        return HC_ERR_IPC_BUILD_PARAM;
1112    }
1113    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)peerUdid, HcStrlen(peerUdid) + 1);
1114    if (ret != HC_SUCCESS) {
1115        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
1116        DestroyCallCtx(&callCtx, NULL);
1117        return HC_ERR_IPC_BUILD_PARAM;
1118    }
1119    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_RELATED_GROUPS, true);
1120    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1121        DestroyCallCtx(&callCtx, NULL);
1122        return HC_ERR_IPC_PROC_FAILED;
1123    }
1124    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1125    ret = HC_ERR_IPC_UNKNOW_REPLY;
1126    inOutLen = sizeof(int32_t);
1127    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1128    if (ret != HC_SUCCESS) {
1129        LOGE("Service return exception, ret: %d", ret);
1130        DestroyCallCtx(&callCtx, NULL);
1131        return ret;
1132    }
1133    ret = RelatedGroupsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupVec, groupNum);
1134    DestroyCallCtx(&callCtx, NULL);
1135    return ret;
1136}
1137
1138static int32_t DevInfoByIdIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outDevInfo)
1139{
1140    int32_t ret;
1141    int32_t inOutLen;
1142
1143    inOutLen = sizeof(int32_t);
1144    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
1145    if ((ret < IPC_RESULT_NUM_1) || (inOutLen != sizeof(int32_t))) {
1146        return HC_ERR_IPC_OUT_DATA_NUM;
1147    }
1148    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DEVICE_INFO, (uint8_t *)outDevInfo, NULL);
1149    if (*outDevInfo == NULL) {
1150        return HC_ERR_IPC_OUT_DATA;
1151    }
1152    *outDevInfo = strdup(*outDevInfo);
1153    if (*outDevInfo == NULL) {
1154        return HC_ERR_ALLOC_MEMORY;
1155    }
1156    return HC_SUCCESS;
1157}
1158
1159static int32_t FormParamsForGettingDeviceInfo(int32_t osAccountId, const char *appId,
1160    const char *peerUdid, const char *groupId, uintptr_t callCtx)
1161{
1162    int32_t ret;
1163    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1164        sizeof(osAccountId));
1165    if (ret != HC_SUCCESS) {
1166        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1167        DestroyCallCtx(&callCtx, NULL);
1168        return HC_ERR_IPC_BUILD_PARAM;
1169    }
1170    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1171    if (ret != HC_SUCCESS) {
1172        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1173        return HC_ERR_IPC_BUILD_PARAM;
1174    }
1175    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)peerUdid, HcStrlen(peerUdid) + 1);
1176    if (ret != HC_SUCCESS) {
1177        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
1178        return HC_ERR_IPC_BUILD_PARAM;
1179    }
1180    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, HcStrlen(groupId) + 1);
1181    if (ret != HC_SUCCESS) {
1182        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
1183        return HC_ERR_IPC_BUILD_PARAM;
1184    }
1185    return HC_SUCCESS;
1186}
1187
1188static int32_t IpcGmGetDeviceInfoById(int32_t osAccountId, const char *appId, const char *peerUdid, const char *groupId,
1189    char **outDevInfo)
1190{
1191    uintptr_t callCtx = 0x0;
1192    int32_t ret;
1193    int32_t inOutLen;
1194    IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
1195
1196    LOGI("starting ...");
1197    if (IsStrInvalid(appId) || IsStrInvalid(peerUdid) || IsStrInvalid(groupId) || (outDevInfo == NULL)) {
1198        LOGE("Invalid params.");
1199        return HC_ERR_INVALID_PARAMS;
1200    }
1201    ret = CreateCallCtx(&callCtx, NULL);
1202    if (ret != HC_SUCCESS) {
1203        LOGE("CreateCallCtx failed, ret %d", ret);
1204        return HC_ERR_IPC_INIT;
1205    }
1206    ret = FormParamsForGettingDeviceInfo(osAccountId, appId, peerUdid, groupId, callCtx);
1207    if (ret != HC_SUCCESS) {
1208        DestroyCallCtx(&callCtx, NULL);
1209        return ret;
1210    }
1211    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_DEV_INFO_BY_ID, true);
1212    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1213        LOGE("ipc call failed");
1214        DestroyCallCtx(&callCtx, NULL);
1215        return HC_ERR_IPC_PROC_FAILED;
1216    }
1217    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1218    ret = HC_ERR_IPC_UNKNOW_REPLY;
1219    inOutLen = sizeof(int32_t);
1220    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1221    if (ret != HC_SUCCESS) {
1222        LOGE("Service return exception, ret: %d", ret);
1223        DestroyCallCtx(&callCtx, NULL);
1224        return ret;
1225    }
1226    ret = DevInfoByIdIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outDevInfo);
1227    LOGI("proc result done, ret %d", ret);
1228    DestroyCallCtx(&callCtx, NULL);
1229    return ret;
1230}
1231
1232static int32_t TrustedDevIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outDevInfoVec, uint32_t *devNum)
1233{
1234    int32_t ret;
1235    int32_t inOutLen;
1236
1237    inOutLen = sizeof(int32_t);
1238    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
1239    if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
1240        return HC_ERR_IPC_OUT_DATA_NUM;
1241    }
1242    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DEVICE_INFO, (uint8_t *)outDevInfoVec, NULL);
1243    if (*outDevInfoVec == NULL) {
1244        return HC_ERR_IPC_OUT_DATA;
1245    }
1246    *outDevInfoVec = strdup(*outDevInfoVec);
1247    if (*outDevInfoVec == NULL) {
1248        return HC_ERR_ALLOC_MEMORY;
1249    }
1250    inOutLen = sizeof(int32_t);
1251    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)devNum, &inOutLen);
1252    return HC_SUCCESS;
1253}
1254
1255static int32_t IpcGmGetTrustedDevices(int32_t osAccountId, const char *appId,
1256    const char *groupId, char **outDevInfoVec, uint32_t *deviceNum)
1257{
1258    uintptr_t callCtx = 0x0;
1259    int32_t inOutLen;
1260    IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
1261
1262    if (IsStrInvalid(appId) || IsStrInvalid(groupId) || (outDevInfoVec == NULL) || (deviceNum == NULL)) {
1263        LOGE("Invalid params.");
1264        return HC_ERR_INVALID_PARAMS;
1265    }
1266    int32_t ret = CreateCallCtx(&callCtx, NULL);
1267    if (ret != HC_SUCCESS) {
1268        LOGE("CreateCallCtx failed, ret %d", ret);
1269        return HC_ERR_IPC_INIT;
1270    }
1271    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1272        sizeof(osAccountId));
1273    if (ret != HC_SUCCESS) {
1274        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1275        DestroyCallCtx(&callCtx, NULL);
1276        return HC_ERR_IPC_BUILD_PARAM;
1277    }
1278    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1279    if (ret != HC_SUCCESS) {
1280        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1281        DestroyCallCtx(&callCtx, NULL);
1282        return HC_ERR_IPC_BUILD_PARAM;
1283    }
1284    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, HcStrlen(groupId) + 1);
1285    if (ret != HC_SUCCESS) {
1286        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
1287        DestroyCallCtx(&callCtx, NULL);
1288        return HC_ERR_IPC_BUILD_PARAM;
1289    }
1290    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_TRUST_DEVICES, true);
1291    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1292        DestroyCallCtx(&callCtx, NULL);
1293        return HC_ERR_IPC_PROC_FAILED;
1294    }
1295    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1296    ret = HC_ERR_IPC_UNKNOW_REPLY;
1297    inOutLen = sizeof(int32_t);
1298    GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1299    if (ret != HC_SUCCESS) {
1300        DestroyCallCtx(&callCtx, NULL);
1301        return ret;
1302    }
1303    ret = TrustedDevIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outDevInfoVec, deviceNum);
1304    DestroyCallCtx(&callCtx, NULL);
1305    return ret;
1306}
1307
1308static bool IpcGmIsDeviceInGroup(int32_t osAccountId, const char *appId, const char *groupId, const char *udid)
1309{
1310    uintptr_t callCtx = 0x0;
1311    int32_t inOutLen;
1312    IpcDataInfo replyCache = { 0 };
1313
1314    if (IsStrInvalid(appId) || IsStrInvalid(groupId) || IsStrInvalid(udid)) {
1315        LOGE("Invalid params.");
1316        return false;
1317    }
1318    int32_t ret = CreateCallCtx(&callCtx, NULL);
1319    if (ret != HC_SUCCESS) {
1320        LOGE("CreateCallCtx failed, ret %d", ret);
1321        return false;
1322    }
1323    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1324        sizeof(osAccountId));
1325    if (ret != HC_SUCCESS) {
1326        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1327        DestroyCallCtx(&callCtx, NULL);
1328        return false;
1329    }
1330    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1331    if (ret != HC_SUCCESS) {
1332        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1333        DestroyCallCtx(&callCtx, NULL);
1334        return false;
1335    }
1336    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, HcStrlen(groupId) + 1);
1337    if (ret != HC_SUCCESS) {
1338        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
1339        DestroyCallCtx(&callCtx, NULL);
1340        return false;
1341    }
1342    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)udid, HcStrlen(udid) + 1);
1343    if (ret != HC_SUCCESS) {
1344        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
1345        DestroyCallCtx(&callCtx, NULL);
1346        return false;
1347    }
1348    ret = DoBinderCall(callCtx, IPC_CALL_ID_IS_DEV_IN_GROUP, true);
1349    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1350        DestroyCallCtx(&callCtx, NULL);
1351        return false;
1352    }
1353    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1354    ret = HC_ERR_IPC_UNKNOW_REPLY;
1355    inOutLen = sizeof(int32_t);
1356    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1357    DestroyCallCtx(&callCtx, NULL);
1358    return (ret == HC_SUCCESS) ? true : false;
1359}
1360
1361static void IpcGmDestroyInfo(char **returnInfo)
1362{
1363    if ((returnInfo == NULL) || (*returnInfo == NULL)) {
1364        return;
1365    }
1366    FreeJsonString(*returnInfo);
1367    *returnInfo = NULL;
1368}
1369
1370static void IpcGmCancelRequest(int64_t requestId, const char *appId)
1371{
1372    uintptr_t callCtx = 0x0;
1373    int32_t ret;
1374
1375    LOGI("starting ...");
1376    if (IsStrInvalid(appId)) {
1377        LOGE("Invalid params.");
1378        return;
1379    }
1380    ret = CreateCallCtx(&callCtx, NULL);
1381    if (ret != HC_SUCCESS) {
1382        LOGE("CreateCallCtx failed, ret %d", ret);
1383        return;
1384    }
1385    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&requestId), sizeof(requestId));
1386    if (ret != HC_SUCCESS) {
1387        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1388        DestroyCallCtx(&callCtx, NULL);
1389        return;
1390    }
1391    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1392    if (ret != HC_SUCCESS) {
1393        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1394        DestroyCallCtx(&callCtx, NULL);
1395        return;
1396    }
1397    ret = DoBinderCall(callCtx, IPC_CALL_GM_CANCEL_REQUEST, true);
1398    DestroyCallCtx(&callCtx, NULL);
1399    if (ret != HC_SUCCESS) {
1400        LOGE("ipc call failed");
1401    } else {
1402        LOGI("process done, ret %d", ret);
1403    }
1404}
1405
1406static void InitIpcGmMethods(DeviceGroupManager *gmMethodObj)
1407{
1408    gmMethodObj->regCallback = IpcGmRegCallback;
1409    gmMethodObj->unRegCallback = IpcGmUnRegCallback;
1410    gmMethodObj->regDataChangeListener = IpcGmRegDataChangeListener;
1411    gmMethodObj->unRegDataChangeListener = IpcGmUnRegDataChangeListener;
1412    gmMethodObj->createGroup = IpcGmCreateGroup;
1413    gmMethodObj->deleteGroup = IpcGmDeleteGroup;
1414    gmMethodObj->addMemberToGroup = IpcGmAddMemberToGroup;
1415    gmMethodObj->deleteMemberFromGroup = IpcGmDelMemberFromGroup;
1416    gmMethodObj->addMultiMembersToGroup = IpcGmAddMultiMembersToGroup;
1417    gmMethodObj->delMultiMembersFromGroup = IpcGmDelMultiMembersFromGroup;
1418    gmMethodObj->processData = IpcGmProcessData;
1419    gmMethodObj->getRegisterInfo = IpcGmGetRegisterInfo;
1420    gmMethodObj->checkAccessToGroup = IpcGmCheckAccessToGroup;
1421    gmMethodObj->getPkInfoList = IpcGmGetPkInfoList;
1422    gmMethodObj->getGroupInfoById = IpcGmGetGroupInfoById;
1423    gmMethodObj->getGroupInfo = IpcGmGetGroupInfo;
1424    gmMethodObj->getJoinedGroups = IpcGmGetJoinedGroups;
1425    gmMethodObj->getRelatedGroups = IpcGmGetRelatedGroups;
1426    gmMethodObj->getDeviceInfoById = IpcGmGetDeviceInfoById;
1427    gmMethodObj->getTrustedDevices = IpcGmGetTrustedDevices;
1428    gmMethodObj->isDeviceInGroup = IpcGmIsDeviceInGroup;
1429    gmMethodObj->cancelRequest = IpcGmCancelRequest;
1430    gmMethodObj->destroyInfo = IpcGmDestroyInfo;
1431    return;
1432}
1433
1434static int32_t EncodeProcessDataParams(uintptr_t callCtx, int64_t authReqId,
1435    const uint8_t *data, uint32_t dataLen, const DeviceAuthCallback *callback)
1436{
1437    int32_t ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&authReqId), sizeof(authReqId));
1438    if (ret != HC_SUCCESS) {
1439        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1440        return HC_ERR_IPC_BUILD_PARAM;
1441    }
1442    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, (const uint8_t *)data, dataLen);
1443    if (ret != HC_SUCCESS) {
1444        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_COMM_DATA);
1445        return HC_ERR_IPC_BUILD_PARAM;
1446    }
1447    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
1448    if (ret != HC_SUCCESS) {
1449        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
1450        return HC_ERR_IPC_BUILD_PARAM;
1451    }
1452    SetCbCtxToDataCtx(callCtx, 0x0);
1453    return HC_SUCCESS;
1454}
1455
1456static int32_t IpcGaProcessData(int64_t authReqId,
1457    const uint8_t *data, uint32_t dataLen, const DeviceAuthCallback *callback)
1458{
1459    uintptr_t callCtx = 0x0;
1460    int32_t ret;
1461    int32_t inOutLen;
1462    IpcDataInfo replyCache = { 0 };
1463
1464    LOGI("starting ...");
1465    if (!IS_COMM_DATA_VALID(data, dataLen) || (callback == NULL)) {
1466        LOGE("invalid params");
1467        return HC_ERR_INVALID_PARAMS;
1468    }
1469    ret = CreateCallCtx(&callCtx, NULL);
1470    if (ret != HC_SUCCESS) {
1471        LOGE("CreateCallCtx failed, ret %d", ret);
1472        return HC_ERR_IPC_INIT;
1473    }
1474    ret = EncodeProcessDataParams(callCtx, authReqId, data, dataLen, callback);
1475    if (ret != HC_SUCCESS) {
1476        DestroyCallCtx(&callCtx, NULL);
1477        return ret;
1478    }
1479    ret = DoBinderCall(callCtx, IPC_CALL_ID_GA_PROC_DATA, true);
1480    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1481        LOGE("ipc call failed");
1482        DestroyCallCtx(&callCtx, NULL);
1483        return HC_ERR_IPC_PROC_FAILED;
1484    }
1485    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1486    ret = HC_ERR_IPC_UNKNOW_REPLY;
1487    inOutLen = sizeof(int32_t);
1488    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1489    LOGI("process done, ret %d", ret);
1490    DestroyCallCtx(&callCtx, NULL);
1491    return ret;
1492}
1493
1494static int32_t EncodeAuthDeviceParams(uintptr_t callCtx, int32_t osAccountId, int64_t authReqId,
1495    const char *authParams, const DeviceAuthCallback *callback)
1496{
1497    int32_t ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1498        sizeof(osAccountId));
1499    if (ret != HC_SUCCESS) {
1500        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1501        return HC_ERR_IPC_BUILD_PARAM;
1502    }
1503    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&authReqId), sizeof(authReqId));
1504    if (ret != HC_SUCCESS) {
1505        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1506        return HC_ERR_IPC_BUILD_PARAM;
1507    }
1508    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_AUTH_PARAMS, (const uint8_t *)authParams,
1509        HcStrlen(authParams) + 1);
1510    if (ret != HC_SUCCESS) {
1511        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_AUTH_PARAMS);
1512        return HC_ERR_IPC_BUILD_PARAM;
1513    }
1514    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
1515    if (ret != HC_SUCCESS) {
1516        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
1517        return HC_ERR_IPC_BUILD_PARAM;
1518    }
1519    SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_AUTH_ID);
1520    return HC_SUCCESS;
1521}
1522
1523static int32_t IpcGaAuthDevice(int32_t osAccountId, int64_t authReqId, const char *authParams,
1524    const DeviceAuthCallback *callback)
1525{
1526    uintptr_t callCtx = 0x0;
1527    int32_t ret;
1528    int32_t inOutLen;
1529    IpcDataInfo replyCache = { 0 };
1530
1531    LOGI("starting ...");
1532    if (IsStrInvalid(authParams) || (callback == NULL)) {
1533        LOGE("invalid params");
1534        return HC_ERR_INVALID_PARAMS;
1535    }
1536    ret = CreateCallCtx(&callCtx, NULL);
1537    if (ret != HC_SUCCESS) {
1538        LOGE("CreateCallCtx failed, ret %d", ret);
1539        return HC_ERR_IPC_INIT;
1540    }
1541    ret = EncodeAuthDeviceParams(callCtx, osAccountId, authReqId, authParams, callback);
1542    if (ret != HC_SUCCESS) {
1543        DestroyCallCtx(&callCtx, NULL);
1544        return ret;
1545    }
1546    ret = DoBinderCall(callCtx, IPC_CALL_ID_AUTH_DEVICE, true);
1547    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1548        LOGE("ipc call failed");
1549        DestroyCallCtx(&callCtx, NULL);
1550        return HC_ERR_IPC_PROC_FAILED;
1551    }
1552    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1553    ret = HC_ERR_IPC_UNKNOW_REPLY;
1554    inOutLen = sizeof(int32_t);
1555    GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1556    LOGI("process done, ret %d", ret);
1557    DestroyCallCtx(&callCtx, NULL);
1558    return ret;
1559}
1560
1561static void IpcGaCancelRequest(int64_t requestId, const char *appId)
1562{
1563    uintptr_t callCtx = 0x0;
1564    int32_t ret;
1565
1566    LOGI("starting ...");
1567    if (IsStrInvalid(appId)) {
1568        LOGE("Invalid params.");
1569        return;
1570    }
1571    ret = CreateCallCtx(&callCtx, NULL);
1572    if (ret != HC_SUCCESS) {
1573        LOGE("CreateCallCtx failed, ret %d", ret);
1574        return;
1575    }
1576    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&requestId), sizeof(requestId));
1577    if (ret != HC_SUCCESS) {
1578        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1579        DestroyCallCtx(&callCtx, NULL);
1580        return;
1581    }
1582    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, HcStrlen(appId) + 1);
1583    if (ret != HC_SUCCESS) {
1584        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
1585        DestroyCallCtx(&callCtx, NULL);
1586        return;
1587    }
1588    ret = DoBinderCall(callCtx, IPC_CALL_GA_CANCEL_REQUEST, true);
1589    DestroyCallCtx(&callCtx, NULL);
1590    if (ret != HC_SUCCESS) {
1591        LOGE("ipc call failed");
1592    } else {
1593        LOGI("process done, ret %d", ret);
1594    }
1595}
1596
1597static int32_t GetIpcReplyByTypeInner(const IpcDataInfo *replies, int32_t cacheNum, char **outInfo)
1598{
1599    GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_RETURN_DATA, (uint8_t *)outInfo, NULL);
1600    if (*outInfo == NULL) {
1601        return HC_ERR_IPC_OUT_DATA;
1602    }
1603    *outInfo = strdup(*outInfo);
1604    if (*outInfo == NULL) {
1605        return HC_ERR_ALLOC_MEMORY;
1606    }
1607    return HC_SUCCESS;
1608}
1609
1610static int32_t IpcGaGetRealInfo(int32_t osAccountId, const char *pseudonymId, char **realInfo)
1611{
1612    uintptr_t callCtx = 0x0;
1613    int32_t ret;
1614    IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1615
1616    LOGI("starting ...");
1617    if (IsStrInvalid(pseudonymId) || (realInfo == NULL)) {
1618        LOGE("Invalid params.");
1619        return HC_ERR_INVALID_PARAMS;
1620    }
1621    ret = CreateCallCtx(&callCtx, NULL);
1622    if (ret != HC_SUCCESS) {
1623        LOGE("CreateCallCtx failed, ret %d", ret);
1624        return HC_ERR_IPC_INIT;
1625    }
1626    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1627        sizeof(osAccountId));
1628    if (ret != HC_SUCCESS) {
1629        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1630        DestroyCallCtx(&callCtx, NULL);
1631        return HC_ERR_IPC_BUILD_PARAM;
1632    }
1633    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_PSEUDONYM_ID, (const uint8_t *)pseudonymId,
1634        HcStrlen(pseudonymId) + 1);
1635    if (ret != HC_SUCCESS) {
1636        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_PSEUDONYM_ID);
1637        DestroyCallCtx(&callCtx, NULL);
1638        return HC_ERR_IPC_BUILD_PARAM;
1639    }
1640    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_REAL_INFO, true);
1641    if (ret != HC_SUCCESS) {
1642        LOGE("ipc call failed");
1643        DestroyCallCtx(&callCtx, NULL);
1644        return HC_ERR_IPC_PROC_FAILED;
1645    }
1646    LOGI("process done, ret %d", ret);
1647    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1648    ret = GetIpcReplyByTypeInner(replyCache, REPLAY_CACHE_NUM(replyCache), realInfo);
1649    if (ret != HC_SUCCESS) {
1650        LOGE("GetIpcReplyByType failed, ret %d", ret);
1651    }
1652    DestroyCallCtx(&callCtx, NULL);
1653    return ret;
1654}
1655
1656static int32_t IpcGaGetPseudonymId(int32_t osAccountId, const char *indexKey, char **pseudonymId)
1657{
1658    uintptr_t callCtx = 0x0;
1659    int32_t ret;
1660    IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1661
1662    LOGI("starting ...");
1663    if (IsStrInvalid(indexKey) || (pseudonymId == NULL)) {
1664        LOGE("Invalid params.");
1665        return HC_ERR_INVALID_PARAMS;
1666    }
1667    ret = CreateCallCtx(&callCtx, NULL);
1668    if (ret != HC_SUCCESS) {
1669        LOGE("CreateCallCtx failed, ret %d", ret);
1670        return HC_ERR_IPC_INIT;
1671    }
1672    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId,
1673        sizeof(osAccountId));
1674    if (ret != HC_SUCCESS) {
1675        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID);
1676        DestroyCallCtx(&callCtx, NULL);
1677        return HC_ERR_IPC_BUILD_PARAM;
1678    }
1679    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_INDEX_KEY, (const uint8_t *)indexKey, HcStrlen(indexKey) + 1);
1680    if (ret != HC_SUCCESS) {
1681        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_INDEX_KEY);
1682        DestroyCallCtx(&callCtx, NULL);
1683        return HC_ERR_IPC_BUILD_PARAM;
1684    }
1685    ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_PSEUDONYM_ID, true);
1686    if (ret != HC_SUCCESS) {
1687        LOGE("ipc call failed");
1688        DestroyCallCtx(&callCtx, NULL);
1689        return HC_ERR_IPC_PROC_FAILED;
1690    }
1691    LOGI("process done, ret %d", ret);
1692    DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1693    ret = GetIpcReplyByTypeInner(replyCache, REPLAY_CACHE_NUM(replyCache), pseudonymId);
1694    if (ret != HC_SUCCESS) {
1695        LOGE("GetIpcReplyByType failed, ret %d", ret);
1696    }
1697    DestroyCallCtx(&callCtx, NULL);
1698    return ret;
1699}
1700
1701static void InitIpcGaMethods(GroupAuthManager *gaMethodObj)
1702{
1703    gaMethodObj->processData = IpcGaProcessData;
1704    gaMethodObj->authDevice = IpcGaAuthDevice;
1705    gaMethodObj->cancelRequest = IpcGaCancelRequest;
1706    gaMethodObj->getRealInfo = IpcGaGetRealInfo;
1707    gaMethodObj->getPseudonymId = IpcGaGetPseudonymId;
1708    return;
1709}
1710
1711DEVICE_AUTH_API_PUBLIC int32_t ProcessCredential(int32_t operationCode, const char *reqJsonStr, char **returnData)
1712{
1713    uintptr_t callCtx = IPC_CALL_CONTEXT_INIT;
1714    int32_t ret;
1715    IpcDataInfo replyCache = { 0 };
1716
1717    LOGI("starting ...");
1718    if (IsStrInvalid(reqJsonStr) || (returnData == NULL)) {
1719        LOGE("Invalid params.");
1720        return HC_ERR_INVALID_PARAMS;
1721    }
1722    ret = CreateCallCtx(&callCtx, NULL);
1723    if (ret != HC_SUCCESS) {
1724        LOGE("CreateCallCtx failed, ret %d", ret);
1725        return HC_ERR_IPC_INIT;
1726    }
1727    ret = SetCallRequestParamInfo(
1728        callCtx, PARAM_TYPE_OPCODE, (const uint8_t *)&operationCode, sizeof(operationCode));
1729    if (ret != HC_SUCCESS) {
1730        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OPCODE);
1731        DestroyCallCtx(&callCtx, NULL);
1732        return HC_ERR_IPC_BUILD_PARAM;
1733    }
1734    ret =
1735        SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQ_JSON, (const uint8_t *)reqJsonStr, HcStrlen(reqJsonStr) + 1);
1736    if (ret != HC_SUCCESS) {
1737        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQ_JSON);
1738        DestroyCallCtx(&callCtx, NULL);
1739        return HC_ERR_IPC_BUILD_PARAM;
1740    }
1741    ret = DoBinderCall(callCtx, IPC_CALL_ID_PROCESS_CREDENTIAL, true);
1742    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1743        LOGE("ipc call failed");
1744        DestroyCallCtx(&callCtx, NULL);
1745        return HC_ERR_IPC_PROC_FAILED;
1746    }
1747    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1748    ret = GetIpcReplyByTypeInner(&replyCache, REPLAY_CACHE_NUM(replyCache), returnData);
1749    if (ret != HC_SUCCESS) {
1750        LOGE("GetIpcReplyByType failed, ret %d", ret);
1751    }
1752    DestroyCallCtx(&callCtx, NULL);
1753    return ret;
1754}
1755
1756DEVICE_AUTH_API_PUBLIC int32_t ProcessAuthDevice(
1757    int64_t requestId, const char *authParams, const DeviceAuthCallback *callback)
1758{
1759    uintptr_t callCtx = IPC_CALL_CONTEXT_INIT;
1760    int32_t ret;
1761    int32_t inOutLen;
1762    IpcDataInfo replyCache = { 0 };
1763
1764    LOGI("starting ...");
1765    if (IsStrInvalid(authParams) || (callback == NULL)) {
1766        LOGE("invalid params");
1767        return HC_ERR_INVALID_PARAMS;
1768    }
1769    ret = CreateCallCtx(&callCtx, NULL);
1770    if (ret != HC_SUCCESS) {
1771        LOGE("CreateCallCtx failed, ret %d", ret);
1772        return HC_ERR_IPC_INIT;
1773    }
1774    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&requestId), sizeof(requestId));
1775    if (ret != HC_SUCCESS) {
1776        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1777        DestroyCallCtx(&callCtx, NULL);
1778        return HC_ERR_IPC_BUILD_PARAM;
1779    }
1780    ret = SetCallRequestParamInfo(
1781        callCtx, PARAM_TYPE_AUTH_PARAMS, (const uint8_t *)authParams, HcStrlen(authParams) + 1);
1782    if (ret != HC_SUCCESS) {
1783        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_AUTH_PARAMS);
1784        DestroyCallCtx(&callCtx, NULL);
1785        return HC_ERR_IPC_BUILD_PARAM;
1786    }
1787    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
1788    if (ret != HC_SUCCESS) {
1789        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
1790        DestroyCallCtx(&callCtx, NULL);
1791        return HC_ERR_IPC_BUILD_PARAM;
1792    }
1793    SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_DIRECT_AUTH_ID);
1794    ret = DoBinderCall(callCtx, IPC_CALL_ID_DA_PROC_DATA, true);
1795    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1796        LOGE("ipc call failed");
1797        DestroyCallCtx(&callCtx, NULL);
1798        return HC_ERR_IPC_PROC_FAILED;
1799    }
1800    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1801    ret = HC_ERR_IPC_UNKNOW_REPLY;
1802    inOutLen = sizeof(int32_t);
1803    GetIpcReplyByType(
1804        &replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1805    LOGI("process done, ret %d", ret);
1806    DestroyCallCtx(&callCtx, NULL);
1807    return ret;
1808}
1809
1810DEVICE_AUTH_API_PUBLIC int32_t StartAuthDevice(
1811    int64_t authReqId, const char *authParams, const DeviceAuthCallback *callback)
1812{
1813    uintptr_t callCtx = IPC_CALL_CONTEXT_INIT;
1814    int32_t ret;
1815    int32_t inOutLen;
1816    IpcDataInfo replyCache = { 0 };
1817
1818    LOGI("starting ...");
1819    if (IsStrInvalid(authParams) || (callback == NULL)) {
1820        LOGE("invalid params");
1821        return HC_ERR_INVALID_PARAMS;
1822    }
1823    ret = CreateCallCtx(&callCtx, NULL);
1824    if (ret != HC_SUCCESS) {
1825        LOGE("CreateCallCtx failed, ret %d", ret);
1826        return HC_ERR_IPC_INIT;
1827    }
1828    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&authReqId), sizeof(authReqId));
1829    if (ret != HC_SUCCESS) {
1830        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1831        DestroyCallCtx(&callCtx, NULL);
1832        return HC_ERR_IPC_BUILD_PARAM;
1833    }
1834    ret = SetCallRequestParamInfo(
1835        callCtx, PARAM_TYPE_AUTH_PARAMS, (const uint8_t *)authParams, HcStrlen(authParams) + 1);
1836    if (ret != HC_SUCCESS) {
1837        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_AUTH_PARAMS);
1838        DestroyCallCtx(&callCtx, NULL);
1839        return HC_ERR_IPC_BUILD_PARAM;
1840    }
1841    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
1842    if (ret != HC_SUCCESS) {
1843        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
1844        DestroyCallCtx(&callCtx, NULL);
1845        return HC_ERR_IPC_BUILD_PARAM;
1846    }
1847    SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_DIRECT_AUTH_ID);
1848    ret = DoBinderCall(callCtx, IPC_CALL_ID_DA_AUTH_DEVICE, true);
1849    if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1850        LOGE("ipc call failed");
1851        DestroyCallCtx(&callCtx, NULL);
1852        return HC_ERR_IPC_PROC_FAILED;
1853    }
1854    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1855    ret = HC_ERR_IPC_UNKNOW_REPLY;
1856    inOutLen = sizeof(int32_t);
1857    GetIpcReplyByType(
1858        &replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1859    LOGI("process done, ret %d", ret);
1860    DestroyCallCtx(&callCtx, NULL);
1861    return ret;
1862}
1863
1864DEVICE_AUTH_API_PUBLIC int32_t CancelAuthRequest(int64_t requestId, const char *authParams)
1865{
1866    uintptr_t callCtx = IPC_CALL_CONTEXT_INIT;
1867    int32_t ret;
1868    int32_t inOutLen;
1869    IpcDataInfo replyCache = { 0 };
1870
1871    LOGI("starting ...");
1872    if (IsStrInvalid(authParams)) {
1873        LOGE("Invalid params.");
1874        return HC_ERR_INVALID_PARAMS;
1875    }
1876    ret = CreateCallCtx(&callCtx, NULL);
1877    if (ret != HC_SUCCESS) {
1878        LOGE("CreateCallCtx failed, ret %d", ret);
1879        return HC_ERR_NULL_PTR;
1880    }
1881    ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&requestId), sizeof(requestId));
1882    if (ret != HC_SUCCESS) {
1883        LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
1884        DestroyCallCtx(&callCtx, NULL);
1885        return HC_ERR_NULL_PTR;
1886    }
1887    ret = SetCallRequestParamInfo(
1888        callCtx, PARAM_TYPE_AUTH_PARAMS, (const uint8_t *)authParams, HcStrlen(authParams) + 1);
1889    if (ret != HC_SUCCESS) {
1890        LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_AUTH_PARAMS);
1891        DestroyCallCtx(&callCtx, NULL);
1892        return HC_ERR_NULL_PTR;
1893    }
1894    ret = DoBinderCall(callCtx, IPC_CALL_ID_DA_CANCEL_REQUEST, true);
1895    if (ret != HC_SUCCESS) {
1896        LOGE("ipc call failed");
1897        DestroyCallCtx(&callCtx, NULL);
1898        return HC_ERR_IPC_PROC_FAILED;
1899    }
1900    DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
1901    ret = HC_ERR_IPC_UNKNOW_REPLY;
1902    inOutLen = sizeof(int32_t);
1903    GetIpcReplyByType(
1904        &replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1905    LOGI("process done, ret %d", ret);
1906    DestroyCallCtx(&callCtx, NULL);
1907    return ret;
1908}
1909
1910DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService(void)
1911{
1912    InitHcMutex(&g_ipcMutex);
1913    return InitProxyAdapt();
1914}
1915
1916DEVICE_AUTH_API_PUBLIC void DestroyDeviceAuthService(void)
1917{
1918    UnInitProxyAdapt();
1919    DestroyHcMutex(&g_ipcMutex);
1920}
1921
1922DEVICE_AUTH_API_PUBLIC const GroupAuthManager *GetGaInstance(void)
1923{
1924    static GroupAuthManager gaInstCtx;
1925    static GroupAuthManager *gaInstPtr = NULL;
1926
1927    if (gaInstPtr == NULL) {
1928        InitIpcGaMethods(&gaInstCtx);
1929        gaInstPtr = &gaInstCtx;
1930    }
1931    return (const GroupAuthManager *)(gaInstPtr);
1932}
1933
1934DEVICE_AUTH_API_PUBLIC const DeviceGroupManager *GetGmInstance(void)
1935{
1936    static DeviceGroupManager gmInstCtx;
1937    static DeviceGroupManager *gmInstPtr = NULL;
1938
1939    if (gmInstPtr == NULL) {
1940        InitIpcGmMethods(&gmInstCtx);
1941        gmInstPtr = &gmInstCtx;
1942    }
1943    return (const DeviceGroupManager *)(gmInstPtr);
1944}
1945
1946#ifdef __cplusplus
1947}
1948#endif
1949