1 /*
2 * Copyright (C) 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 "identity_service_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 #include "sa_load_on_demand.h"
24 #include "ipc_sdk_defines.h"
25
26 #include "ipc_adapt.h"
27 #include "securec.h"
28
29 #ifdef __cplusplus
30 extern "C" {
31 #endif
32
33 #define IPC_DATA_CACHES_1 1
34 #define IPC_DATA_CACHES_3 3
35 #define IPC_DATA_CACHES_4 4
36 #define REPLAY_CACHE_NUM(caches) (sizeof(caches) / sizeof(IpcDataInfo))
37 #define IPC_APPID_LEN 128
38
39 #define IS_COMM_DATA_VALID(dPtr, dLen) (((dPtr) != NULL) && ((dLen) > 0) && ((dLen) <= 4096))
40
41 static const int32_t IPC_RESULT_NUM_1 = 1;
42
43 typedef struct {
44 uintptr_t inst;
45 char appId[IPC_APPID_LEN];
46 } IpcProxyCbInfo;
47
48 static IpcProxyCbInfo g_ipcCredListenerCbList = { 0 };
49 static HcMutex g_ipcMutex;
50
DelIpcCliCallbackCtx(const char * appId,IpcProxyCbInfo * cbCache)51 static void DelIpcCliCallbackCtx(const char *appId, IpcProxyCbInfo *cbCache)
52 {
53 if (cbCache->appId[0] == 0) {
54 return;
55 }
56 (void)LockHcMutex(&g_ipcMutex);
57 int32_t ret = memcmp(appId, cbCache->appId, HcStrlen(cbCache->appId) + 1);
58 if (ret == 0) {
59 cbCache->appId[0] = 0;
60 }
61 UnlockHcMutex(&g_ipcMutex);
62 return;
63 }
64
IsStrInvalid(const char * str)65 static bool IsStrInvalid(const char *str)
66 {
67 return (str == NULL || str[0] == 0);
68 }
69
AddIpcCliCallbackCtx(const char * appId,uintptr_t cbInst,IpcProxyCbInfo * cbCache)70 static void AddIpcCliCallbackCtx(const char *appId, uintptr_t cbInst, IpcProxyCbInfo *cbCache)
71 {
72 errno_t eno;
73 (void)LockHcMutex(&g_ipcMutex);
74 eno = memcpy_s(cbCache->appId, IPC_APPID_LEN, appId, HcStrlen(appId) + 1);
75 if (eno != EOK) {
76 UnlockHcMutex(&g_ipcMutex);
77 LOGE("memory copy appId to cbcache failed.");
78 return;
79 }
80 cbCache->inst = cbInst;
81 UnlockHcMutex(&g_ipcMutex);
82 }
83
GetIpcReplyByType(const IpcDataInfo * ipcData,int32_t dataNum,int32_t type,uint8_t * outCache,int32_t * cacheLen)84 static void GetIpcReplyByType(const IpcDataInfo *ipcData,
85 int32_t dataNum, int32_t type, uint8_t *outCache, int32_t *cacheLen)
86 {
87 int32_t i;
88 errno_t eno;
89
90 for (i = 0; i < dataNum; i++) {
91 if (ipcData[i].type != type) {
92 continue;
93 }
94 switch (type) {
95 case PARAM_TYPE_REG_INFO:
96 case PARAM_TYPE_DEVICE_INFO:
97 case PARAM_TYPE_GROUP_INFO:
98 case PARAM_TYPE_CRED_ID:
99 case PARAM_TYPE_CRED_INFO:
100 case PARAM_TYPE_CRED_INFO_LIST:
101 case PARAM_TYPE_CRED_VAL:
102 case PARAM_TYPE_RETURN_DATA:
103 *(uint8_t **)outCache = ipcData[i].val;
104 break;
105 case PARAM_TYPE_IPC_RESULT:
106 case PARAM_TYPE_IPC_RESULT_NUM:
107 case PARAM_TYPE_COMM_DATA:
108 case PARAM_TYPE_DATA_NUM:
109 eno = memcpy_s(outCache, *cacheLen, ipcData[i].val, ipcData[i].valSz);
110 if (eno != EOK) {
111 break;
112 }
113 *cacheLen = ipcData[i].valSz;
114 break;
115 default:
116 LOGE("un-expectation type case");
117 break;
118 }
119 }
120 return;
121 }
122
IpcCmAddCredential(int32_t osAccountId,const char * requestParams,char ** returnData)123 static int32_t IpcCmAddCredential(int32_t osAccountId, const char *requestParams, char **returnData)
124 {
125 RegisterDevAuthCallbackIfNeed();
126 LOGI("starting ...");
127 uintptr_t callCtx = 0x0;
128 int32_t ret;
129 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
130 char *outInfo = NULL;
131 int32_t inOutLen;
132
133 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(requestParams) || returnData == NULL);
134 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
135 do {
136 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
137 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQUEST_PARAMS, requestParams, HcStrlen(requestParams) + 1);
138 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_ADD_CREDENTIAL, true);
139 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
140 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
141 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
142 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_ID, outInfo);
143 *returnData = strdup(outInfo);
144 if (*returnData == NULL) {
145 ret = HC_ERR_ALLOC_MEMORY;
146 }
147 } while (0);
148 DESTROY_IPC_CTX(callCtx);
149 LOGI("process done, ret: %" LOG_PUB "d", ret);
150 return ret;
151 }
152
IpcCmRegChangeListenerInner(const char * appId,CredChangeListener * listener,bool needCache)153 static int32_t IpcCmRegChangeListenerInner(const char *appId, CredChangeListener *listener, bool needCache)
154 {
155 LOGI("starting ...");
156 uintptr_t callCtx = 0x0;
157 int32_t ret;
158 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
159 int32_t inOutLen;
160
161 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || (listener == NULL)));
162 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
163 do {
164 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
165 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_LISTENER, listener, sizeof(*listener));
166 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
167 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_REG_LISTENER, true);
168 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
169 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
170 AddIpcCliCallbackCtx(appId, 0, &g_ipcCredListenerCbList);
171 if (needCache) {
172 ret = AddCallbackInfoToList(appId, NULL, NULL, listener, CRED_CHANGE_LISTENER);
173 }
174 } while (0);
175 DESTROY_IPC_CTX(callCtx);
176 LOGI("process done, ret: %" LOG_PUB "d", ret);
177 return ret;
178 }
179
IpcCmRegChangeListener(const char * appId,CredChangeListener * listener)180 static int32_t IpcCmRegChangeListener(const char *appId, CredChangeListener *listener)
181 {
182 return IpcCmRegChangeListenerInner(appId, listener, true);
183 }
184
IpcCmUnRegChangeListener(const char * appId)185 static int32_t IpcCmUnRegChangeListener(const char *appId)
186 {
187 LOGI("starting ...");
188 uintptr_t callCtx = 0x0;
189 int32_t ret;
190 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
191 int32_t inOutLen;
192
193 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(appId));
194 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
195 do {
196 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
197 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_UNREG_LISTENER, true);
198 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
199 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
200 DelIpcCliCallbackCtx(appId, &g_ipcCredListenerCbList);
201 ret = RemoveCallbackInfoFromList(appId, CRED_CHANGE_LISTENER);
202 } while (0);
203 DESTROY_IPC_CTX(callCtx);
204
205 LOGI("process done, ret: %" LOG_PUB "d", ret);
206 return ret;
207 }
208
IpcCmExportCredential(int32_t osAccountId,const char * credId,char ** returnData)209 static int32_t IpcCmExportCredential(int32_t osAccountId, const char *credId, char **returnData)
210 {
211 RegisterDevAuthCallbackIfNeed();
212 LOGI("starting ...");
213 uintptr_t callCtx = 0x0;
214 int32_t ret;
215 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
216 int32_t inOutLen;
217 char *outInfo = NULL;
218
219 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(credId) || returnData == NULL);
220 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
221 do {
222 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
223 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_CRED_ID, credId, HcStrlen(credId) + 1);
224 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_EXPORT_CREDENTIAL, true);
225 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
226 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
227 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
228 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_VAL, outInfo);
229 *returnData = strdup(outInfo);
230 if (*returnData == NULL) {
231 ret = HC_ERR_ALLOC_MEMORY;
232 break;
233 }
234 } while (0);
235 DESTROY_IPC_CTX(callCtx);
236 LOGI("process done, ret: %" LOG_PUB "d", ret);
237 return ret;
238 }
239
IpcCmQueryCredByParams(int32_t osAccountId,const char * requestParams,char ** returnCredList)240 static int32_t IpcCmQueryCredByParams(int32_t osAccountId, const char *requestParams, char **returnCredList)
241 {
242 LOGI("starting ...");
243 uintptr_t callCtx = 0x0;
244 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
245 char *outInfo = NULL;
246 int32_t ret;
247 int32_t inOutLen;
248
249 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(requestParams) || returnCredList == NULL);
250 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
251 do {
252 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
253 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_QUERY_PARAMS, requestParams, HcStrlen(requestParams) + 1);
254 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_QUERY_CREDENTIAL_BY_PARAMS, true);
255 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
256 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
257 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
258 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_INFO_LIST, outInfo);
259 *returnCredList = strdup(outInfo);
260 if (*returnCredList == NULL) {
261 ret = HC_ERR_ALLOC_MEMORY;
262 break;
263 }
264 } while (0);
265 DESTROY_IPC_CTX(callCtx);
266 LOGI("process done, ret: %" LOG_PUB "d", ret);
267 return ret;
268 }
269
IpcCmQueryCredInfoByCredId(int32_t osAccountId,const char * credId,char ** returnCredInfo)270 static int32_t IpcCmQueryCredInfoByCredId(int32_t osAccountId, const char *credId, char **returnCredInfo)
271 {
272 LOGI("starting ...");
273 uintptr_t callCtx = 0x0;
274 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
275 char *outInfo = NULL;
276 int32_t ret;
277 int32_t inOutLen;
278
279 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(credId) || returnCredInfo == NULL);
280 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
281 do {
282 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
283 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_CRED_ID, credId, HcStrlen(credId) + 1);
284 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_QUERY_CREDENTIAL_BY_CRED_ID, true);
285 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
286 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
287 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
288 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_INFO, outInfo);
289 *returnCredInfo = strdup(outInfo);
290 if (*returnCredInfo == NULL) {
291 ret = HC_ERR_ALLOC_MEMORY;
292 break;
293 }
294 } while (0);
295 DESTROY_IPC_CTX(callCtx);
296
297 LOGI("process done, ret: %" LOG_PUB "d", ret);
298 return ret;
299 }
300
IpcCmDeleteCredential(int32_t osAccountId,const char * credId)301 static int32_t IpcCmDeleteCredential(int32_t osAccountId, const char *credId)
302 {
303 RegisterDevAuthCallbackIfNeed();
304 LOGI("starting ...");
305 uintptr_t callCtx = 0x0;
306 int32_t ret;
307 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
308 int32_t inOutLen;
309
310 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(credId));
311 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
312 do {
313 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
314 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_CRED_ID, credId, HcStrlen(credId) + 1);
315 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_DEL_CREDENTIAL, true);
316 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
317 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
318 } while (0);
319
320 DESTROY_IPC_CTX(callCtx);
321 LOGI("process done, ret: %" LOG_PUB "d", ret);
322 return ret;
323 }
324
IpcCmUpdateCredInfo(int32_t osAccountId,const char * credId,const char * requestParams)325 static int32_t IpcCmUpdateCredInfo(int32_t osAccountId, const char *credId, const char *requestParams)
326 {
327 RegisterDevAuthCallbackIfNeed();
328 LOGI("starting ...");
329 uintptr_t callCtx = 0x0;
330 int32_t ret;
331 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
332 int32_t inOutLen;
333
334 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(credId) || IsStrInvalid(requestParams));
335 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
336 do {
337 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
338 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_CRED_ID, credId, HcStrlen(credId) + 1);
339 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQUEST_PARAMS, requestParams, HcStrlen(requestParams) + 1);
340 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_UPDATE_CRED_INFO, true);
341 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
342 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
343 } while (0);
344
345 DESTROY_IPC_CTX(callCtx);
346 LOGI("process done, ret: %" LOG_PUB "d", ret);
347 return ret;
348 }
349
IpcCmAgreeCredential(int32_t osAccountId,const char * selfCredId,const char * requestParams,char ** returnData)350 static int32_t IpcCmAgreeCredential(int32_t osAccountId, const char *selfCredId, const char *requestParams,
351 char **returnData)
352 {
353 RegisterDevAuthCallbackIfNeed();
354 LOGI("starting ...");
355 uintptr_t callCtx = 0x0;
356 int32_t ret;
357 char *outInfo = NULL;
358 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
359 int32_t inOutLen;
360
361 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(selfCredId) ||
362 IsStrInvalid(requestParams) || returnData == NULL);
363 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
364 do {
365 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
366 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_CRED_ID, selfCredId, HcStrlen(selfCredId) + 1);
367 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQUEST_PARAMS, requestParams, HcStrlen(requestParams) + 1);
368 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_AGREE_CREDENTIAL, true);
369 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
370 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
371 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
372 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_ID, outInfo);
373 *returnData = strdup(outInfo);
374 if (*returnData == NULL) {
375 ret = HC_ERR_ALLOC_MEMORY;
376 break;
377 }
378 } while (0);
379 DESTROY_IPC_CTX(callCtx);
380
381 LOGI("process done, ret: %" LOG_PUB "d", ret);
382 return ret;
383 }
384
IpcCmDelCredByParams(int32_t osAccountId,const char * requestParams,char ** returnData)385 static int32_t IpcCmDelCredByParams(int32_t osAccountId, const char *requestParams, char **returnData)
386 {
387 RegisterDevAuthCallbackIfNeed();
388 LOGI("starting ...");
389 uintptr_t callCtx = 0x0;
390 int32_t ret;
391 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
392 char *outInfo = NULL;
393 int32_t inOutLen;
394
395 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(requestParams) || returnData == NULL);
396 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
397 do {
398 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
399 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQUEST_PARAMS, requestParams, HcStrlen(requestParams) + 1);
400 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_DEL_CRED_BY_PARAMS, true);
401 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
402 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
403 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
404 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_INFO_LIST, outInfo);
405 *returnData = strdup(outInfo);
406 if (*returnData == NULL) {
407 ret = HC_ERR_ALLOC_MEMORY;
408 break;
409 }
410 } while (0);
411 DESTROY_IPC_CTX(callCtx);
412
413 LOGI("process done, ret: %" LOG_PUB "d", ret);
414 return ret;
415 }
416
IpcCmBatchUpdateCredentials(int32_t osAccountId,const char * requestParams,char ** returnData)417 static int32_t IpcCmBatchUpdateCredentials(int32_t osAccountId, const char *requestParams, char **returnData)
418 {
419 RegisterDevAuthCallbackIfNeed();
420 LOGI("starting ...");
421 uintptr_t callCtx = 0x0;
422 int32_t ret;
423 IpcDataInfo replyCache[IPC_DATA_CACHES_3] = { { 0 } };
424 char *outInfo = NULL;
425 int32_t inOutLen;
426
427 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(IsStrInvalid(requestParams) || returnData == NULL);
428 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
429 do {
430 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
431 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQUEST_PARAMS, requestParams, HcStrlen(requestParams) + 1);
432 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CM_BATCH_UPDATE_CREDENTIALS, true);
433 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
434 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
435 BREAK_IF_GET_IPC_RESULT_NUM_FAILED(replyCache, PARAM_TYPE_IPC_RESULT_NUM, IPC_RESULT_NUM_1);
436 BREAK_IF_GET_IPC_REPLY_STR_FAILED(replyCache, PARAM_TYPE_CRED_INFO_LIST, outInfo);
437 *returnData = strdup(outInfo);
438 if (*returnData == NULL) {
439 ret = HC_ERR_ALLOC_MEMORY;
440 break;
441 }
442 } while (0);
443 DESTROY_IPC_CTX(callCtx);
444
445 LOGI("process done, ret: %" LOG_PUB "d", ret);
446 return ret;
447 }
448
IsJsonString(const char * str)449 static bool IsJsonString(const char *str)
450 {
451 CJson *json = CreateJsonFromString(str);
452 if (json == NULL) {
453 LOGE("Input str is not json str.");
454 return false;
455 }
456 FreeJson(json);
457 return true;
458 }
459
IpcCmDestroyInfo(char ** returnData)460 static void IpcCmDestroyInfo(char **returnData)
461 {
462 if (returnData == NULL || *returnData == NULL) {
463 return;
464 }
465 if (IsJsonString(*returnData)) {
466 FreeJsonString(*returnData);
467 } else {
468 HcFree(*returnData);
469 }
470 *returnData = NULL;
471 }
472
InitIpcCmMethods(CredManager * cmMethodObj)473 static void InitIpcCmMethods(CredManager *cmMethodObj)
474 {
475 cmMethodObj->addCredential = IpcCmAddCredential;
476 cmMethodObj->exportCredential = IpcCmExportCredential;
477 cmMethodObj->registerChangeListener = IpcCmRegChangeListener;
478 cmMethodObj->unregisterChangeListener = IpcCmUnRegChangeListener;
479 cmMethodObj->queryCredentialByParams = IpcCmQueryCredByParams;
480 cmMethodObj->queryCredInfoByCredId = IpcCmQueryCredInfoByCredId;
481 cmMethodObj->deleteCredential = IpcCmDeleteCredential;
482 cmMethodObj->updateCredInfo = IpcCmUpdateCredInfo;
483 cmMethodObj->agreeCredential = IpcCmAgreeCredential;
484 cmMethodObj->deleteCredByParams = IpcCmDelCredByParams;
485 cmMethodObj->batchUpdateCredentials = IpcCmBatchUpdateCredentials;
486 cmMethodObj->destroyInfo = IpcCmDestroyInfo;
487 return;
488 }
489
IpcCmAuthCredential(int32_t osAccountId,int64_t authReqId,const char * authParams,const DeviceAuthCallback * caCallback)490 static int32_t IpcCmAuthCredential(int32_t osAccountId, int64_t authReqId, const char *authParams,
491 const DeviceAuthCallback *caCallback)
492 {
493 LOGI("starting ...");
494 uintptr_t callCtx = 0x0;
495 int32_t ret;
496 int32_t inOutLen;
497 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
498 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (caCallback == NULL)));
499 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
500 do {
501 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
502 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
503 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
504 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, caCallback, sizeof(*caCallback));
505 SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_AUTH_ID);
506 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CA_AUTH_CREDENTIAL, true);
507 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
508 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
509 } while (0);
510 DESTROY_IPC_CTX(callCtx);
511 LOGI("process done, ret: %" LOG_PUB "d", ret);
512 DestroyCallCtx(&callCtx);
513 return ret;
514 }
515
IpcCmProcessCredData(int64_t authReqId,const uint8_t * data,uint32_t dataLen,const DeviceAuthCallback * callback)516 static int32_t IpcCmProcessCredData(int64_t authReqId, const uint8_t *data, uint32_t dataLen,
517 const DeviceAuthCallback *callback)
518 {
519 LOGI("starting ...");
520 uintptr_t callCtx = 0x0;
521 int32_t ret;
522 int32_t inOutLen;
523 IpcDataInfo replyCache[IPC_DATA_CACHES_1] = { { 0 } };
524 RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(!IS_COMM_DATA_VALID(data, dataLen) || (callback == NULL));
525 RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
526 do {
527 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
528 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
529 BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
530 SetCbCtxToDataCtx(callCtx, 0x0);
531 BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CA_PROCESS_CRED_DATA, true);
532 DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
533 BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
534 } while (0);
535 DESTROY_IPC_CTX(callCtx);
536 LOGI("process done, ret: %" LOG_PUB "d", ret);
537 return ret;
538 }
539
InitIpcCaMethods(CredAuthManager * caMethodObj)540 static void InitIpcCaMethods(CredAuthManager *caMethodObj)
541 {
542 caMethodObj->authCredential = IpcCmAuthCredential;
543 caMethodObj->processCredData = IpcCmProcessCredData;
544 return;
545 }
546
InitISIpc(void)547 int32_t InitISIpc(void)
548 {
549 int32_t ret = InitHcMutex(&g_ipcMutex, false);
550 if (ret != IS_SUCCESS) {
551 return ret;
552 }
553 SetRegCredChangeListenerFunc(IpcCmRegChangeListenerInner);
554 return IS_SUCCESS;
555 }
556
DeInitISIpc(void)557 void DeInitISIpc(void)
558 {
559 DestroyHcMutex(&g_ipcMutex);
560 }
561
GetCredMgrInstance(void)562 DEVICE_AUTH_API_PUBLIC const CredManager *GetCredMgrInstance(void)
563 {
564 static CredManager cmInstCtx;
565 static CredManager *cmInstPtr = NULL;
566
567 if (cmInstPtr == NULL) {
568 InitIpcCmMethods(&cmInstCtx);
569 cmInstPtr = &cmInstCtx;
570 }
571 return (const CredManager *)(cmInstPtr);
572 }
573
GetCredAuthInstance(void)574 DEVICE_AUTH_API_PUBLIC const CredAuthManager *GetCredAuthInstance(void)
575 {
576 static CredAuthManager caInstCtx;
577 static CredAuthManager *caInstPtr = NULL;
578
579 if (caInstPtr == NULL) {
580 InitIpcCaMethods(&caInstCtx);
581 caInstPtr = &caInstCtx;
582 }
583 return (const CredAuthManager *)(caInstPtr);
584 }
585
586 #ifdef __cplusplus
587 }
588 #endif
589