1 /*
2 * Copyright (C) 2021-2025 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 "identity_service_ipc_sdk.h"
21 #include "ipc_sdk_defines.h"
22 #include "device_auth.h"
23 #include "hc_log.h"
24 #include "hc_mutex.h"
25 #include "hc_types.h"
26
27 #include "ipc_adapt.h"
28 #include "securec.h"
29 #include "sa_load_on_demand.h"
30
31 #ifdef __cplusplus
32 extern "C" {
33 #endif
34
35 #define IPC_DATA_CACHES_1 1
36 #define IPC_DATA_CACHES_2 2
37 #define IPC_DATA_CACHES_3 3
38 #define IPC_DATA_CACHES_4 4
39 #define IPC_DATA_CACHES_6 6
40 #define REPLAY_CACHE_NUM(caches) (sizeof(caches) / sizeof(IpcDataInfo))
41 #define IPC_APPID_LEN 128
42
43 #define IS_COMM_DATA_VALID(dPtr, dLen) (((dPtr) != NULL) && ((dLen) > 0) && ((dLen) <= 4096))
44
45 static const int32_t IPC_RESULT_NUM_1 = 1;
46 static const int32_t IPC_RESULT_NUM_2 = 2;
47 static const int32_t IPC_RESULT_NUM_4 = 4;
48
49 typedef struct {
50 uintptr_t inst;
51 char appId[IPC_APPID_LEN];
52 } IpcProxyCbInfo;
53 static IpcProxyCbInfo g_ipcProxyCbList = { 0 };
54 static IpcProxyCbInfo g_ipcListenerCbList = { 0 };
55 static HcMutex g_ipcMutex;
56 static bool g_devAuthServiceStatus = false;
57
IsStrInvalid(const char * str)58 static bool IsStrInvalid(const char *str)
59 {
60 return (str == NULL || str[0] == 0);
61 }
62
AddIpcCliCallbackCtx(const char * appId,uintptr_t cbInst,IpcProxyCbInfo * cbCache)63 static void AddIpcCliCallbackCtx(const char *appId, uintptr_t cbInst, IpcProxyCbInfo *cbCache)
64 {
65 errno_t eno;
66
67 (void)LockHcMutex(&g_ipcMutex);
68 eno = memcpy_s(cbCache->appId, IPC_APPID_LEN, appId, HcStrlen(appId) + 1);
69 if (eno != EOK) {
70 UnlockHcMutex(&g_ipcMutex);
71 LOGE("memory copy failed");
72 return;
73 }
74 cbCache->inst = cbInst;
75 UnlockHcMutex(&g_ipcMutex);
76 }
77
DelIpcCliCallbackCtx(const char * appId,IpcProxyCbInfo * cbCache)78 static void DelIpcCliCallbackCtx(const char *appId, IpcProxyCbInfo *cbCache)
79 {
80 int32_t ret;
81
82 if (cbCache->appId[0] == 0) {
83 return;
84 }
85 (void)LockHcMutex(&g_ipcMutex);
86 ret = memcmp(appId, cbCache->appId, HcStrlen(cbCache->appId) + 1);
87 if (ret == 0) {
88 cbCache->appId[0] = 0;
89 }
90 UnlockHcMutex(&g_ipcMutex);
91 return;
92 }
93
GetIpcReplyByType(const IpcDataInfo * ipcData,int32_t dataNum,int32_t type,uint8_t * outCache,int32_t * cacheLen)94 static void GetIpcReplyByType(const IpcDataInfo *ipcData,
95 int32_t dataNum, int32_t type, uint8_t *outCache, int32_t *cacheLen)
96 {
97 int32_t i;
98 errno_t eno;
99
100 for (i = 0; i < dataNum; i++) {
101 if (ipcData[i].type != type) {
102 continue;
103 }
104 switch (type) {
105 case PARAM_TYPE_REG_INFO:
106 case PARAM_TYPE_DEVICE_INFO:
107 case PARAM_TYPE_GROUP_INFO:
108 case PARAM_TYPE_CRED_ID:
109 case PARAM_TYPE_CRED_INFO:
110 case PARAM_TYPE_CRED_INFO_LIST:
111 case PARAM_TYPE_CRED_VAL:
112 case PARAM_TYPE_RETURN_DATA:
113 case PARAM_TYPE_SHARED_KEY_VAL:
114 case PARAM_TYPE_RANDOM_VAL:
115 *(uint8_t **)outCache = ipcData[i].val;
116 break;
117 case PARAM_TYPE_IPC_RESULT:
118 case PARAM_TYPE_IPC_RESULT_NUM:
119 case PARAM_TYPE_COMM_DATA:
120 case PARAM_TYPE_DATA_NUM:
121 case PARAM_TYPE_SHARED_KEY_LEN:
122 case PARAM_TYPE_RANDOM_LEN:
123 eno = memcpy_s(outCache, *cacheLen, ipcData[i].val, ipcData[i].valSz);
124 if (eno != EOK) {
125 break;
126 }
127 *cacheLen = ipcData[i].valSz;
128 break;
129 default:
130 LOGE("un-expectation type case.");
131 break;
132 }
133 }
134 return;
135 }
136
IpcGmRegCallbackInner(const char * appId,const DeviceAuthCallback * callback,bool needCache)137 static int32_t IpcGmRegCallbackInner(const char *appId, const DeviceAuthCallback *callback, bool needCache)
138 {
139 uintptr_t callCtx = 0x0;
140 int32_t ret;
141 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
142 int32_t inOutLen;
143
144 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || callback == NULL));
145 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
146 do {
147 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
148 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
149 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
150 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_REG_CB, true);
151 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
152 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
153 AddIpcCliCallbackCtx(appId, 0, &g_ipcProxyCbList);
154 if (needCache) {
155 ret = AddCallbackInfoToList(appId, callback, NULL, NULL, DEVAUTH_CALLBACK);
156 }
157 } while (0);
158 DESTROY_IPC_CTX(callCtx);
159
160 LOGI("process done, ret: %" LOG_PUB "d", ret);
161 return ret;
162 }
163
IpcGmRegCallback(const char * appId,const DeviceAuthCallback * callback)164 static int32_t IpcGmRegCallback(const char *appId, const DeviceAuthCallback *callback)
165 {
166 LOGI("starting ...");
167 return IpcGmRegCallbackInner(appId, callback, true);
168 }
169
IpcGmUnRegCallback(const char * appId)170 static int32_t IpcGmUnRegCallback(const char *appId)
171 {
172 uintptr_t callCtx = 0x0;
173 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
174 int32_t inOutLen;
175 int32_t ret;
176 LOGI("starting ...");
177
178 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(appId));
179 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
180 do {
181 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
182 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_UNREG_CB, true);
183 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
184 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
185 DelIpcCliCallbackCtx(appId, &g_ipcProxyCbList);
186 ret = RemoveCallbackInfoFromList(appId, DEVAUTH_CALLBACK);
187 } while (0);
188 DESTROY_IPC_CTX(callCtx);
189
190 LOGI("process done, ret: %" LOG_PUB "d", ret);
191 return ret;
192 }
193
IpcGmRegDataChangeListenerInner(const char * appId,const DataChangeListener * listener,bool needCache)194 static int32_t IpcGmRegDataChangeListenerInner(const char *appId, const DataChangeListener *listener, bool needCache)
195 {
196 uintptr_t callCtx = 0x0;
197 int32_t ret;
198 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
199 int32_t inOutLen;
200
201 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || (listener == NULL)));
202 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
203 do {
204 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
205 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_LISTENER, listener, sizeof(*listener));
206 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
207 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_REG_LISTENER, true);
208 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
209 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
210 AddIpcCliCallbackCtx(appId, 0, &g_ipcListenerCbList);
211 if (needCache) {
212 ret = AddCallbackInfoToList(appId, NULL, listener, NULL, GROUP_CHANGE_LISTENER);
213 }
214 } while (0);
215 DESTROY_IPC_CTX(callCtx);
216
217 LOGI("process done, ret: %" LOG_PUB "d", ret);
218 return ret;
219 }
220
IpcGmRegDataChangeListener(const char * appId,const DataChangeListener * listener)221 static int32_t IpcGmRegDataChangeListener(const char *appId, const DataChangeListener *listener)
222 {
223 LOGI("starting ...");
224 return IpcGmRegDataChangeListenerInner(appId, listener, true);
225 }
226
IpcGmUnRegDataChangeListener(const char * appId)227 static int32_t IpcGmUnRegDataChangeListener(const char *appId)
228 {
229 LOGI("starting ...");
230 uintptr_t callCtx = 0x0;
231 int32_t ret;
232 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
233 int32_t inOutLen;
234
235 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(appId));
236 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
237 do {
238 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
239 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_UNREG_LISTENER, true);
240 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
241 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
242 DelIpcCliCallbackCtx(appId, &g_ipcListenerCbList);
243 ret = RemoveCallbackInfoFromList(appId, GROUP_CHANGE_LISTENER);
244 } while (0);
245 DESTROY_IPC_CTX(callCtx);
246
247 LOGI("process done, ret: %" LOG_PUB "d", ret);
248 return ret;
249 }
250
IpcGmCreateGroup(int32_t osAccountId,int64_t requestId,const char * appId,const char * createParams)251 static int32_t IpcGmCreateGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams)
252 {
253 RegisterDevAuthCallbackIfNeed();
254 LOGI("starting ...");
255 uintptr_t callCtx = 0x0;
256 int32_t ret;
257 int32_t inOutLen;
258 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
259
260 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(createParams)));
261 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
262 do {
263 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
264 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
265 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
266 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_CREATE_PARAMS, createParams, HcStrlen(createParams) + 1);
267 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CREATE_GROUP, true);
268 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
269 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
270 } while (0);
271 DESTROY_IPC_CTX(callCtx);
272
273 LOGI("process done, ret: %" LOG_PUB "d", ret);
274 return ret;
275 }
276
IpcGmDeleteGroup(int32_t osAccountId,int64_t requestId,const char * appId,const char * delParams)277 static int32_t IpcGmDeleteGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *delParams)
278 {
279 RegisterDevAuthCallbackIfNeed();
280 uintptr_t callCtx = 0x0;
281 int32_t inOutLen;
282 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
283 int32_t ret;
284 LOGI("starting ...");
285
286 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(delParams)));
287 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
288 do {
289 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
290 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
291 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
292 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEL_PARAMS, delParams, HcStrlen(delParams) + 1);
293 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DEL_GROUP, true);
294 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
295 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
296 } while (0);
297 DESTROY_IPC_CTX(callCtx);
298
299 LOGI("process done, ret: %" LOG_PUB "d", ret);
300 return ret;
301 }
302
IpcGmAddMemberToGroup(int32_t osAccountId,int64_t requestId,const char * appId,const char * addParams)303 static int32_t IpcGmAddMemberToGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams)
304 {
305 RegisterDevAuthCallbackIfNeed();
306 LOGI("starting ...");
307 uintptr_t callCtx = 0x0;
308 int32_t ret;
309 int32_t inOutLen;
310 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
311
312 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(addParams)));
313 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
314 do {
315 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
316 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
317 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
318 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_ADD_PARAMS, addParams, HcStrlen(addParams) + 1);
319 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_ADD_GROUP_MEMBER, true);
320 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
321 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
322 } while (0);
323 DESTROY_IPC_CTX(callCtx);
324
325 LOGI("process done, ret: %" LOG_PUB "d", ret);
326 return ret;
327 }
328
IpcGmDelMemberFromGroup(int32_t osAccountId,int64_t requestId,const char * appId,const char * delParams)329 static int32_t IpcGmDelMemberFromGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *delParams)
330 {
331 RegisterDevAuthCallbackIfNeed();
332 LOGI("starting ...");
333 uintptr_t callCtx = 0x0;
334 int32_t ret;
335 int32_t inOutLen;
336 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
337
338 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(delParams)));
339 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
340 do {
341 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
342 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
343 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
344 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEL_PARAMS, delParams, HcStrlen(delParams) + 1);
345 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DEL_GROUP_MEMBER, true);
346 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
347 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
348 } while (0);
349 DESTROY_IPC_CTX(callCtx);
350
351 LOGI("process done, ret: %" LOG_PUB "d", ret);
352 return ret;
353 }
354
IpcGmAddMultiMembersToGroup(int32_t osAccountId,const char * appId,const char * addParams)355 static int32_t IpcGmAddMultiMembersToGroup(int32_t osAccountId, const char *appId, const char *addParams)
356 {
357 RegisterDevAuthCallbackIfNeed();
358 LOGI("starting ...");
359 int32_t ret;
360 uintptr_t callCtx = 0x0;
361 int32_t inOutLen;
362 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
363
364 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(addParams)));
365 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
366 do {
367 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
368 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
369 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_ADD_PARAMS, addParams, HcStrlen(addParams) + 1);
370 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_ADD_MULTI_GROUP_MEMBERS, true);
371 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
372 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
373 } while (0);
374 DESTROY_IPC_CTX(callCtx);
375
376 LOGI("process done, ret: %" LOG_PUB "d", ret);
377 return ret;
378 }
379
IpcGmDelMultiMembersFromGroup(int32_t osAccountId,const char * appId,const char * delParams)380 static int32_t IpcGmDelMultiMembersFromGroup(int32_t osAccountId, const char *appId, const char *delParams)
381 {
382 RegisterDevAuthCallbackIfNeed();
383 LOGI("starting ...");
384 int32_t ret;
385 uintptr_t callCtx = 0x0;
386 int32_t inOutLen;
387 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
388
389 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(delParams)));
390 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
391 do {
392 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
393 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
394 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEL_PARAMS, delParams, HcStrlen(delParams) + 1);
395 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DEL_MULTI_GROUP_MEMBERS, true);
396 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
397 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
398 } while (0);
399 DESTROY_IPC_CTX(callCtx);
400
401 LOGI("process done, ret: %" LOG_PUB "d", ret);
402 return ret;
403 }
404
IpcGmProcessData(int64_t requestId,const uint8_t * data,uint32_t dataLen)405 static int32_t IpcGmProcessData(int64_t requestId, const uint8_t *data, uint32_t dataLen)
406 {
407 RegisterDevAuthCallbackIfNeed();
408 LOGI("starting ...");
409 uintptr_t callCtx = 0x0;
410 int32_t ret;
411 int32_t inOutLen;
412 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
413
414 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((!IS_COMM_DATA_VALID(data, dataLen)));
415 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
416 do {
417 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
418 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
419 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GM_PROC_DATA, true);
420 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
421 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
422 } while (0);
423 DESTROY_IPC_CTX(callCtx);
424
425 LOGI("process done, ret: %" LOG_PUB "d", ret);
426 return ret;
427 }
428
IpcGmGetRegisterInfo(const char * reqJsonStr,char ** registerInfo)429 static int32_t IpcGmGetRegisterInfo(const char *reqJsonStr, char **registerInfo)
430 {
431 LOGI("starting ...");
432 int32_t ret;
433 uintptr_t callCtx = 0x0;
434 int32_t inOutLen;
435 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
436 char *outInfo = NULL;
437
438 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(reqJsonStr) || (registerInfo == NULL)));
439 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
440 do {
441 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQ_JSON, reqJsonStr, HcStrlen(reqJsonStr) + 1);
442 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_APPLY_REG_INFO, true);
443 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
444 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
445 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
446 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_REG_INFO, outInfo);
447 *registerInfo = strdup(outInfo);
448 if (*registerInfo == NULL) {
449 ret = HC_ERR_ALLOC_MEMORY;
450 }
451 } while (0);
452 DESTROY_IPC_CTX(callCtx);
453
454 LOGI("process done, ret: %" LOG_PUB "d", ret);
455 return ret;
456 }
457
IpcGmCheckAccessToGroup(int32_t osAccountId,const char * appId,const char * groupId)458 static int32_t IpcGmCheckAccessToGroup(int32_t osAccountId, const char *appId, const char *groupId)
459 {
460 uintptr_t callCtx = 0x0;
461 int32_t ret;
462 int32_t inOutLen;
463 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
464
465 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(groupId)));
466 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
467 do {
468 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
469 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
470 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_GROUPID, groupId, HcStrlen(groupId) + 1);
471 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CHECK_ACCESS_TO_GROUP, true);
472 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
473 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
474 } while (0);
475 DESTROY_IPC_CTX(callCtx);
476
477 return ret;
478 }
479
IpcGmGetPkInfoList(int32_t osAccountId,const char * appId,const char * queryParams,char ** returnInfoList,uint32_t * returnInfoNum)480 static int32_t IpcGmGetPkInfoList(int32_t osAccountId, const char *appId, const char *queryParams,
481 char **returnInfoList, uint32_t *returnInfoNum)
482 {
483 uintptr_t callCtx = 0x0;
484 int32_t ret;
485 int32_t inOutLen;
486 IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
487 char *outInfo = NULL;
488
489 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(queryParams) || (returnInfoList == NULL)
490 || (returnInfoNum == NULL)));
491 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
492 do {
493 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
494 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
495 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_QUERY_PARAMS, queryParams, HcStrlen(queryParams) + 1);
496 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_PK_INFO_LIST, true);
497 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
498 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
499 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_2);
500 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_RETURN_DATA, outInfo);
501 *returnInfoList = strdup(outInfo);
502 if (*returnInfoList == NULL) {
503 ret = HC_ERR_ALLOC_MEMORY;
504 break;
505 }
506 GET_IPC_REPLY_INT(replyCache, PARAM_TYPE_DATA_NUM, returnInfoNum);
507 } while (0);
508 DESTROY_IPC_CTX(callCtx);
509
510 return ret;
511 }
512
IpcGmGetGroupInfoById(int32_t osAccountId,const char * appId,const char * groupId,char ** outGroupInfo)513 static int32_t IpcGmGetGroupInfoById(int32_t osAccountId, const char *appId, const char *groupId, char **outGroupInfo)
514 {
515 int32_t ret;
516 uintptr_t callCtx = 0x0;
517 int32_t inOutLen;
518 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
519 char *outInfo = NULL;
520
521 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(groupId) || (outGroupInfo == NULL)));
522 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
523 do {
524 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
525 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
526 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_GROUPID, groupId, HcStrlen(groupId) + 1);
527 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_GROUP_INFO, true);
528 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
529 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
530 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
531 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_GROUP_INFO, outInfo);
532 *outGroupInfo = strdup(outInfo);
533 if (*outGroupInfo == NULL) {
534 ret = HC_ERR_ALLOC_MEMORY;
535 }
536 } while (0);
537 DESTROY_IPC_CTX(callCtx);
538
539 return ret;
540 }
541
IpcGmGetGroupInfo(int32_t osAccountId,const char * appId,const char * queryParams,char ** outGroupVec,uint32_t * groupNum)542 static int32_t IpcGmGetGroupInfo(int32_t osAccountId, const char *appId, const char *queryParams,
543 char **outGroupVec, uint32_t *groupNum)
544 {
545 int32_t ret;
546 uintptr_t callCtx = 0x0;
547 int32_t inOutLen;
548 IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
549 char *outInfo = NULL;
550
551 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(queryParams)
552 || (outGroupVec == NULL) || (groupNum == NULL)));
553 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
554 do {
555 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
556 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
557 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_QUERY_PARAMS, queryParams, HcStrlen(queryParams) + 1);
558 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_SEARCH_GROUPS, true);
559 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
560 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
561 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_2);
562 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_GROUP_INFO, outInfo);
563 *outGroupVec = strdup(outInfo);
564 if (*outGroupVec == NULL) {
565 ret = HC_ERR_ALLOC_MEMORY;
566 break;
567 }
568 GET_IPC_REPLY_INT(replyCache, PARAM_TYPE_DATA_NUM, groupNum);
569 } while (0);
570 DESTROY_IPC_CTX(callCtx);
571
572 return ret;
573 }
574
IpcGmGetJoinedGroups(int32_t osAccountId,const char * appId,int32_t groupType,char ** outGroupVec,uint32_t * groupNum)575 static int32_t IpcGmGetJoinedGroups(int32_t osAccountId, const char *appId, int32_t groupType,
576 char **outGroupVec, uint32_t *groupNum)
577 {
578 int32_t ret;
579 uintptr_t callCtx = 0x0;
580 int32_t inOutLen;
581 IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
582 char *outInfo = NULL;
583
584 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || (outGroupVec == NULL) || (groupNum == NULL)));
585 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
586 do {
587 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
588 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
589 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_GROUP_TYPE, &groupType, sizeof(groupType));
590 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_JOINED_GROUPS, true);
591 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
592 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
593 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_2);
594 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_GROUP_INFO, outInfo);
595 *outGroupVec = strdup(outInfo);
596 if (*outGroupVec == NULL) {
597 ret = HC_ERR_ALLOC_MEMORY;
598 break;
599 }
600 GET_IPC_REPLY_INT(replyCache, PARAM_TYPE_DATA_NUM, groupNum);
601 } while (0);
602 DESTROY_IPC_CTX(callCtx);
603
604 return ret;
605 }
606
IpcGmGetRelatedGroups(int32_t osAccountId,const char * appId,const char * peerUdid,char ** outGroupVec,uint32_t * groupNum)607 static int32_t IpcGmGetRelatedGroups(int32_t osAccountId, const char *appId, const char *peerUdid,
608 char **outGroupVec, uint32_t *groupNum)
609 {
610 uintptr_t callCtx = 0x0;
611 int32_t ret;
612 int32_t inOutLen;
613 IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
614 char *outInfo = NULL;
615
616 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(peerUdid) ||
617 (outGroupVec == NULL) || (groupNum == NULL)));
618 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
619 do {
620 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
621 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
622 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_UDID, peerUdid, HcStrlen(peerUdid) + 1);
623 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_RELATED_GROUPS, true);
624 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
625 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
626 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_2);
627 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_GROUP_INFO, outInfo);
628 *outGroupVec = strdup(outInfo);
629 if (*outGroupVec == NULL) {
630 ret = HC_ERR_ALLOC_MEMORY;
631 break;
632 }
633 GET_IPC_REPLY_INT(replyCache, PARAM_TYPE_DATA_NUM, groupNum);
634 } while (0);
635 DESTROY_IPC_CTX(callCtx);
636
637 return ret;
638 }
639
IpcGmGetDeviceInfoById(int32_t osAccountId,const char * appId,const char * peerUdid,const char * groupId,char ** outDevInfo)640 static int32_t IpcGmGetDeviceInfoById(int32_t osAccountId, const char *appId, const char *peerUdid, const char *groupId,
641 char **outDevInfo)
642 {
643 uintptr_t callCtx = 0x0;
644 int32_t ret;
645 int32_t inOutLen;
646 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
647 char *outInfo = NULL;
648
649 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(peerUdid) ||
650 IsStrInvalid(groupId) || (outDevInfo == NULL)));
651 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
652 do {
653 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
654 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
655 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_UDID, peerUdid, HcStrlen(peerUdid) + 1);
656 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_GROUPID, groupId, HcStrlen(groupId) + 1);
657 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_DEV_INFO_BY_ID, true);
658 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
659 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
660 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
661 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_DEVICE_INFO, outInfo);
662 *outDevInfo = strdup(outInfo);
663 if (*outDevInfo == NULL) {
664 ret = HC_ERR_ALLOC_MEMORY;
665 }
666 } while (0);
667 DESTROY_IPC_CTX(callCtx);
668
669 return ret;
670 }
671
IpcGmGetTrustedDevices(int32_t osAccountId,const char * appId,const char * groupId,char ** outDevInfoVec,uint32_t * deviceNum)672 static int32_t IpcGmGetTrustedDevices(int32_t osAccountId, const char *appId,
673 const char *groupId, char **outDevInfoVec, uint32_t *deviceNum)
674 {
675 int32_t ret;
676 uintptr_t callCtx = 0x0;
677 int32_t inOutLen;
678 IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
679 char *outInfo = NULL;
680
681 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(groupId) ||
682 (outDevInfoVec == NULL) || (deviceNum == NULL)));
683 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
684 do {
685 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
686 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
687 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_GROUPID, groupId, HcStrlen(groupId) + 1);
688 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_TRUST_DEVICES, true);
689 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
690 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
691 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_2);
692 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_DEVICE_INFO, outInfo);
693 *outDevInfoVec = strdup(outInfo);
694 if (*outDevInfoVec == NULL) {
695 ret = HC_ERR_ALLOC_MEMORY;
696 break;
697 }
698 GET_IPC_REPLY_INT(replyCache, PARAM_TYPE_DATA_NUM, deviceNum);
699 } while (0);
700 DESTROY_IPC_CTX(callCtx);
701
702 return ret;
703 }
704
IpcGmIsDeviceInGroup(int32_t osAccountId,const char * appId,const char * groupId,const char * udid)705 static bool IpcGmIsDeviceInGroup(int32_t osAccountId, const char *appId, const char *groupId, const char *udid)
706 {
707 int32_t ret;
708 uintptr_t callCtx = 0x0;
709 int32_t inOutLen;
710 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
711
712 RETURN_BOOL_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(groupId) || IsStrInvalid(udid)));
713 RETURN_BOOL_IF_CREATE_IPC_CTX_FAILED(callCtx);
714 do {
715 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
716 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
717 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_GROUPID, groupId, HcStrlen(groupId) + 1);
718 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_UDID, udid, HcStrlen(udid) + 1);
719 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_IS_DEV_IN_GROUP, true);
720 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
721 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
722 } while (0);
723 DESTROY_IPC_CTX(callCtx);
724
725 return (ret == HC_SUCCESS) ? true : false;
726 }
727
IpcGmDestroyInfo(char ** returnInfo)728 static void IpcGmDestroyInfo(char **returnInfo)
729 {
730 if ((returnInfo == NULL) || (*returnInfo == NULL)) {
731 return;
732 }
733 FreeJsonString(*returnInfo);
734 *returnInfo = NULL;
735 }
736
IpcGmCancelRequest(int64_t requestId,const char * appId)737 static void IpcGmCancelRequest(int64_t requestId, const char *appId)
738 {
739 LOGI("starting ...");
740 uintptr_t callCtx = 0x0;
741 int32_t ret;
742
743 RETURN_VOID_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId)));
744 RETURN_VOID_IF_CREATE_IPC_CTX_FAILED(callCtx);
745 do {
746 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
747 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
748 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_GM_CANCEL_REQUEST, true);
749 } while (0);
750 DESTROY_IPC_CTX(callCtx);
751
752 LOGI("process done, ret: %" LOG_PUB "d", ret);
753 }
754
InitIpcGmMethods(DeviceGroupManager * gmMethodObj)755 static void InitIpcGmMethods(DeviceGroupManager *gmMethodObj)
756 {
757 gmMethodObj->regCallback = IpcGmRegCallback;
758 gmMethodObj->unRegCallback = IpcGmUnRegCallback;
759 gmMethodObj->regDataChangeListener = IpcGmRegDataChangeListener;
760 gmMethodObj->unRegDataChangeListener = IpcGmUnRegDataChangeListener;
761 gmMethodObj->createGroup = IpcGmCreateGroup;
762 gmMethodObj->deleteGroup = IpcGmDeleteGroup;
763 gmMethodObj->addMemberToGroup = IpcGmAddMemberToGroup;
764 gmMethodObj->deleteMemberFromGroup = IpcGmDelMemberFromGroup;
765 gmMethodObj->addMultiMembersToGroup = IpcGmAddMultiMembersToGroup;
766 gmMethodObj->delMultiMembersFromGroup = IpcGmDelMultiMembersFromGroup;
767 gmMethodObj->processData = IpcGmProcessData;
768 gmMethodObj->getRegisterInfo = IpcGmGetRegisterInfo;
769 gmMethodObj->checkAccessToGroup = IpcGmCheckAccessToGroup;
770 gmMethodObj->getPkInfoList = IpcGmGetPkInfoList;
771 gmMethodObj->getGroupInfoById = IpcGmGetGroupInfoById;
772 gmMethodObj->getGroupInfo = IpcGmGetGroupInfo;
773 gmMethodObj->getJoinedGroups = IpcGmGetJoinedGroups;
774 gmMethodObj->getRelatedGroups = IpcGmGetRelatedGroups;
775 gmMethodObj->getDeviceInfoById = IpcGmGetDeviceInfoById;
776 gmMethodObj->getTrustedDevices = IpcGmGetTrustedDevices;
777 gmMethodObj->isDeviceInGroup = IpcGmIsDeviceInGroup;
778 gmMethodObj->cancelRequest = IpcGmCancelRequest;
779 gmMethodObj->destroyInfo = IpcGmDestroyInfo;
780 return;
781 }
782
IpcGaProcessData(int64_t authReqId,const uint8_t * data,uint32_t dataLen,const DeviceAuthCallback * callback)783 static int32_t IpcGaProcessData(int64_t authReqId,
784 const uint8_t *data, uint32_t dataLen, const DeviceAuthCallback *callback)
785 {
786 LOGI("starting ...");
787 RegisterDevAuthCallbackIfNeed();
788 uintptr_t callCtx = 0x0;
789 int32_t ret;
790 int32_t inOutLen;
791 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
792
793 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((!IS_COMM_DATA_VALID(data, dataLen) || (callback == NULL)));
794 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
795 do {
796 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
797 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
798 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
799 SetCbCtxToDataCtx(callCtx, 0x0);
800 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GA_PROC_DATA, true);
801 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
802 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
803 } while (0);
804 DESTROY_IPC_CTX(callCtx);
805
806 LOGI("process done, ret: %" LOG_PUB "d", ret);
807 return ret;
808 }
809
IpcGaAuthDevice(int32_t osAccountId,int64_t authReqId,const char * authParams,const DeviceAuthCallback * callback)810 static int32_t IpcGaAuthDevice(int32_t osAccountId, int64_t authReqId, const char *authParams,
811 const DeviceAuthCallback *callback)
812 {
813 LOGI("starting ...");
814 RegisterDevAuthCallbackIfNeed();
815 int32_t ret;
816 int32_t inOutLen;
817 uintptr_t callCtx = 0x0;
818 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
819
820 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (callback == NULL)));
821 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
822 do {
823 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
824 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
825 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
826 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
827 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_AUTH_ID);
828 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_AUTH_DEVICE, true);
829 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
830 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
831 } while (0);
832 DESTROY_IPC_CTX(callCtx);
833
834 LOGI("process done, ret: %" LOG_PUB "d", ret);
835 return ret;
836 }
837
IpcGaCancelRequest(int64_t requestId,const char * appId)838 static void IpcGaCancelRequest(int64_t requestId, const char *appId)
839 {
840 LOGI("starting ...");
841 uintptr_t callCtx = 0x0;
842 int32_t ret;
843
844 RETURN_VOID_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId)));
845 RETURN_VOID_IF_CREATE_IPC_CTX_FAILED(callCtx);
846 do {
847 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
848 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
849 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_GA_CANCEL_REQUEST, true);
850 } while (0);
851 DESTROY_IPC_CTX(callCtx);
852
853 LOGI("process done, ret: %" LOG_PUB "d", ret);
854 }
855
IpcGaGetRealInfo(int32_t osAccountId,const char * pseudonymId,char ** realInfo)856 static int32_t IpcGaGetRealInfo(int32_t osAccountId, const char *pseudonymId, char **realInfo)
857 {
858 uintptr_t callCtx = 0x0;
859 int32_t ret;
860 int32_t inOutLen;
861 IpcDataInfo replyCache[IPC_DATA_CACHES_2] = { { 0 } };
862 char *outInfo = NULL;
863
864 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(pseudonymId) || (realInfo == NULL)));
865 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
866 do {
867 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
868 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_PSEUDONYM_ID, pseudonymId, HcStrlen(pseudonymId) + 1);
869 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_REAL_INFO, true);
870 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
871 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
872 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_RETURN_DATA, outInfo);
873 *realInfo = strdup(outInfo);
874 if (*realInfo == NULL) {
875 ret = HC_ERR_ALLOC_MEMORY;
876 }
877 } while (0);
878 DESTROY_IPC_CTX(callCtx);
879
880 return ret;
881 }
882
IpcGaGetPseudonymId(int32_t osAccountId,const char * indexKey,char ** pseudonymId)883 static int32_t IpcGaGetPseudonymId(int32_t osAccountId, const char *indexKey, char **pseudonymId)
884 {
885 RegisterDevAuthCallbackIfNeed();
886 int32_t ret;
887 uintptr_t callCtx = 0x0;
888 int32_t inOutLen;
889 IpcDataInfo replyCache[IPC_DATA_CACHES_2] = { { 0 } };
890 char *outInfo = NULL;
891
892 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(indexKey) || (pseudonymId == NULL)));
893 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
894 do {
895 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
896 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_INDEX_KEY, indexKey, HcStrlen(indexKey) + 1);
897 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GET_PSEUDONYM_ID, true);
898 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
899 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
900 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_RETURN_DATA, outInfo);
901 *pseudonymId = strdup(outInfo);
902 if (*pseudonymId == NULL) {
903 ret = HC_ERR_ALLOC_MEMORY;
904 }
905 } while (0);
906 DESTROY_IPC_CTX(callCtx);
907
908 return ret;
909 }
910
InitIpcGaMethods(GroupAuthManager * gaMethodObj)911 static void InitIpcGaMethods(GroupAuthManager *gaMethodObj)
912 {
913 gaMethodObj->processData = IpcGaProcessData;
914 gaMethodObj->authDevice = IpcGaAuthDevice;
915 gaMethodObj->cancelRequest = IpcGaCancelRequest;
916 gaMethodObj->getRealInfo = IpcGaGetRealInfo;
917 gaMethodObj->getPseudonymId = IpcGaGetPseudonymId;
918 return;
919 }
920
SetReturnSharedKey(const uint8_t * sharedKeyVal,uint32_t sharedKeyLen,DataBuff * returnSharedKey)921 static int32_t SetReturnSharedKey(const uint8_t *sharedKeyVal, uint32_t sharedKeyLen, DataBuff *returnSharedKey)
922 {
923 uint8_t *tmpSharedKeyVal = (uint8_t *)HcMalloc(sharedKeyLen, 0);
924 if (tmpSharedKeyVal == NULL) {
925 LOGE("malloc temp shared key failed.");
926 return HC_ERR_ALLOC_MEMORY;
927 }
928 if (memcpy_s(tmpSharedKeyVal, sharedKeyLen, sharedKeyVal, sharedKeyLen) != EOK) {
929 LOGE("memcpy_s temp shared key failed.");
930 HcFree(tmpSharedKeyVal);
931 return HC_ERR_MEMORY_COPY;
932 }
933 returnSharedKey->data = tmpSharedKeyVal;
934 returnSharedKey->length = sharedKeyLen;
935 return HC_SUCCESS;
936 }
937
SetReturnRandom(const uint8_t * randomVal,uint32_t randomLen,DataBuff * returnRandom)938 static int32_t SetReturnRandom(const uint8_t *randomVal, uint32_t randomLen, DataBuff *returnRandom)
939 {
940 uint8_t *tmpRandomVal = (uint8_t *)HcMalloc(randomLen, 0);
941 if (tmpRandomVal == NULL) {
942 LOGE("malloc temp random failed.");
943 return HC_ERR_ALLOC_MEMORY;
944 }
945 if (memcpy_s(tmpRandomVal, randomLen, randomVal, randomLen) != EOK) {
946 LOGE("memcpy_s temp random failed.");
947 HcFree(tmpRandomVal);
948 return HC_ERR_MEMORY_COPY;
949 }
950 returnRandom->data = tmpRandomVal;
951 returnRandom->length = randomLen;
952 return HC_SUCCESS;
953 }
954
IpcAvDestroyDataBuff(DataBuff * dataBuff)955 static void IpcAvDestroyDataBuff(DataBuff *dataBuff)
956 {
957 if (dataBuff == NULL || dataBuff->data == NULL) {
958 return;
959 }
960 HcFree(dataBuff->data);
961 dataBuff->data = NULL;
962 dataBuff->length = 0;
963 }
964
GetSharedKeyAndRandom(const IpcDataInfo * replies,int32_t cacheNum,DataBuff * returnSharedKey,DataBuff * returnRandom)965 static int32_t GetSharedKeyAndRandom(const IpcDataInfo *replies, int32_t cacheNum, DataBuff *returnSharedKey,
966 DataBuff *returnRandom)
967 {
968 int32_t resultNum = 0;
969 int32_t inOutLen = sizeof(int32_t);
970 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&resultNum, &inOutLen);
971 if ((resultNum < IPC_RESULT_NUM_4) || (inOutLen != sizeof(int32_t))) {
972 return HC_ERR_IPC_OUT_DATA_NUM;
973 }
974
975 uint8_t *sharedKeyVal = NULL;
976 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_SHARED_KEY_VAL, (uint8_t *)&sharedKeyVal, NULL);
977 if (sharedKeyVal == NULL) {
978 return HC_ERR_IPC_OUT_DATA;
979 }
980 inOutLen = sizeof(int32_t);
981 uint32_t sharedKeyLen = 0;
982 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_SHARED_KEY_LEN, (uint8_t *)&sharedKeyLen, &inOutLen);
983 if (sharedKeyLen == 0) {
984 return HC_ERR_IPC_OUT_DATA;
985 }
986
987 uint8_t *randomVal = NULL;
988 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_RANDOM_VAL, (uint8_t *)&randomVal, NULL);
989 if (randomVal == NULL) {
990 return HC_ERR_IPC_OUT_DATA;
991 }
992 inOutLen = sizeof(int32_t);
993 uint32_t randomLen = 0;
994 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_RANDOM_LEN, (uint8_t *)&randomLen, &inOutLen);
995 if (randomLen == 0) {
996 return HC_ERR_IPC_OUT_DATA;
997 }
998 int32_t ret = SetReturnSharedKey(sharedKeyVal, sharedKeyLen, returnSharedKey);
999 if (ret != HC_SUCCESS) {
1000 return ret;
1001 }
1002 ret = SetReturnRandom(randomVal, randomLen, returnRandom);
1003 if (ret != HC_SUCCESS) {
1004 IpcAvDestroyDataBuff(returnSharedKey);
1005 }
1006 return ret;
1007 }
1008
IpcAvGetClientSharedKey(const char * peerPkWithSig,const char * serviceId,DataBuff * returnSharedKey,DataBuff * returnRandom)1009 static int32_t IpcAvGetClientSharedKey(const char *peerPkWithSig, const char *serviceId, DataBuff *returnSharedKey,
1010 DataBuff *returnRandom)
1011 {
1012 if ((peerPkWithSig == NULL) || (serviceId == NULL) || (returnSharedKey == NULL) || (returnRandom == NULL)) {
1013 LOGE("Error occurs, params invalid.");
1014 return HC_ERR_INVALID_PARAMS;
1015 }
1016 uintptr_t callCtx = 0x0;
1017 int32_t ret = CreateCallCtx(&callCtx);
1018 if (ret != HC_SUCCESS) {
1019 LOGE("CreateCallCtx failed, ret %" LOG_PUB "d", ret);
1020 return HC_ERR_IPC_INIT;
1021 }
1022 ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_PK_WITH_SIG, (const uint8_t *)peerPkWithSig,
1023 HcStrlen(peerPkWithSig) + 1);
1024 if (ret != HC_SUCCESS) {
1025 LOGE("IpcAvGetClientSharedKey set request param failed, ret %" LOG_PUB "d, param id %" LOG_PUB "d",
1026 ret, PARAM_TYPE_PK_WITH_SIG);
1027 DestroyCallCtx(&callCtx);
1028 return HC_ERR_IPC_BUILD_PARAM;
1029 }
1030 ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_SERVICE_ID, (const uint8_t *)serviceId, HcStrlen(serviceId) + 1);
1031 if (ret != HC_SUCCESS) {
1032 LOGE("IpcAvGetClientSharedKey set request param failed, ret %" LOG_PUB "d, param id %" LOG_PUB "d",
1033 ret, PARAM_TYPE_SERVICE_ID);
1034 DestroyCallCtx(&callCtx);
1035 return HC_ERR_IPC_BUILD_PARAM;
1036 }
1037 ret = DoBinderCall(callCtx, IPC_CALL_ID_AV_GET_CLIENT_SHARED_KEY, true);
1038 if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1039 DestroyCallCtx(&callCtx);
1040 return HC_ERR_IPC_PROC_FAILED;
1041 }
1042 IpcDataInfo replyCache[IPC_DATA_CACHES_6] = { { 0 } };
1043 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1044 ret = HC_ERR_IPC_UNKNOW_REPLY;
1045 int32_t inOutLen = sizeof(int32_t);
1046 GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1047 if (ret != HC_SUCCESS) {
1048 DestroyCallCtx(&callCtx);
1049 return ret;
1050 }
1051 ret = GetSharedKeyAndRandom(replyCache, REPLAY_CACHE_NUM(replyCache), returnSharedKey, returnRandom);
1052 DestroyCallCtx(&callCtx);
1053 return ret;
1054 }
1055
GetSharedKey(const IpcDataInfo * replies,int32_t cacheNum,DataBuff * returnSharedKey)1056 static int32_t GetSharedKey(const IpcDataInfo *replies, int32_t cacheNum, DataBuff *returnSharedKey)
1057 {
1058 int32_t resultNum = 0;
1059 int32_t inOutLen = sizeof(int32_t);
1060 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&resultNum, &inOutLen);
1061 if ((resultNum < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
1062 return HC_ERR_IPC_OUT_DATA_NUM;
1063 }
1064
1065 uint8_t *sharedKeyVal = NULL;
1066 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_SHARED_KEY_VAL, (uint8_t *)&sharedKeyVal, NULL);
1067 if (sharedKeyVal == NULL) {
1068 return HC_ERR_IPC_OUT_DATA;
1069 }
1070 inOutLen = sizeof(int32_t);
1071 uint32_t sharedKeyLen = 0;
1072 GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_SHARED_KEY_LEN, (uint8_t *)&sharedKeyLen, &inOutLen);
1073 if (sharedKeyLen == 0) {
1074 return HC_ERR_IPC_OUT_DATA;
1075 }
1076 return SetReturnSharedKey(sharedKeyVal, sharedKeyLen, returnSharedKey);
1077 }
1078
IpcAvGetServerSharedKey(const char * peerPkWithSig,const char * serviceId,const DataBuff * random,DataBuff * returnSharedKey)1079 static int32_t IpcAvGetServerSharedKey(const char *peerPkWithSig, const char *serviceId, const DataBuff *random,
1080 DataBuff *returnSharedKey)
1081 {
1082 if ((peerPkWithSig == NULL) || (serviceId == NULL) || (random == NULL) || (random->data == NULL) ||
1083 (returnSharedKey == NULL)) {
1084 LOGE("Invalid params.");
1085 return HC_ERR_INVALID_PARAMS;
1086 }
1087 uintptr_t callCtx = 0x0;
1088 int32_t ret = CreateCallCtx(&callCtx);
1089 if (ret != HC_SUCCESS) {
1090 LOGE("IpcAvGetServerSharedKey CreateCallCtx failed, ret %" LOG_PUB "d", ret);
1091 return HC_ERR_IPC_INIT;
1092 }
1093 ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_PK_WITH_SIG, (const uint8_t *)peerPkWithSig,
1094 HcStrlen(peerPkWithSig) + 1);
1095 if (ret != HC_SUCCESS) {
1096 LOGE("set request param failed, ret %" LOG_PUB "d, param id %" LOG_PUB "d", ret, PARAM_TYPE_PK_WITH_SIG);
1097 DestroyCallCtx(&callCtx);
1098 return HC_ERR_IPC_BUILD_PARAM;
1099 }
1100 ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_SERVICE_ID, (const uint8_t *)serviceId, HcStrlen(serviceId) + 1);
1101 if (ret != HC_SUCCESS) {
1102 LOGE("set request param failed, ret %" LOG_PUB "d, param id %" LOG_PUB "d", ret, PARAM_TYPE_SERVICE_ID);
1103 DestroyCallCtx(&callCtx);
1104 return HC_ERR_IPC_BUILD_PARAM;
1105 }
1106 ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_RANDOM, (const uint8_t *)random->data, random->length);
1107 if (ret != HC_SUCCESS) {
1108 LOGE("set request param failed, ret %" LOG_PUB "d, param id %" LOG_PUB "d", ret, PARAM_TYPE_RANDOM);
1109 DestroyCallCtx(&callCtx);
1110 return HC_ERR_IPC_BUILD_PARAM;
1111 }
1112 ret = DoBinderCall(callCtx, IPC_CALL_ID_AV_GET_SERVER_SHARED_KEY, true);
1113 if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
1114 DestroyCallCtx(&callCtx);
1115 return HC_ERR_IPC_PROC_FAILED;
1116 }
1117 IpcDataInfo replyCache[IPC_DATA_CACHES_4] = { { 0 } };
1118 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1119 ret = HC_ERR_IPC_UNKNOW_REPLY;
1120 int32_t inOutLen = sizeof(int32_t);
1121 GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
1122 if (ret != HC_SUCCESS) {
1123 DestroyCallCtx(&callCtx);
1124 return ret;
1125 }
1126 ret = GetSharedKey(replyCache, REPLAY_CACHE_NUM(replyCache), returnSharedKey);
1127 DestroyCallCtx(&callCtx);
1128 return ret;
1129 }
1130
InitIpcAccountVerifierMethods(AccountVerifier * accountVerifier)1131 static void InitIpcAccountVerifierMethods(AccountVerifier *accountVerifier)
1132 {
1133 accountVerifier->getClientSharedKey = IpcAvGetClientSharedKey;
1134 accountVerifier->getServerSharedKey = IpcAvGetServerSharedKey;
1135 accountVerifier->destroyDataBuff = IpcAvDestroyDataBuff;
1136 }
1137
IpcLaStartLightAccountAuth(int32_t osAccountId,int64_t requestId,const char * serviceId,const DeviceAuthCallback * laCallBack)1138 static int32_t IpcLaStartLightAccountAuth(int32_t osAccountId, int64_t requestId,
1139 const char *serviceId, const DeviceAuthCallback *laCallBack)
1140 {
1141 LOGI("starting ...");
1142 int32_t ret;
1143 uintptr_t callCtx = 0x0;
1144 int32_t inOutLen;
1145 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1146
1147 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(serviceId) || laCallBack == NULL));
1148 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
1149 do {
1150 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
1151 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
1152 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_SERVICE_ID, serviceId, HcStrlen(serviceId) + 1);
1153 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, laCallBack, sizeof(*laCallBack));
1154 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_LIGHT_AUTH_ID);
1155 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_LA_START_LIGHT_ACCOUNT_AUTH, true);
1156 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1157 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
1158 } while (0);
1159 DESTROY_IPC_CTX(callCtx);
1160
1161 LOGI("process done, ret: %" LOG_PUB "d", ret);
1162 return ret;
1163 }
1164
IpcLaProcessLightAccountAuth(int32_t osAccountId,int64_t requestId,DataBuff * inMsg,const DeviceAuthCallback * laCallBack)1165 static int32_t IpcLaProcessLightAccountAuth(int32_t osAccountId, int64_t requestId,
1166 DataBuff *inMsg, const DeviceAuthCallback *laCallBack)
1167 {
1168 LOGI("starting ...");
1169 int32_t ret;
1170 uintptr_t callCtx = 0x0;
1171 int32_t inOutLen;
1172 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1173
1174 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((!IS_COMM_DATA_VALID(inMsg->data, inMsg->length) || (laCallBack == NULL)));
1175 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
1176 do {
1177 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
1178 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
1179 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, inMsg->data, inMsg->length);
1180 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, laCallBack, sizeof(*laCallBack));
1181 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_LIGHT_AUTH_ID);
1182 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_LA_PROCESS_LIGHT_ACCOUNT_AUTH, true);
1183 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1184 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
1185 } while (0);
1186 DESTROY_IPC_CTX(callCtx);
1187
1188 LOGI("process done, ret: %" LOG_PUB "d", ret);
1189 return ret;
1190 }
1191
InitIpcLightAccountVerifierMethods(LightAccountVerifier * lightAccountVerifier)1192 static void InitIpcLightAccountVerifierMethods(LightAccountVerifier *lightAccountVerifier)
1193 {
1194 lightAccountVerifier->startLightAccountAuth = IpcLaStartLightAccountAuth;
1195 lightAccountVerifier->processLightAccountAuth = IpcLaProcessLightAccountAuth;
1196 }
1197
ProcessCredential(int32_t operationCode,const char * reqJsonStr,char ** returnData)1198 DEVICE_AUTH_API_PUBLIC int32_t ProcessCredential(int32_t operationCode, const char *reqJsonStr, char **returnData)
1199 {
1200 LOGI("starting ...");
1201 uintptr_t callCtx = 0x0;
1202 int32_t ret;
1203 int32_t inOutLen;
1204 IpcDataInfo replyCache[IPC_DATA_CACHES_2] = { { 0 } };
1205 char *outInfo = NULL;
1206
1207 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(reqJsonStr) || (returnData == NULL)));
1208 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
1209 do {
1210 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OPCODE, &operationCode, sizeof(operationCode));
1211 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQ_JSON, reqJsonStr, HcStrlen(reqJsonStr) + 1);
1212 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_PROCESS_CREDENTIAL, true);
1213 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1214 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
1215 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_RETURN_DATA, outInfo);
1216 *returnData = strdup(outInfo);
1217 if (*returnData == NULL) {
1218 ret = HC_ERR_ALLOC_MEMORY;
1219 }
1220 } while (0);
1221 DESTROY_IPC_CTX(callCtx);
1222
1223 LOGI("process done, ret: %" LOG_PUB "d", ret);
1224 return ret;
1225 }
1226
ProcessAuthDevice(int64_t requestId,const char * authParams,const DeviceAuthCallback * callback)1227 DEVICE_AUTH_API_PUBLIC int32_t ProcessAuthDevice(
1228 int64_t requestId, const char *authParams, const DeviceAuthCallback *callback)
1229 {
1230 LOGI("starting ...");
1231 int32_t ret;
1232 uintptr_t callCtx = 0x0;
1233 int32_t inOutLen;
1234 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1235
1236 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (callback == NULL)));
1237 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
1238 do {
1239 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
1240 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
1241 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
1242 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_DIRECT_AUTH_ID);
1243 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DA_PROC_DATA, true);
1244 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1245 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
1246 } while (0);
1247 DESTROY_IPC_CTX(callCtx);
1248
1249 LOGI("process done, ret: %" LOG_PUB "d", ret);
1250 return ret;
1251 }
1252
StartAuthDevice(int64_t authReqId,const char * authParams,const DeviceAuthCallback * callback)1253 DEVICE_AUTH_API_PUBLIC int32_t StartAuthDevice(
1254 int64_t authReqId, const char *authParams, const DeviceAuthCallback *callback)
1255 {
1256 LOGI("starting ...");
1257 int32_t ret;
1258 uintptr_t callCtx = 0x0;
1259 int32_t inOutLen;
1260 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1261
1262 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (callback == NULL)));
1263 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
1264 do {
1265 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
1266 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
1267 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
1268 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_DIRECT_AUTH_ID);
1269 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DA_AUTH_DEVICE, true);
1270 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1271 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
1272 } while (0);
1273 DESTROY_IPC_CTX(callCtx);
1274
1275 LOGI("process done, ret: %" LOG_PUB "d", ret);
1276 return ret;
1277 }
1278
CancelAuthRequest(int64_t requestId,const char * authParams)1279 DEVICE_AUTH_API_PUBLIC int32_t CancelAuthRequest(int64_t requestId, const char *authParams)
1280 {
1281 LOGI("starting ...");
1282 int32_t ret;
1283 uintptr_t callCtx = 0x0;
1284 int32_t inOutLen;
1285 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
1286
1287 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams)));
1288 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
1289 do {
1290 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
1291 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
1292 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DA_CANCEL_REQUEST, true);
1293 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
1294 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
1295 } while (0);
1296 DESTROY_IPC_CTX(callCtx);
1297
1298 LOGI("process done, ret: %" LOG_PUB "d", ret);
1299 return ret;
1300 }
1301
InitDeviceAuthService(void)1302 DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService(void)
1303 {
1304 if (g_devAuthServiceStatus == true) {
1305 LOGI("device auth sdk already init");
1306 return HC_SUCCESS;
1307 }
1308 int32_t ret = InitHcMutex(&g_ipcMutex, false);
1309 if (ret != HC_SUCCESS) {
1310 return ret;
1311 }
1312 ret = InitLoadOnDemand();
1313 if (ret != HC_SUCCESS) {
1314 DestroyHcMutex(&g_ipcMutex);
1315 return ret;
1316 }
1317 ret = InitISIpc();
1318 if (ret != HC_SUCCESS) {
1319 DeInitLoadOnDemand();
1320 DestroyHcMutex(&g_ipcMutex);
1321 return ret;
1322 }
1323 ret = InitProxyAdapt();
1324 if (ret != HC_SUCCESS) {
1325 DeInitISIpc();
1326 DeInitLoadOnDemand();
1327 DestroyHcMutex(&g_ipcMutex);
1328 return ret;
1329 }
1330 g_devAuthServiceStatus = true;
1331 SetRegCallbackFunc(IpcGmRegCallbackInner);
1332 SetRegDataChangeListenerFunc(IpcGmRegDataChangeListenerInner);
1333 SubscribeDeviceAuthSa();
1334 return HC_SUCCESS;
1335 }
1336
DestroyDeviceAuthService(void)1337 DEVICE_AUTH_API_PUBLIC void DestroyDeviceAuthService(void)
1338 {
1339 UnSubscribeDeviceAuthSa();
1340 UnInitProxyAdapt();
1341 DeInitISIpc();
1342 DeInitLoadOnDemand();
1343 DestroyHcMutex(&g_ipcMutex);
1344 g_devAuthServiceStatus = false;
1345 }
1346
GetGaInstance(void)1347 DEVICE_AUTH_API_PUBLIC const GroupAuthManager *GetGaInstance(void)
1348 {
1349 static GroupAuthManager gaInstCtx;
1350 static GroupAuthManager *gaInstPtr = NULL;
1351
1352 if (gaInstPtr == NULL) {
1353 InitIpcGaMethods(&gaInstCtx);
1354 gaInstPtr = &gaInstCtx;
1355 }
1356 return (const GroupAuthManager *)(gaInstPtr);
1357 }
1358
GetGmInstance(void)1359 DEVICE_AUTH_API_PUBLIC const DeviceGroupManager *GetGmInstance(void)
1360 {
1361 static DeviceGroupManager gmInstCtx;
1362 static DeviceGroupManager *gmInstPtr = NULL;
1363
1364 if (gmInstPtr == NULL) {
1365 InitIpcGmMethods(&gmInstCtx);
1366 gmInstPtr = &gmInstCtx;
1367 }
1368 return (const DeviceGroupManager *)(gmInstPtr);
1369 }
1370
GetAccountVerifierInstance(void)1371 DEVICE_AUTH_API_PUBLIC const AccountVerifier *GetAccountVerifierInstance(void)
1372 {
1373 static AccountVerifier avInstCtx;
1374 static AccountVerifier *avInstPtr = NULL;
1375 InitIpcAccountVerifierMethods(&avInstCtx);
1376 avInstPtr = &avInstCtx;
1377 return (const AccountVerifier *)(avInstPtr);
1378 }
1379
GetLightAccountVerifierInstance(void)1380 DEVICE_AUTH_API_PUBLIC const LightAccountVerifier *GetLightAccountVerifierInstance(void)
1381 {
1382 static LightAccountVerifier laInstCtx;
1383 static LightAccountVerifier *laInstPtr = NULL;
1384 InitIpcLightAccountVerifierMethods(&laInstCtx);
1385 laInstPtr = &laInstCtx;
1386 return (const LightAccountVerifier *)(laInstPtr);
1387 }
1388
1389 #ifdef __cplusplus
1390 }
1391 #endif
1392