Skip to content

X
Xts Acts

OpenHarmony / Xts Acts
1 年多 前同步成功

通知 9
Star 22
Fork 0
X
Xts Acts
提交 051d29ce 编写于 作者: H hu-jixiang1
1 浏览文件
操作

hujixiang1@huawei.com 

Signed-off-by: Nhu-jixiang1 <hujixiang1@huawei.com>
Change-Id: I5275ed23cc936ce3432264b2c99472a2d5c69549
上级 3af7a0fc
隐藏空白更改
内联 并排
Showing with 22 addition and 4232 deletion
security_lite/hichain_posix0/BUILD.gn 已删除 100644 → 0
浏览文件 @ 3af7a0fc
# Copyright (c) 2020-2021 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import("//test/xts/tools/lite/build/suite_lite.gni")
hctest_suite("ActsSecurityHichainTest0") {
suite_name = "acts"
defines = [ "HILINE_E2E_SECURITY_CONFIG" ]
sources = [
"src/hichain_function_test.c",
# "src/hichain_huks_adapt.c",
]
include_dirs = [
"//base/security/huks/interfaces/innerkits/huks_lite/",
"//third_party/cJSON",
"//base/security/deviceauth/interfaces/innerkits/deviceauth_lite",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/huks_adapter",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/base",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/json",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/key_agreement",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/log",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/schedule",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/struct",
"//base/security/deviceauth/frameworks/deviceauth_lite/source/auth_info",
"//third_party/bounds_checking_function/include",
"//kernel/liteos_a/test/kernel/sample/lwip2.0_linux_CI/dependency/include",
"dbg_code",
"gtest",
"//base/security/huks/interfaces/innerkits/huks_lite/",
]
cflags = [ "-Wno-error" ]
}
security_lite/hichain_posix0/Test.json 已删除 100644 → 0
浏览文件 @ 3af7a0fc
{
"description": "Config for hcpptest demo test cases",
"environment": [
{
"type": "device",
"label": "ipcamera"
}
],
"kits": [
{
"type": "MountKit",
"server": "NfsServer",
"mount": [
{
"source": "testcases/security",
"target": "/test_root/security"
}
]
}
],
"driver": {
"type": "CppTestLite",
"execute": "/test_root/security/ActsSecurityHichainTest.bin"
}
}
\ No newline at end of file
security_lite/hichain_posix0/Test.tmpl 已删除 100644 → 0
浏览文件 @ 3af7a0fc
{
"description": "Config for $module test cases",
"environment": [
{
"type": "device",
"label": "wifiiot"
}
],
"kits": [
{
"type": "DeployKit",
"timeout": "20000",
"burn_file": "$subsystem/$module.bin"
}
],
"driver": {
"type": "CTestLite"
}
}
\ No newline at end of file
security_lite/hichain_posix0/device_auth.h 已删除 100644 → 0
浏览文件 @ 3af7a0fc
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DEVICE_AUTH_H
#define DEVICE_AUTH_H
#include <stdint.h>
#include <stdbool.h>
#if defined(_LINUX) || defined(_UNIX)
#define DEVICE_AUTH_API_PUBLIC __attribute__ ((visibility("default")))
#else
#define DEVICE_AUTH_API_PUBLIC
#endif
#define FIELD_GROUP_ID "groupId"
#define FIELD_GROUP_TYPE "groupType"
#define FIELD_GROUP_NAME "groupName"
#define FIELD_PEER_DEVICE_ID "peerDeviceId"
#define FIELD_IS_ADMIN "isAdmin"
#define FIELD_CREDENTIAL_TYPE "credentialType"
#define FIELD_IS_FORCE_DELETE "isForceDelete"
#define FIELD_IS_IGNORE_CHANNEL "isIgnoreChannel"
#define FIELD_CONNECT_PARAMS "connectParams"
#define FIELD_ADD_ID "addId"
#define FIELD_DELETE_ID "deleteId"
#define FIELD_APP_ID "appId"
#define FIELD_SERVICE_TYPE "serviceType"
#define FIELD_PEER_AUTH_STATE "peerAuthState"
#define FIELD_IS_DEVICE_LEVEL "isDeviceLevel"
#define FIELD_ALTERNATIVE "alternative"
#define FIELD_PEER_UDID "peerUdid"
#define FIELD_PEER_CONN_DEVICE_ID "peerConnDeviceId"
#define FIELD_KEY_LENGTH "keyLength"
#define FIELD_IS_CLIENT "isClient"
#define FIELD_SESSION_KEY "sessionKey"
#define FIELD_AUTH_FORM "authForm"
#define FIELD_CONFIRMATION "confirmation"
#define FIELD_GROUP_OWNER "groupOwner"
#define FIELD_PEER_AUTH_ID "peerAuthId"
#define FIELD_PEER_USER_TYPE "peerUserType"
#define FIELD_PEER_USER_ID "peerUserId"
#define FIELD_SERVICE_PKG_NAME "servicePkgName"
#define FIELD_USER_TYPE "userType"
#define FIELD_USER_ID "userId"
#define FIELD_DEVICE_ID "deviceId"
#define FIELD_UID_HASH "uidHash"
#define FIELD_PIN_CODE "pinCode"
#define FIELD_AUTH_ID "authId"
#define FIELD_GROUP_VISIBILITY "groupVisibility"
#define FIELD_EXPIRE_TIME "expireTime"
#define FIELD_IS_DELETE_ALL "isDeleteAll"
typedef enum {
GROUP_CREATE = 0,
GROUP_DISBAND = 1,
MEMBER_INVITE = 2,
MEMBER_JOIN = 3,
MEMBER_DELETE = 4,
ACCOUNT_BIND = 5
} GroupOperationCode;
typedef enum {
CREDENTIAL_SAVE = 0,
CREDENTIAL_CLEAR = 1,
CREDENTIAL_UPDATE = 2,
CREDENTIAL_QUERY = 3,
} CredentialCode;
typedef enum {
DEVICE_TYPE_ACCESSORY = 0,
DEVICE_TYPE_CONTROLLER = 1,
DEVICE_TYPE_PROXY = 2
} UserType;
#define REQUEST_REJECTED 0x80000005
#define REQUEST_ACCEPTED 0x80000006
#define REQUEST_WAITING 0x80000007
typedef struct {
void (*onGroupCreated)(const char *groupInfo);
void (*onGroupDeleted)(const char *groupInfo);
void (*onDeviceBound)(const char *peerUdid, const char *groupInfo);
void (*onDeviceUnBound)(const char *peerUdid, const char *groupInfo);
void (*onDeviceNotTrusted)(const char *peerUdid);
void (*onLastGroupDeleted)(const char *peerUdid, int groupType);
void (*onTrustedDeviceNumChanged)(int curTrustedDeviceNum);
} DataChangeListener;
typedef struct {
bool (*onTransmit)(int64_t requestId, const uint8_t *data, uint32_t dataLen);
void (*onSessionKeyReturned)(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen);
void (*onFinish)(int64_t requestId, int operationCode, const char *returnData);
void (*onError)(int64_t requestId, int operationCode, int errorCode, const char *errorReturn);
char *(*onRequest)(int64_t requestId, int operationCode, const char *reqParams);
} DeviceAuthCallback;
typedef struct {
int32_t (*processData)(int64_t authReqId, const uint8_t *data, uint32_t dataLen,
const DeviceAuthCallback *gaCallback);
int32_t (*queryTrustedDeviceNum)(void);
bool (*isTrustedDevice)(const char *udid);
int32_t (*getAuthState)(int64_t authReqId, const char *groupId, const char *peerUdid,
uint8_t *out, uint32_t *outLen);
int32_t (*authDevice)(int64_t authReqId, const char *authParams, const DeviceAuthCallback *gaCallback);
void (*informDeviceDisconnection)(const char *udid);
} GroupAuthManager;
typedef struct {
int32_t (*regCallback)(const char *appId, const DeviceAuthCallback *callback);
int32_t (*unRegCallback)(const char *appId);
int32_t (*regDataChangeListener)(const char *appId, const DataChangeListener *listener);
int32_t (*unRegDataChangeListener)(const char *appId);
int32_t (*createGroup)(int64_t requestId, const char *appId, const char *createParams);
int32_t (*deleteGroup)(int64_t requestId, const char *appId, const char *disbandParams);
int32_t (*addMemberToGroup)(int64_t requestId, const char *appId, const char *addParams);
int32_t (*deleteMemberFromGroup)(int64_t requestId, const char *appId, const char *deleteParams);
int32_t (*processData)(int64_t requestId, const uint8_t *data, uint32_t dataLen);
int32_t (*confirmRequest)(int64_t requestId, const char *appId, const char *confirmParams);
int32_t (*bindPeer)(int64_t requestId, const char *appId, const char *bindParams);
int32_t (*unbindPeer)(int64_t requestId, const char *appId, const char *unBindParams);
int32_t (*processLiteData)(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen);
int32_t (*authKeyAgree)(int64_t requestId, const char *appId, const char *buildParams);
int32_t (*processKeyAgreeData)(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen);
int32_t (*processCredential)(int operationCode, const char *reqJsonStr, char **returnJsonStr);
int32_t (*getRegisterInfo)(char **returnRegisterInfo);
int32_t (*getLocalConnectInfo)(char **returnInfo);
int32_t (*addGroupManager)(const char *appId, const char *groupId, const char *managerAppId);
int32_t (*addGroupFriend)(const char *appId, const char *groupId, const char *friendAppId);
int32_t (*deleteGroupManager)(const char *appId, const char *groupId, const char *managerAppId);
int32_t (*deleteGroupFriend)(const char *appId, const char *groupId, const char *friendAppId);
int32_t (*getGroupManagers)(const char *appId, const char *groupId, char **returnManagers, uint32_t *returnSize);
int32_t (*getGroupFriends)(const char *appId, const char *groupId, char **returnFriends, uint32_t *returnSize);
int32_t (*getGroupInfoById)(const char *appId, const char *groupId, char **returnGroupInfo);
int32_t (*getGroupInfo)(const char *appId, const char *queryParams, char **returnGroupVec, uint32_t *groupNum);
int32_t (*getJoinedGroups)(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum);
int32_t (*getRelatedGroups)(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum);
int32_t (*getDeviceInfoById)(const char *appId, const char *deviceId, const char *groupId, char **returnDeviceInfo);
int32_t (*getTrustedDevices)(const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum);
bool (*isDeviceInGroup)(const char *appId, const char *groupId, const char *deviceId);
void (*destroyInfo)(char **returnInfo);
} DeviceGroupManager;
#ifdef __cplusplus
extern "C" {
#endif
DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService();
DEVICE_AUTH_API_PUBLIC void DestroyDeviceAuthService();
DEVICE_AUTH_API_PUBLIC const GroupAuthManager *GetGaInstance();
DEVICE_AUTH_API_PUBLIC const DeviceGroupManager *GetGmInstance();
#ifdef __cplusplus
}
#endif
#endif
security_lite/hichain_posix0/device_auth_defines.h 已删除 100644 → 0
浏览文件 @ 3af7a0fc
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DEVICE_AUTH_DEFINES_H
#define DEVICE_AUTH_DEFINES_H
#define HC_GROUP_FRIEND_MAX_NUM 100 /* Visibility is 1, friend list is available, and max is 100 */
#define HC_GROUP_MANAGER_MAX_NUM 10 /* manager max number is 10, it includes owner and other managers */
enum {
/* common error code, 0x00000000 ~ 0x00000FFF */
HC_SUCCESS = 0x00000000,
HC_ERROR = 0x00000001,
HC_ERR_INVALID_PARAMS = 0x00000002,
HC_ERR_INVALID_LEN = 0x00000003,
HC_ERR_NULL_PTR = 0x00000004,
HC_ERR_ALLOC_MEMORY = 0x00000005,
HC_ERR_MEMORY_COPY = 0x00000006,
HC_HEX_CONVERT_FAILED = 0x00000007,
HC_ERR_NOT_SUPPORT = 0x00000008,
HC_ERR_TIME_OUT = 0x00000009,
HC_ERR_CASE = 0x0000000A,
HC_ERR_BAD_TIMING = 0x0000000B,
HC_ERR_PEER_ERROR = 0x0000000C,
/* error code for huks adapter , 0x00001000 ~ 0x00001FFF */
HC_ERR_KEY_NOT_EXIST = 0x00001001,
HC_ERR_GENERATE_KEY_FAILED = 0x000010002,
HC_ERR_INVALID_PUBLIC_KEY = 0x00001003,
HC_ERR_VERIFY_FAILED = 0x00001004,
HC_ERR_HASH_FAIL = 0x00001005,
/* error code for json util , 0x00002000 ~ 0x00002FFF */
HC_ERR_JSON_FAIL = 0x00002001,
HC_ERR_JSON_CREATE = 0x00002002,
HC_ERR_JSON_GET = 0x00002003,
HC_ERR_JSON_ADD = 0x00002004,
HC_ERR_PACKAGE_JSON_TO_STRING_FAIL = 0x00002005,
/* error code for ipc, 0x00003000 ~ 0x00003FFF */
HC_ERR_IPC_INTERNAL_FAILED = 0x00003001,
HC_ERR_IPC_UNKNOW_OPCODE = 0x00003002,
HC_ERR_IPC_CALL_DATA_LENGTH = 0x00003003,
HC_ERR_IPC_METHOD_ID_INVALID = 0x00003004,
HC_ERR_IPC_BAD_MESSAGE_LENGTH = 0x00003005,
HC_ERR_IPC_BAD_VAL_LENGTH = 0x00003006,
HC_ERR_IPC_BAD_PARAM_NUM = 0x00003007,
HC_ERR_IPC_BAD_MSG_TYPE = 0x00003008,
HC_ERR_IPC_GET_SERVICE = 0x00003009,
HC_ERR_IPC_GET_PROXY = 0x0000300A,
HC_ERR_IPC_INIT = 0x0000300B,
HC_ERR_IPC_BUILD_PARAM = 0x0000300C,
HC_ERR_IPC_PROC_FAILED = 0x0000300D,
HC_ERR_IPC_UNKNOW_REPLAY = 0x0000300E,
HC_ERR_IPC_OUT_DATA_NUM = 0x0000300F,
HC_ERR_IPC_OUT_DATA = 0x00003010,
/* error code for module , 0x00004000 ~ 0x00004FFF */
HC_ERR_MODULE_NOT_FOUNT = 0x00004001,
HC_ERR_UNSUPPORTED_METHOD = 0x00004002,
HC_ERR_UNSUPPORTED_VERSION = 0x00004003,
HC_ERR_UNSUPPORTED_CURVE = 0x00004004,
HC_ERR_BAD_MESSAGE = 0x00004005,
HC_ERR_PROOF_NOT_MATCH = 0x00004006,
HC_ERR_INIT_TASK_FAIL = 0x00004007,
HC_ERR_TASK_IS_NULL = 0x00004008,
HC_ERR_TASK_ID_IS_NOT_MATCH = 0x00004009,
HC_ERR_INVALID_ALG = 0x0000400A,
HC_ERR_IGNORE_MSG = 0x0000400B,
HC_ERR_LOCAL_IDENTITY_NOT_EXIST = 0x0000400C,
/* error code for group , 0x00005000 ~ 0x00005FFF */
HC_ERR_ACCESS_DENIED = 0x00005001,
HC_ERR_CALLBACK_NOT_FOUND = 0x00005002,
HC_ERR_SERVICE_NEED_RESTART = 0x00005003,
HC_ERR_NO_CANDIDATE_GROUP = 0x00005004,
HC_ERR_TRANSMIT_FAIL = 0x00005005,
HC_ERR_REQUEST_EXIST = 0x00005006,
HC_ERR_REQUEST_NOT_FOUND = 0x00005007,
HC_ERR_SESSION_NOT_EXIST = 0x00005008,
HC_ERR_SESSION_ID_CONFLICT = 0x00005009,
HC_ERR_REQ_REJECTED = 0x0000500A,
HC_ERR_SERVER_CONFIRM_FAIL = 0x0000500B,
HC_ERR_CREATE_SESSION_FAIL = 0x0000500C,
HC_ERR_SESSION_IS_FULL = 0x0000500D,
/* error code for database , 0x00006000 ~ 0x00006FFF */
HC_ERR_DB = 0x00006001,
HC_ERR_BEYOND_LIMIT = 0x00006002,
HC_ERR_SAVE_DB_FAILED = 0x00006003,
HC_ERR_FRIEND_NOT_EXIST = 0x00006004,
HC_ERR_MANAGER_NOT_EXIST = 0x00006005,
HC_ERR_GROUP_DUPLICATE = 0x00006006,
HC_ERR_GROUP_NOT_EXIST = 0x00006007,
HC_ERR_DEVICE_NOT_EXIST = 0x00006008,
HC_ERR_DEVICE_DUPLICATE = 0x00006009,
HC_ERR_LOST_DATA = 0x0000600A,
/* error code for broadcast , 0x00007000 ~ 0x00007FFF */
HC_ERR_LISTENER_NOT_EXIST = 0x000070012,
/* error code for channel , 0x00008000 ~ 0x00008FFF */
HC_ERR_CHANNEL_NOT_EXIST = 0x000080012,
HC_ERR_SOFT_BUS = 0x00008002,
/* error code used on DAS service */
INVALID_PARAMETERS = 0xF0000001,
EXCEED_AUTHORITY = 0xF0000002,
TIMEOUT = 0xF0000003,
NOT_REGISTERED = 0xF0000004,
NOT_TRUST_PEER = 0xF0000005,
NOT_TRUST_CONTROLLER = 0xF0000006,
NOT_TRUST_ACCESSORY = 0xF0000007,
OVER_MAX_TRUST_NUM = 0xF0000008,
CONNECTION_INTERRUPTED = 0xF0000009,
UNSUPPORTED_VERSION = 0xF000000A,
BAD_PAYLOAD = 0xF000000B,
ALGORITHM_UNSUPPORTED = 0xF000000C,
PROOF_MISMATCH = 0xF000000D,
UNKOWN = 0xF0000000,
};
#endif
security_lite/hichain_posix0/ipc_sdk.c 已删除 100644 → 0
浏览文件 @ 3af7a0fc
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ipc_sdk.h"
#include "common_defs.h"
#include "device_auth_defines.h"
#include "device_auth.h"
#include "hc_log.h"
#include "hc_mutex.h"
#include "ipc_adapt.h"
#include "securec.h"
#ifdef __cplusplus
extern "C" {
#endif
#define IPC_DATA_CACHES_3 3
#define IPC_DATA_CACHES_4 4
#define REPLAY_CACHE_NUM(caches) (sizeof(caches) / sizeof(IpcDataInfo))
#define IPC_APPID_LEN 128
#define IS_STRING_VALID(str) (((str) != NULL) && ((str)[0] != 0))
#define IS_COMM_DATA_VALID(dPtr, dLen) (((dPtr) != NULL) && ((dLen) > 0) && ((dLen) <= 4096))
typedef struct {
uintptr_t inst;
char appId[IPC_APPID_LEN];
} IpcProxyCbInfo;
static IpcProxyCbInfo g_ipcProxyCbList = {0};
static IpcProxyCbInfo g_ipcListenerCbList = {0};
static HcMutex g_ipcMutex;
static void DelIpcCliCallbackCtx(const char *appId, IpcProxyCbInfo *cbCache)
{
int32_t ret;
if (cbCache->appId[0] == 0) {
return;
}
g_ipcMutex.lock(&g_ipcMutex);
ret = memcmp(appId, cbCache->appId, strlen(cbCache->appId) + 1);
if (ret == 0) {
cbCache->appId[0] = 0;
}
g_ipcMutex.unlock(&g_ipcMutex);
return;
}
static void AddIpcCliCallbackCtx(const char *appId, uintptr_t cbInst, IpcProxyCbInfo *cbCache)
{
errno_t eno;
LOGI("starting ...");
g_ipcMutex.lock(&g_ipcMutex);
eno = memcpy_s(cbCache->appId, IPC_APPID_LEN, appId, strlen(appId) + 1);
if (eno != EOK) {
g_ipcMutex.unlock(&g_ipcMutex);
LOGE("memory copy failed");
return;
}
cbCache->inst = cbInst;
g_ipcMutex.unlock(&g_ipcMutex);
LOGI("success, appid: %s", appId);
return;
}
static void GetIpcReplyByType(const IpcDataInfo *ipcData,
int32_t dataNum, int32_t type, uint8_t *outCache, int32_t *cacheLen)
{
int32_t i;
int32_t ret = HC_ERR_IPC_BAD_MSG_TYPE;
errno_t eno;
LOGI("type %d", type);
for (i = 0; i < dataNum; i++) {
if (ipcData[i].type != type) {
continue;
}
ret = HC_SUCCESS;
switch (type) {
case PARAM_TYPE_REG_INFO:
case PARAM_TYPE_MGR_APPID:
case PARAM_TYPE_FRIEND_APPID:
case PARAM_TYPE_DEVICE_INFO:
case PARAM_TYPE_GROUP_INFO:
*(uint8_t **)outCache = ipcData[i].val;
if (cacheLen != NULL) {
*cacheLen = ipcData[i].valSz;
}
break;
case PARAM_TYPE_IPC_RESULT:
case PARAM_TYPE_IPC_RESULT_NUM:
case PARAM_TYPE_COMM_DATA:
case PARAM_TYPE_DATA_NUM:
eno = memcpy_s(outCache, *cacheLen, ipcData[i].val, ipcData[i].valSz);
if (eno != EOK) {
ret = HC_ERR_MEMORY_COPY;
break;
}
*cacheLen = ipcData[i].valSz;
break;
default:
ret = HC_ERR_IPC_BAD_MSG_TYPE;
LOGE("un-expectation type case");
break;
}
}
LOGI("process done, type %d, result %d", type, ret);
return;
}
static int32_t IpcGmRegCallback(const char *appId, const DeviceAuthCallback *callback)
{
uintptr_t callCtx = 0x0;
int32_t ret;
LOGI("starting ...");
if (!IS_STRING_VALID(appId)) {
LOGE("invalid params");
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
ret = DoBinderCall(callCtx, IPC_CALL_ID_REG_CB, true);
if (ret == HC_SUCCESS) {
AddIpcCliCallbackCtx(appId, 0, &g_ipcProxyCbList);
}
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return (ret == HC_SUCCESS) ? HC_SUCCESS : HC_ERR_IPC_PROC_FAILED;
}
static int32_t IpcGmUnRegCallback(const char *appId)
{
uintptr_t callCtx = 0x0;
int32_t ret;
LOGI("starting ...");
if (!IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_UNREG_CB, true);
if (ret == HC_SUCCESS) {
DelIpcCliCallbackCtx(appId, &g_ipcProxyCbList);
}
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", HC_SUCCESS);
return HC_SUCCESS;
}
static int32_t IpcGmRegDataChangeListener(const char *appId, const DataChangeListener *listener)
{
uintptr_t callCtx = 0x0;
int32_t ret;
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || (listener == NULL)) {
LOGE("invalid params");
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_LISTERNER, (const uint8_t *)listener, sizeof(*listener));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_LISTERNER);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
ret = DoBinderCall(callCtx, IPC_CALL_ID_REG_LISTENER, true);
if (ret == HC_SUCCESS) {
AddIpcCliCallbackCtx(appId, 0, &g_ipcListenerCbList);
}
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return (ret == HC_SUCCESS) ? HC_SUCCESS : HC_ERR_IPC_PROC_FAILED;
}
static int32_t IpcGmUnRegDataChangeListener(const char *appId)
{
uintptr_t callCtx = 0x0;
int32_t ret;
LOGI("starting ...");
if (!IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_UNREG_LISTENER, true);
if (ret == HC_SUCCESS) {
DelIpcCliCallbackCtx(appId, &g_ipcListenerCbList);
}
DestroyCallCtx(&callCtx, NULL);
LOGI("process done");
return HC_SUCCESS;
}
static int32_t IpcGmCreateGroup(int64_t requestId, const char *appid, const char *createParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(createParams) || !IS_STRING_VALID(appid)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appid, strlen(appid) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_CREATE_PARAMS,
(const uint8_t *)createParams, strlen(createParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_CREATE_PARAMS);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_CREATE_GROUP, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmDelGroup(int64_t requestId, const char *appId, const char *delParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(delParams) || !IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEL_PARAMS, (const uint8_t *)delParams, strlen(delParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_DEL_PARAMS);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_GROUP, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmAddMemberToGroup(int64_t requestId, const char *appId, const char *addParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(addParams)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_ADD_PARAMS, (const uint8_t *)addParams, strlen(addParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_ADD_PARAMS);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_ADD_GROUP_MEMBER, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmDelMemberFromGroup(int64_t requestId, const char *appId, const char *delParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(delParams)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEL_PARAMS, (const uint8_t *)delParams, strlen(delParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_DEL_PARAMS);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_GROUP_MEMBER, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmProcessData(int64_t requestId, const uint8_t *data, uint32_t dataLen)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_COMM_DATA_VALID(data, dataLen)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_COMM_DATA);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GM_PROC_DATA, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmConfirmRequest(int64_t requestId, const char *appId, const char *cfmParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(cfmParams)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQ_CFM, (const uint8_t *)cfmParams, strlen(cfmParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQ_CFM);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_CFM_REQUEST, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmBindPeer(int64_t requestId, const char *appId, const char *bindParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(bindParams)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_BIND, (const uint8_t *)bindParams, strlen(bindParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_BIND);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_BIND_PEER, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmUnBindPeer(int64_t requestId, const char *appId, const char *unBindParams)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(unBindParams)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UNBIND, (const uint8_t *)unBindParams, strlen(unBindParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UNBIND);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_UNBIND_PEER, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmProcessLiteData(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_COMM_DATA_VALID(data, dataLen) || !IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&requestId), sizeof(requestId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_COMM_DATA);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_PROC_LIGHT_DATA, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmProcCredential(int32_t operationCode, const char *credential, char **returnJsonStr)
{
LOGI("starting ...");
(void)operationCode;
if (!IS_STRING_VALID(credential) || (returnJsonStr == NULL)) {
LOGE("The input groupType is invalid or credential is NULL!");
return HC_ERR_INVALID_PARAMS;
}
return HC_ERR_NOT_SUPPORT;
}
static int32_t IpcGmGetRegisterInfo(char **registerInfo)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_3] = {{0}};
char *outInfo = NULL;
LOGI("starting ...");
if (registerInfo == NULL) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_APPLY_REG_INFO, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int32_t))) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_1) || (inOutLen != sizeof(int32_t))) {
LOGE("done, ret %d", HC_ERR_IPC_OUT_DATA_NUM);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_REG_INFO, (uint8_t *)&outInfo, NULL);
if ((outInfo == NULL) || (strlen(outInfo) == 0)) {
LOGE("done, ret %d", HC_ERR_IPC_OUT_DATA);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_OUT_DATA;
}
*registerInfo = strdup(outInfo);
DestroyCallCtx(&callCtx, NULL);
return (*registerInfo != NULL) ? HC_SUCCESS : HC_ERR_NULL_PTR;
}
static int32_t IpcGmGetLocalConnectInfo(char **outLocalConnInfo)
{
LOGI("starting ...");
if (outLocalConnInfo == NULL) {
return HC_ERR_INVALID_PARAMS;
}
return HC_ERR_NOT_SUPPORT;
}
static int32_t IpcGmAddGroupManager(const char *appId, const char *groupId, const char *managerAppId)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(groupId) || !IS_STRING_VALID(managerAppId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_MGR_APPID,
(const uint8_t *)managerAppId, strlen(managerAppId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_MGR_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_ADD_GROUP_MGR, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmAddGroupFriend(const char *appId, const char *groupId, const char *friendAppId)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(groupId) || !IS_STRING_VALID(friendAppId) || !IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_FRIEND_APPID,
(const uint8_t *)friendAppId, strlen(friendAppId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_FRIEND_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_ADD_GROUP_FRIEND, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmDelGroupManager(const char *appId, const char *groupId, const char *managerAppId)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(groupId) || !IS_STRING_VALID(managerAppId) || !IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_MGR_APPID,
(const uint8_t *)managerAppId, strlen(managerAppId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_MGR_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_GROUP_MGR, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t IpcGmDelGroupFriend(const char *appId, const char *groupId, const char *friendAppId)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(groupId) || !IS_STRING_VALID(friendAppId) || !IS_STRING_VALID(appId)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_FRIEND_APPID,
(const uint8_t *)friendAppId, strlen(friendAppId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_FRIEND_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_DEL_GROUP_FRIEND, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
DestroyCallCtx(&callCtx, NULL);
LOGI("process done, ret %d", ret);
return ret;
}
static int32_t GetGroupManagersIpcResult(const IpcDataInfo *replies, int32_t cacheNum,
char **outManagers, uint32_t *outSize)
{
int32_t inOutLen;
int32_t ret;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_MGR_APPID, (uint8_t *)outManagers, NULL);
if ((*outManagers == NULL) || (strlen(*outManagers) == 0)) {
return HC_ERR_IPC_OUT_DATA;
}
*outManagers = strdup(*outManagers);
if (*outManagers == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)outSize, &inOutLen);
return HC_SUCCESS;
}
static int32_t IpcGmGetGroupManagers(const char *appId, const char *groupId, char **outManagers, uint32_t *outSize)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(groupId) || !IS_STRING_VALID(appId) || (outManagers == NULL) || (outSize == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_GROUP_MGR, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = GetGroupManagersIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outManagers, outSize);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t GetGroupFriendsIpcResult(const IpcDataInfo *replies,
int32_t cacheNum, char **outFriends, uint32_t *outSize)
{
int32_t inOutLen;
int32_t ret;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_FRIEND_APPID, (uint8_t *)outFriends, NULL);
if ((*outFriends == NULL) || (strlen(*outFriends) == 0)) {
return HC_ERR_IPC_OUT_DATA;
}
*outFriends = strdup(*outFriends);
if (*outFriends == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)outSize, &inOutLen);
return HC_SUCCESS;
}
static int32_t IpcGmGetGroupFriends(const char *appId, const char *groupId, char **outFriends, uint32_t *outSize)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(groupId) || !IS_STRING_VALID(appId) || (outFriends == NULL) || (outSize == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_GROUP_FRIEND, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = GetGroupFriendsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outFriends, outSize);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t GroupInfoIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outGroupInfo)
{
int32_t inOutLen;
int32_t ret;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_1) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupInfo, NULL);
if (*outGroupInfo == NULL) {
return HC_ERR_IPC_OUT_DATA;
}
*outGroupInfo = strdup(*outGroupInfo);
if (*outGroupInfo == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
return HC_SUCCESS;
}
static int32_t IpcGmGetGroupInfoById(const char *appId, const char *groupId, char **outGroupInfo)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_3] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(groupId) || !IS_STRING_VALID(appId) || (outGroupInfo == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_GROUP_INFO, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = GroupInfoIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupInfo);
DestroyCallCtx(&callCtx, NULL);
LOGI("proc result done, ret %d", ret);
return ret;
}
static int32_t SearchGroupsIpcResult(const IpcDataInfo *replies,
int32_t cacheNum, char **outGroupVec, uint32_t *groupNum)
{
int32_t ret;
int32_t inOutLen;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupVec, NULL);
if (*outGroupVec == NULL) {
return HC_ERR_IPC_OUT_DATA;
}
*outGroupVec = strdup(*outGroupVec);
if (*outGroupVec == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)groupNum, &inOutLen);
return HC_SUCCESS;
}
static int32_t IpcGmGetGroupInfo(const char *appId, const char *queryParams, char **outGroupVec, uint32_t *groupNum)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(queryParams) || !IS_STRING_VALID(appId) || (outGroupVec == NULL) || (groupNum == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_QUERY_PARAMS,
(const uint8_t *)queryParams, strlen(queryParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_QUERY_PARAMS);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_SEARCH_GROUPS, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = SearchGroupsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupVec, groupNum);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t JoinedGroupsIpcResult(const IpcDataInfo *replies,
int32_t cacheNum, char **outGroupVec, uint32_t *groupNum)
{
int32_t ret;
int32_t inOutLen;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupVec, NULL);
if (*outGroupVec == NULL) {
return HC_ERR_IPC_OUT_DATA;
}
*outGroupVec = strdup(*outGroupVec);
if (*outGroupVec == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)groupNum, &inOutLen);
return HC_SUCCESS;
}
static int32_t IpcGmGetJoinedGroups(const char *appId, int32_t groupType, char **outGroupVec, uint32_t *groupNum)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || (outGroupVec == NULL) ||
(groupNum == NULL) || (groupType != ACROSS_ACCOUNT_AUTHORIZE_GROUP)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUP_TYPE, (const uint8_t *)&groupType, sizeof(groupType));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUP_TYPE);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_JOINED_GROUPS, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = JoinedGroupsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupVec, groupNum);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t RelatedGroupsIpcResult(const IpcDataInfo *replies,
int32_t cacheNum, char **outGroupVec, uint32_t *groupNum)
{
int32_t ret;
int32_t inOutLen;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_GROUP_INFO, (uint8_t *)outGroupVec, NULL);
if (*outGroupVec == NULL) {
return HC_ERR_IPC_OUT_DATA;
}
*outGroupVec = strdup(*outGroupVec);
if (*outGroupVec == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)groupNum, &inOutLen);
return HC_SUCCESS;
}
static int32_t IpcGmGetRelatedGroups(const char *appId, const char *peerUdid, char **outGroupVec, uint32_t *groupNum)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(peerUdid) || (outGroupVec == NULL) || (groupNum == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)peerUdid, strlen(peerUdid) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_RELATED_GROUPS, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = RelatedGroupsIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outGroupVec, groupNum);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t DevInfoByIdIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outDevInfo)
{
int32_t ret;
int32_t inOutLen;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_1) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DEVICE_INFO, (uint8_t *)outDevInfo, NULL);
if (*outDevInfo == NULL) {
return HC_ERR_IPC_OUT_DATA;
}
*outDevInfo = strdup(*outDevInfo);
if (*outDevInfo == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
return HC_SUCCESS;
}
static int32_t FormParamsForGettingDeviceInfo(const char *appId,
const char *peerUdid, const char *groupId, uintptr_t callCtx)
{
int32_t ret;
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)peerUdid, strlen(peerUdid) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
return HC_ERR_IPC_BUILD_PARAM;
}
return HC_SUCCESS;
}
static int32_t IpcGmGetDeviceInfoById(const char *appId, const char *peerUdid, const char *groupId, char **outDevInfo)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_3] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(peerUdid) || !IS_STRING_VALID(groupId) || (outDevInfo == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = FormParamsForGettingDeviceInfo(appId, peerUdid, groupId, callCtx);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_DEV_INFO_BY_ID, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = DevInfoByIdIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outDevInfo);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t TrustedDevIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outDevInfoVec, uint32_t *devNum)
{
int32_t ret;
int32_t inOutLen;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen);
if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) {
return HC_ERR_IPC_OUT_DATA_NUM;
}
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DEVICE_INFO, (uint8_t *)outDevInfoVec, NULL);
if (*outDevInfoVec == NULL) {
return HC_ERR_IPC_OUT_DATA;
}
*outDevInfoVec = strdup(*outDevInfoVec);
if (*outDevInfoVec == NULL) {
return HC_ERR_ALLOC_MEMORY;
}
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)devNum, &inOutLen);
return HC_SUCCESS;
}
static int32_t IpcGmGetTrustedDevices(const char *appId,
const char *groupId, char **outDevInfoVec, uint32_t *deviceNum)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(groupId) ||
(outDevInfoVec == NULL) || (deviceNum == NULL)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_TRUST_DEVICES, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = TrustedDevIpcResult(replyCache, REPLAY_CACHE_NUM(replyCache), outDevInfoVec, deviceNum);
LOGI("proc result done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static bool IpcGmIsDeviceInGroup(const char *appId, const char *groupId, const char *udid)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(groupId) || !IS_STRING_VALID(udid)) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)udid, strlen(udid) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_IS_DEV_IN_GROUP, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return (ret == HC_SUCCESS) ? true : false;
}
static void IpcGmDestroyInfo(char **returnInfo)
{
if ((returnInfo == NULL) || (*returnInfo == NULL)) {
return;
}
FreeJsonString(*returnInfo);
*returnInfo = NULL;
}
static int32_t IpcGmAuthKeyAgree(int64_t requestId, const char *appId, const char *buildParams)
{
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(buildParams)) {
return HC_ERR_INVALID_PARAMS;
}
(void)requestId;
return HC_ERR_NOT_SUPPORT;
}
static int32_t IpcGmProcessKeyAgreeData(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen)
{
LOGI("starting ...");
if (!IS_STRING_VALID(appId) || !IS_COMM_DATA_VALID(data, dataLen)) {
return HC_ERR_INVALID_PARAMS;
}
(void)requestId;
return HC_ERR_NOT_SUPPORT;
}
static void InitIpcGmMethods(DeviceGroupManager *gmMethodObj)
{
LOGI("starting ...");
gmMethodObj->regCallback = IpcGmRegCallback;
gmMethodObj->unRegCallback = IpcGmUnRegCallback;
gmMethodObj->regDataChangeListener = IpcGmRegDataChangeListener;
gmMethodObj->unRegDataChangeListener = IpcGmUnRegDataChangeListener;
gmMethodObj->createGroup = IpcGmCreateGroup;
gmMethodObj->deleteGroup = IpcGmDelGroup;
gmMethodObj->addMemberToGroup = IpcGmAddMemberToGroup;
gmMethodObj->deleteMemberFromGroup = IpcGmDelMemberFromGroup;
gmMethodObj->processData = IpcGmProcessData;
gmMethodObj->confirmRequest = IpcGmConfirmRequest;
gmMethodObj->bindPeer = IpcGmBindPeer;
gmMethodObj->unbindPeer = IpcGmUnBindPeer;
gmMethodObj->processLiteData = IpcGmProcessLiteData;
gmMethodObj->processCredential = IpcGmProcCredential;
gmMethodObj->getRegisterInfo = IpcGmGetRegisterInfo;
gmMethodObj->getLocalConnectInfo = IpcGmGetLocalConnectInfo;
gmMethodObj->addGroupManager = IpcGmAddGroupManager;
gmMethodObj->addGroupFriend = IpcGmAddGroupFriend;
gmMethodObj->deleteGroupManager = IpcGmDelGroupManager;
gmMethodObj->deleteGroupFriend = IpcGmDelGroupFriend;
gmMethodObj->getGroupManagers = IpcGmGetGroupManagers;
gmMethodObj->getGroupFriends = IpcGmGetGroupFriends;
gmMethodObj->getGroupInfoById = IpcGmGetGroupInfoById;
gmMethodObj->getGroupInfo = IpcGmGetGroupInfo;
gmMethodObj->getJoinedGroups = IpcGmGetJoinedGroups;
gmMethodObj->getRelatedGroups = IpcGmGetRelatedGroups;
gmMethodObj->getDeviceInfoById = IpcGmGetDeviceInfoById;
gmMethodObj->getTrustedDevices = IpcGmGetTrustedDevices;
gmMethodObj->isDeviceInGroup = IpcGmIsDeviceInGroup;
gmMethodObj->destroyInfo = IpcGmDestroyInfo;
gmMethodObj->authKeyAgree = IpcGmAuthKeyAgree;
gmMethodObj->processKeyAgreeData = IpcGmProcessKeyAgreeData;
LOGI("process done");
return;
}
static int32_t IpcGaProcessData(int64_t authReqId,
const uint8_t *data, uint32_t dataLen, const DeviceAuthCallback *callback)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_COMM_DATA_VALID(data, dataLen) || (callback == NULL)) {
LOGE("invalid params");
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&authReqId), sizeof(authReqId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, (const uint8_t *)data, dataLen);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_COMM_DATA);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
SetCbCtxToDataCtx(callCtx, 0x0);
ret = DoBinderCall(callCtx, IPC_CALL_ID_GA_PROC_DATA, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t IpcGaQueryTrustedDeviceNum(void)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_QUERY_TRUST_DEV_NUM, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, device num %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static bool IpcGaIsTrustedDevice(const char *udid)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (udid == NULL) {
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
uint32_t udidLen = strlen(udid) + 1;
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, (const uint8_t *)udid, udidLen);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_COMM_DATA);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_IS_TRUST_DEVICE, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return (ret == HC_SUCCESS) ? true : false;
}
static int32_t FormParamsForGettingAuthState(int64_t authReqId, const char *groupId,
const char *peerUdid, uintptr_t callCtx)
{
int32_t ret;
int32_t inOutLen;
inOutLen = sizeof(authReqId);
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&authReqId, inOutLen);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)peerUdid, strlen(peerUdid) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID);
return HC_ERR_IPC_BUILD_PARAM;
}
return HC_SUCCESS;
}
static int32_t IpcGaGetAuthState(int64_t authReqId, const char *groupId,
const char *peerUdid, uint8_t *out, uint32_t *outLen)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache[IPC_DATA_CACHES_3] = {{0}};
LOGI("starting ...");
if (!IS_STRING_VALID(peerUdid) || !IS_STRING_VALID(groupId) || (out == NULL) || (outLen == NULL)) {
LOGE("invalid params");
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = FormParamsForGettingAuthState(authReqId, groupId, peerUdid, callCtx);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_AUTH_STATE, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
if (ret != HC_SUCCESS) {
DestroyCallCtx(&callCtx, NULL);
return ret;
}
GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_COMM_DATA, out, (int32_t *)outLen);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static int32_t IpcGaAuthDevice(int64_t authReqId, const char *authParams, const DeviceAuthCallback *callback)
{
uintptr_t callCtx = 0x0;
int32_t ret;
int32_t inOutLen;
IpcDataInfo replyCache = {0};
LOGI("starting ...");
if (!IS_STRING_VALID(authParams) || (callback == NULL)) {
LOGE("invalid params");
return HC_ERR_INVALID_PARAMS;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return HC_ERROR;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return HC_ERR_IPC_INIT;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&authReqId), sizeof(authReqId));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_AUTH_PARAMS, (const uint8_t *)authParams, strlen(authParams) + 1);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_AUTH_PARAMS);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_DEV_AUTH_CB, (const uint8_t *)callback, sizeof(*callback));
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_DEV_AUTH_CB);
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_BUILD_PARAM;
}
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_AUTH_ID);
ret = DoBinderCall(callCtx, IPC_CALL_ID_AUTH_DEVICE, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call failed");
DestroyCallCtx(&callCtx, NULL);
return HC_ERR_IPC_PROC_FAILED;
}
DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache));
ret = HC_ERR_IPC_UNKNOW_REPLAY;
inOutLen = sizeof(int32_t);
GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen);
LOGI("process done, ret %d", ret);
DestroyCallCtx(&callCtx, NULL);
return ret;
}
static void IpcGaInformDeviceDisconn(const char *udid)
{
uintptr_t callCtx = 0x0;
int32_t ret;
LOGI("entering ...");
if (udid == NULL) {
LOGE("invalid params");
return;
}
if (!IsServiceRunning()) {
LOGE("service is not activity");
return;
}
ret = CreateCallCtx(&callCtx, NULL);
if (ret != HC_SUCCESS) {
LOGE("CreateCallCtx failed, ret %d", ret);
return;
}
uint32_t udidLen = strlen(udid) + 1;
ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, (const uint8_t *)udid, udidLen);
if (ret != HC_SUCCESS) {
LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_COMM_DATA);
DestroyCallCtx(&callCtx, NULL);
return;
}
ret = DoBinderCall(callCtx, IPC_CALL_ID_INFORM_DEV_DISCONN, true);
if (ret == HC_ERR_IPC_INTERNAL_FAILED) {
LOGE("ipc call error");
DestroyCallCtx(&callCtx, NULL);
return;
}
LOGI("process done");
DestroyCallCtx(&callCtx, NULL);
return;
}
static void InitIpcGaMethods(GroupAuthManager *gaMethodObj)
{
LOGI("entering...");
gaMethodObj->processData = IpcGaProcessData;
gaMethodObj->queryTrustedDeviceNum = IpcGaQueryTrustedDeviceNum;
gaMethodObj->isTrustedDevice = IpcGaIsTrustedDevice;
gaMethodObj->getAuthState = IpcGaGetAuthState;
gaMethodObj->authDevice = IpcGaAuthDevice;
gaMethodObj->informDeviceDisconnection = IpcGaInformDeviceDisconn;
LOGI("process done");
return;
}
DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService(void)
{
InitHcMutex(&g_ipcMutex);
return HC_SUCCESS;
}
DEVICE_AUTH_API_PUBLIC void DestroyDeviceAuthService(void)
{
DestroyHcMutex(&g_ipcMutex);
}
DEVICE_AUTH_API_PUBLIC const GroupAuthManager *GetGaInstance(void)
{
static GroupAuthManager gaInstCtx = {NULL};
static GroupAuthManager *gaInstPtr = NULL;
LOGI("Enter InitIpcMethods...");
if (gaInstPtr == NULL) {
InitIpcGaMethods(&gaInstCtx);
gaInstPtr = &gaInstCtx;
}
LOGI("InitIpcMethods done");
return (const GroupAuthManager *)(gaInstPtr);
}
DEVICE_AUTH_API_PUBLIC const DeviceGroupManager *GetGmInstance(void)
{
static DeviceGroupManager gmInstCtx = {NULL};
static DeviceGroupManager *gmInstPtr = NULL;
LOGI("Enter InitIpcMethods...");
if (gmInstPtr == NULL) {
InitIpcGmMethods(&gmInstCtx);
gmInstPtr = &gmInstCtx;
}
LOGI("InitIpcMethods done");
return (const DeviceGroupManager *)(gmInstPtr);
}
#ifdef __cplusplus
}
#endif
security_lite/hichain_posix0/ipc_sdk.h 已删除 100644 → 0
浏览文件 @ 3af7a0fc
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef IPC_SDK_H
#define IPC_SDK_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#define IPC_RESULT_NUM_1 1
#define IPC_RESULT_NUM_2 2
#define IPC_CALL_BACK_STUB_AUTH_ID 0
#define IPC_CALL_BACK_STUB_BIND_ID 1
/* params type for ipc call */
#define PARAM_TYPE_APPID 1
#define PARAM_TYPE_DEV_AUTH_CB 2
#define PARAM_TYPE_LISTERNER 3
#define PARAM_TYPE_REQID 4
#define PARAM_TYPE_CREATE_PARAMS 5
#define PARAM_TYPE_GROUPID 6
#define PARAM_TYPE_UDID 7
#define PARAM_TYPE_ADD_PARAMS 8
#define PARAM_TYPE_DEL_PARAMS 9
#define PARAM_TYPE_COMM_DATA 10
#define PARAM_TYPE_REQ_CFM 11
#define PARAM_TYPE_BIND 12
#define PARAM_TYPE_UNBIND 13
#define PARAM_TYPE_GROUP_TYPE 14
#define PARAM_TYPE_CREDENTIAL 15
#define PARAM_TYPE_MGR_APPID 16
#define PARAM_TYPE_FRIEND_APPID 17
#define PARAM_TYPE_QUERY_PARAMS 18
#define PARAM_TYPE_REG_INFO 19
#define PARAM_TYPE_DATA_NUM 20
#define PARAM_TYPE_SESS_KEY 21
#define PARAM_TYPE_OPCODE 22
#define PARAM_TYPE_IPC_RESULT 23
#define PARAM_TYPE_IPC_RESULT_NUM 24
#define PARAM_TYPE_ERRCODE 25
#define PARAM_TYPE_ERR_INFO 26
#define PARAM_TYPE_REQ_INFO 27
#define PARAM_TYPE_GROUP_INFO 28
#define PARAM_TYPE_DEVICE_INFO 29
#define PARAM_TYPE_AUTH_PARAMS 30
#define PARAM_TYPE_CB_OBJECT 31
enum {
IPC_CALL_ID_REG_CB = 1,
IPC_CALL_ID_UNREG_CB,
IPC_CALL_ID_REG_LISTENER,
IPC_CALL_ID_UNREG_LISTENER,
IPC_CALL_ID_CREATE_GROUP,
IPC_CALL_ID_DEL_GROUP,
IPC_CALL_ID_ADD_GROUP_MEMBER,
IPC_CALL_ID_DEL_GROUP_MEMBER,
IPC_CALL_ID_GM_PROC_DATA,
IPC_CALL_ID_CFM_REQUEST,
IPC_CALL_ID_BIND_PEER,
IPC_CALL_ID_UNBIND_PEER,
IPC_CALL_ID_PROC_LIGHT_DATA,
IPC_CALL_ID_SAVE_CREDENTIAL,
IPC_CALL_ID_APPLY_REG_INFO,
IPC_CALL_ID_ADD_GROUP_MGR,
IPC_CALL_ID_ADD_GROUP_FRIEND,
IPC_CALL_ID_DEL_GROUP_MGR,
IPC_CALL_ID_DEL_GROUP_FRIEND,
IPC_CALL_ID_GET_GROUP_MGR,
IPC_CALL_ID_GET_GROUP_FRIEND,
IPC_CALL_ID_GET_GROUP_INFO,
IPC_CALL_ID_SEARCH_GROUPS,
IPC_CALL_ID_GET_JOINED_GROUPS,
IPC_CALL_ID_GET_RELATED_GROUPS,
IPC_CALL_ID_GET_DEV_INFO_BY_ID,
IPC_CALL_ID_GET_TRUST_DEVICES,
IPC_CALL_ID_IS_DEV_IN_GROUP,
IPC_CALL_ID_DESTROY_INFO,
IPC_CALL_ID_GA_PROC_DATA,
IPC_CALL_ID_QUERY_TRUST_DEV_NUM,
IPC_CALL_ID_IS_TRUST_DEVICE,
IPC_CALL_ID_GET_AUTH_STATE,
IPC_CALL_ID_AUTH_DEVICE,
IPC_CALL_ID_INFORM_DEV_DISCONN
};
#ifdef __cplusplus
}
#endif
#endif
security_lite/hichain_posix0/ipc_service.c 已删除 100644 → 0
浏览文件 @ 3af7a0fc
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ipc_service.h"
#include "common_defs.h"
#include "device_auth_defines.h"
#include "device_auth.h"
#include "hc_condition.h"
#include "hc_log.h"
#include "hc_thread.h"
#include "ipc_adapt.h"
#include "ipc_sdk.h"
#include "securec.h"
#ifdef __cplusplus
extern "C" {
#endif
static const int32_t g_ipcResultNum1 = IPC_RESULT_NUM_1;
static const int32_t g_ipcResultNum2 = IPC_RESULT_NUM_2;
static const char *g_serviceAppId = "deviceauth_service";
static DeviceGroupManager g_devGroupMgrMethod = {NULL};
static GroupAuthManager g_groupAuthMgrMethod = {NULL};
static DeviceAuthCallback g_bindCbAdt = {NULL};
static DeviceAuthCallback g_authCbAdt = {NULL};
static DataChangeListener g_listenCbAdt = {NULL};
static int32_t BindRequestIdWithAppId(const char *data)
{
const char *appId = NULL;
int32_t ret;
int64_t requestId = -1;
CJson *dataJson = CreateJsonFromString(data);
if (dataJson == NULL) {
LOGE("failed to create json from string!");
return HC_ERROR;
}
appId = GetStringFromJson(dataJson, FIELD_APP_ID);
if (appId == NULL) {
LOGE("failed to get appId from json object!");
FreeJson(dataJson);
return HC_ERROR;
}
(void)GetInt64FromJson(dataJson, FIELD_REQUEST_ID, &requestId);
ret = AddReqIdByAppId(appId, requestId);
FreeJson(dataJson);
return ret;
}
static int32_t IpcServiceGmRegCallback(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const DeviceAuthCallback *callback = NULL;
int32_t cbObjIdx = -1;
int32_t idxLen;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&callback, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_DEV_AUTH_CB);
return ret;
}
ret = AddIpcCallBackByAppId(appId, (const uint8_t *)callback, sizeof(DeviceAuthCallback), CB_TYPE_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return HC_ERROR;
}
idxLen = sizeof(cbObjIdx);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CB_OBJECT, (uint8_t *)&cbObjIdx, &idxLen);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_CB_OBJECT);
DelIpcCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
return ret;
}
AddIpcCbObjByAppId(appId, cbObjIdx, CB_TYPE_DEV_AUTH);
InitDeviceAuthCbCtx(&g_bindCbAdt, CB_TYPE_DEV_AUTH);
callRet = g_devGroupMgrMethod.regCallback(appId, &g_bindCbAdt);
if (callRet != HC_SUCCESS) {
DelIpcCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
}
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmUnRegCallback(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet = HC_SUCCESS;
int32_t ret;
const char *appId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
DelIpcCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmRegDataChangeListener(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const DataChangeListener *callback = NULL;
static int32_t registered = 0;
int32_t cbObjIdx = -1;
int32_t idxLen;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_LISTERNER, (uint8_t *)&callback, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_LISTERNER);
return ret;
}
ret = AddIpcCallBackByAppId(appId, (const uint8_t *)callback, sizeof(DataChangeListener), CB_TYPE_LISTENER);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return HC_ERROR;
}
idxLen = sizeof(cbObjIdx);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CB_OBJECT, (uint8_t *)&cbObjIdx, &idxLen);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_CB_OBJECT);
DelIpcCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
return ret;
}
AddIpcCbObjByAppId(appId, cbObjIdx, CB_TYPE_LISTENER);
callRet = HC_SUCCESS;
if (registered == 0) {
InitDevAuthListenerCbCtx(&g_listenCbAdt);
callRet = g_devGroupMgrMethod.regDataChangeListener(g_serviceAppId, &g_listenCbAdt);
if (callRet == HC_SUCCESS) {
registered = 1;
} else {
DelIpcCallBackByAppId(appId, CB_TYPE_LISTENER);
}
}
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmUnRegDataChangeListener(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet = HC_SUCCESS;
int32_t ret;
const char *appId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
DelIpcCallBackByAppId(appId, CB_TYPE_LISTENER);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmCreateGroup(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int64_t requestId = 0;
int32_t inOutLen;
const char *createParams = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CREATE_PARAMS, (uint8_t *)&createParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_CREATE_PARAMS);
return ret;
}
callRet = g_devGroupMgrMethod.createGroup(requestId, appId, createParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmDelGroup(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int64_t requestId = 0;
int32_t inOutLen;
const char *appId = NULL;
const char *delParams = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_DEL_PARAMS, (uint8_t *)&delParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_DEL_PARAMS);
return ret;
}
callRet = g_devGroupMgrMethod.deleteGroup(requestId, appId, delParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmAddMemberToGroup(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t inOutLen;
int64_t requestId = 0;
const char *addParams = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_ADD_PARAMS, (uint8_t *)&addParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_ADD_PARAMS);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = AddReqIdByAppId(appId, requestId);
if (ret != HC_SUCCESS) {
return ret;
}
callRet = g_devGroupMgrMethod.addMemberToGroup(requestId, appId, addParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmDelMemberFromGroup(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t inOutLen;
int64_t requestId = 0;
const char *delParams = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_DEL_PARAMS, (uint8_t *)&delParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_DEL_PARAMS);
return ret;
}
callRet = g_devGroupMgrMethod.deleteMemberFromGroup(requestId, appId, delParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmProcessData(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t dataLen;
int32_t inOutLen;
int64_t requestId = 0;
const uint8_t *data = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
dataLen = 0;
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_COMM_DATA, (uint8_t *)&data, &dataLen);
if ((ret != HC_SUCCESS) || (dataLen <= 0)) {
LOGE("get param error, type %d, data length %d", PARAM_TYPE_COMM_DATA, dataLen);
return ret;
}
ret = BindRequestIdWithAppId((const char *)data);
if (ret != HC_SUCCESS) {
return ret;
}
callRet = g_devGroupMgrMethod.processData(requestId, data, dataLen);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmConfirmRequest(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t inOutLen;
int64_t requestId = 0;
const char *cfmParams = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&cfmParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQ_CFM, (uint8_t *)&cfmParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_REQ_CFM);
return ret;
}
callRet = g_devGroupMgrMethod.confirmRequest(requestId, appId, cfmParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmBindPeer(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t inOutLen;
int64_t requestId = 0;
const char *bindParams = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_BIND, (uint8_t *)&bindParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_BIND);
return ret;
}
callRet = g_devGroupMgrMethod.bindPeer(requestId, appId, bindParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmUnBindPeer(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t inOutLen;
int64_t requestId = 0;
const char *unBindParams = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_UNBIND);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_UNBIND, (uint8_t *)&unBindParams, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_UNBIND);
return ret;
}
callRet = g_devGroupMgrMethod.unbindPeer(requestId, appId, unBindParams);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmProcessLiteData(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t dataLen;
int32_t inOutLen;
int64_t requestId;
const uint8_t *data = NULL;
const char *appId = NULL;
LOGI("starting ...");
inOutLen = sizeof(int64_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int64_t))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
dataLen = 0;
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_COMM_DATA, (uint8_t *)&data, &dataLen);
if ((ret != HC_SUCCESS) || (dataLen <= 0)) {
LOGE("get param error, type %d", PARAM_TYPE_COMM_DATA);
return ret;
}
AddReqIdByAppId(appId, requestId);
callRet = g_devGroupMgrMethod.processLiteData(requestId, appId, data, dataLen);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmSaveCredential(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t opCode = 0;
int32_t inOutLen;
const char *credential = NULL;
char *returnJsonStr = NULL;
LOGI("starting ...");
inOutLen = sizeof(int32_t);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OPCODE, (uint8_t *)&opCode, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(int32_t))) {
LOGE("get param error, type %d", PARAM_TYPE_OPCODE);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CREDENTIAL, (uint8_t *)&credential, NULL);
if ((ret != HC_SUCCESS) || (credential == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_CREDENTIAL);
return ret;
}
callRet = g_devGroupMgrMethod.processCredential(opCode, credential, &returnJsonStr);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
if ((ret == HC_SUCCESS) && (returnJsonStr != NULL)) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_REQ_INFO,
(const uint8_t *)returnJsonStr, strlen(returnJsonStr) + 1);
g_devGroupMgrMethod.destroyInfo(&returnJsonStr);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_REG_INFO, NULL, 0);
}
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmApplyRegisterInfo(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
char *registerInfo = NULL;
(void)ipcParams;
(void)paramNum;
LOGI("starting ...");
callRet = g_devGroupMgrMethod.getRegisterInfo(&registerInfo);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum1, sizeof(int32_t));
if (registerInfo != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_REG_INFO,
(const uint8_t *)registerInfo, strlen(registerInfo) + 1);
g_devGroupMgrMethod.destroyInfo(&registerInfo);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_REG_INFO, NULL, 0);
}
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmAddGroupManager(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
const char *managerAppId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_MGR_APPID, (uint8_t *)&managerAppId, NULL);
if ((ret != HC_SUCCESS) || (managerAppId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_MGR_APPID);
return ret;
}
callRet = g_devGroupMgrMethod.addGroupManager(appId, groupId, managerAppId);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmAddGroupFriend(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
const char *friendAppId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_FRIEND_APPID, (uint8_t *)&friendAppId, NULL);
if ((ret != HC_SUCCESS) || (friendAppId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_FRIEND_APPID);
return ret;
}
callRet = g_devGroupMgrMethod.addGroupFriend(appId, groupId, friendAppId);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmDelGroupManager(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
const char *managerAppId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_MGR_APPID, (uint8_t *)&managerAppId, NULL);
if ((ret != HC_SUCCESS) || (managerAppId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_MGR_APPID);
return ret;
}
callRet = g_devGroupMgrMethod.deleteGroupManager(appId, groupId, managerAppId);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmDelGroupFriend(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
const char *friendAppId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_FRIEND_APPID, (uint8_t *)&friendAppId, NULL);
if ((ret != HC_SUCCESS) || (friendAppId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_FRIEND_APPID);
return ret;
}
callRet = g_devGroupMgrMethod.deleteGroupFriend(appId, groupId, friendAppId);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGmGetGroupManagers(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
char *managers = NULL;
uint32_t managersNum = 0;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
callRet = g_devGroupMgrMethod.getGroupManagers(appId, groupId, &managers, &managersNum);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum2, sizeof(int32_t));
if (managers != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_MGR_APPID, (const uint8_t *)managers, strlen(managers) + 1);
g_devGroupMgrMethod.destroyInfo(&managers);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_MGR_APPID, NULL, 0);
}
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&managersNum, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetGroupFriends(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
char *friends = NULL;
uint32_t friendsNum = 0;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
callRet = g_devGroupMgrMethod.getGroupFriends(appId, groupId, &friends, &friendsNum);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum2, sizeof(int32_t));
if (friends != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_FRIEND_APPID, (const uint8_t *)friends, strlen(friends) + 1);
g_devGroupMgrMethod.destroyInfo(&friends);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_FRIEND_APPID, NULL, 0);
}
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&friendsNum, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetGroupInfoById(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
char *groupInfo = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
callRet = g_devGroupMgrMethod.getGroupInfoById(appId, groupId, &groupInfo);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum1, sizeof(int32_t));
if (groupInfo != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, (const uint8_t *)groupInfo, strlen(groupInfo) + 1);
g_devGroupMgrMethod.destroyInfo(&groupInfo);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, NULL, 0);
}
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetGroupInfo(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *queryParams = NULL;
char *outGroups = NULL;
uint32_t groupNum = 0;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_QUERY_PARAMS, (uint8_t *)&queryParams, NULL);
if ((ret != HC_SUCCESS) || (queryParams == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_QUERY_PARAMS);
return ret;
}
callRet = g_devGroupMgrMethod.getGroupInfo(appId, queryParams, &outGroups, &groupNum);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum2, sizeof(int32_t));
if (outGroups != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, (const uint8_t *)outGroups, strlen(outGroups) + 1);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, NULL, 0);
}
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&groupNum, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
g_devGroupMgrMethod.destroyInfo(&outGroups);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetJoinedGroups(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t groupType = 0;
const char *appId = NULL;
char *outGroups = NULL;
uint32_t groupNum = 0;
int32_t inOutLen;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
inOutLen = sizeof(groupType);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUP_TYPE, (uint8_t *)&groupType, &inOutLen);
if ((ret != HC_SUCCESS || (inOutLen != sizeof(groupType)))) {
LOGE("get param error, type %d", PARAM_TYPE_GROUP_TYPE);
return ret;
}
callRet = g_devGroupMgrMethod.getJoinedGroups(appId, groupType, &outGroups, &groupNum);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum2, sizeof(int32_t));
if (outGroups != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, (const uint8_t *)outGroups, strlen(outGroups) + 1);
g_devGroupMgrMethod.destroyInfo(&outGroups);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, NULL, 0);
}
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&groupNum, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetRelatedGroups(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *peerUdid = NULL;
char *outGroups = NULL;
uint32_t groupNum = 0;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_UDID, (uint8_t *)&peerUdid, NULL);
if ((ret != HC_SUCCESS) || (peerUdid == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_UDID);
return ret;
}
callRet = g_devGroupMgrMethod.getRelatedGroups(appId, peerUdid, &outGroups, &groupNum);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum2, sizeof(int32_t));
if (outGroups != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, (const uint8_t *)outGroups, strlen(outGroups) + 1);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_GROUP_INFO, NULL, 0);
}
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&groupNum, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
g_devGroupMgrMethod.destroyInfo(&outGroups);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetDeviceInfoById(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *peerUdid = NULL;
const char *groupId = NULL;
char *outDevInfo = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_UDID, (uint8_t *)&peerUdid, NULL);
if ((ret != HC_SUCCESS) || (peerUdid == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_UDID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
callRet = g_devGroupMgrMethod.getDeviceInfoById(appId, peerUdid, groupId, &outDevInfo);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum1, sizeof(int32_t));
if (outDevInfo != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DEVICE_INFO,
(const uint8_t *)outDevInfo, strlen(outDevInfo) + 1);
g_devGroupMgrMethod.destroyInfo(&outDevInfo);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DEVICE_INFO, NULL, 0);
}
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmGetTrustedDevices(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const char *groupId = NULL;
char *outDevInfo = NULL;
uint32_t outDevNum = 0;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
callRet = g_devGroupMgrMethod.getTrustedDevices(appId, groupId, &outDevInfo, &outDevNum);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM,
(const uint8_t *)&g_ipcResultNum2, sizeof(int32_t));
if (outDevInfo != NULL) {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DEVICE_INFO,
(const uint8_t *)outDevInfo, strlen(outDevInfo) + 1);
} else {
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DEVICE_INFO, NULL, 0);
}
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&outDevNum, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
g_devGroupMgrMethod.destroyInfo(&outDevInfo);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGmIsDeviceInGroup(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
bool bRet = false;
const char *appId = NULL;
const char *udid = NULL;
const char *groupId = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
if ((ret != HC_SUCCESS) || (appId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_APPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_UDID, (uint8_t *)&udid, NULL);
if ((ret != HC_SUCCESS) || (udid == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_UDID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if ((ret != HC_SUCCESS) || (groupId == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
bRet = g_devGroupMgrMethod.isDeviceInGroup(appId, groupId, udid);
callRet = ((bRet == true) ? HC_SUCCESS : HC_ERROR);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGaProcessData(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const DeviceAuthCallback *gaCallback = NULL;
int64_t authReqId = 0;
uint8_t *data = NULL;
uint32_t dataLen = 0;
int32_t inOutLen;
int32_t cbObjIdx = -1;
LOGI("starting ...");
inOutLen = sizeof(authReqId);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&authReqId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(authReqId))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_COMM_DATA, (uint8_t *)&data, (int32_t *)&dataLen);
if ((ret != HC_SUCCESS) || (data == NULL) || (dataLen == 0)) {
LOGE("get param error, type %d", PARAM_TYPE_COMM_DATA);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&gaCallback, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_DEV_AUTH_CB);
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(authReqId, (const uint8_t *)gaCallback,
sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return HC_ERROR;
}
inOutLen = sizeof(cbObjIdx);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CB_OBJECT, (uint8_t *)&cbObjIdx, &inOutLen);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_CB_OBJECT);
DelIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH, true);
return ret;
}
AddIpcCbObjByReqId(authReqId, cbObjIdx, CB_TYPE_TMP_DEV_AUTH);
InitDeviceAuthCbCtx(&g_authCbAdt, CB_TYPE_TMP_DEV_AUTH);
callRet = g_groupAuthMgrMethod.processData(authReqId, data, dataLen, &g_authCbAdt);
if (callRet != HC_SUCCESS) {
DelIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH, true);
}
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGaQueryTrustedDeviceNum(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
(void)ipcParams;
(void)paramNum;
LOGI("starting ...");
callRet = g_groupAuthMgrMethod.queryTrustedDeviceNum();
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGaIsTrustedDevice(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
int32_t udidLen = 0;
bool bRet = false;
const char *udid = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_COMM_DATA, (uint8_t *)&udid, &udidLen);
if ((ret != HC_SUCCESS) || (udid == NULL) || (udidLen == 0)) {
LOGE("get param error, type %d", PARAM_TYPE_COMM_DATA);
return ret;
}
bRet = g_groupAuthMgrMethod.isTrustedDevice(udid);
callRet = ((bRet == true) ? HC_SUCCESS : HC_ERROR);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGaGetAuthState(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
const char *groupId = NULL;
const char *peerUdid = NULL;
int64_t authReqId = 0;
int32_t inOutLen;
uint8_t out[512] = {0}; /* 512 - buffer size */
uint32_t outLen = sizeof(out);
LOGI("starting ...");
inOutLen = sizeof(authReqId);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&authReqId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(authReqId))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_GROUPID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_UDID, (uint8_t *)&peerUdid, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_UDID);
return ret;
}
callRet = g_groupAuthMgrMethod.getAuthState(authReqId, groupId, peerUdid, out, &outLen);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_COMM_DATA, (const uint8_t *)out, (int32_t)outLen);
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return (ret == HC_SUCCESS) ? ret : HC_ERROR;
}
static int32_t IpcServiceGaAuthDevice(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet;
int32_t ret;
DeviceAuthCallback *gaCallback = NULL;
int64_t authReqId = 0;
const char *authParams = NULL;
int32_t inOutLen;
int32_t cbObjIdx = -1;
LOGI("starting ...");
inOutLen = sizeof(authReqId);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&authReqId, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(authReqId))) {
LOGE("get param error, type %d", PARAM_TYPE_REQID);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_AUTH_PARAMS, (uint8_t *)&authParams, NULL);
if ((ret != HC_SUCCESS) || (authParams == NULL)) {
LOGE("get param error, type %d", PARAM_TYPE_AUTH_PARAMS);
return ret;
}
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&gaCallback, NULL);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_DEV_AUTH_CB);
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(authReqId, (const uint8_t *)gaCallback,
sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return HC_ERROR;
}
inOutLen = sizeof(cbObjIdx);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CB_OBJECT, (uint8_t *)&cbObjIdx, &inOutLen);
if (ret != HC_SUCCESS) {
LOGE("get param error, type %d", PARAM_TYPE_CB_OBJECT);
DelIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH, true);
return ret;
}
AddIpcCbObjByReqId(authReqId, cbObjIdx, CB_TYPE_TMP_DEV_AUTH);
InitDeviceAuthCbCtx(&g_authCbAdt, CB_TYPE_TMP_DEV_AUTH);
callRet = g_groupAuthMgrMethod.authDevice(authReqId, authParams, &g_authCbAdt);
if (callRet != HC_SUCCESS) {
DelIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH, true);
}
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t IpcServiceGaInformDevDisconnection(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t callRet = HC_SUCCESS;
int32_t ret;
int32_t udidLen = 0;
const char *udid = NULL;
LOGI("starting ...");
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_COMM_DATA, (uint8_t *)&udid, &udidLen);
if ((ret != HC_SUCCESS) || (udid == NULL) || (udidLen == 0)) {
LOGE("get param error, type %d", PARAM_TYPE_COMM_DATA);
return ret;
}
g_groupAuthMgrMethod.informDeviceDisconnection(udid);
ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
LOGI("process done, call ret %d, ipc ret %d", callRet, ret);
return ret;
}
static int32_t AddMethodMap(uintptr_t ipcInstance)
{
uint32_t ret;
ret = SetIpcCallMap(ipcInstance, IpcServiceGmRegCallback, IPC_CALL_ID_REG_CB);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmUnRegCallback, IPC_CALL_ID_UNREG_CB);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmRegDataChangeListener, IPC_CALL_ID_REG_LISTENER);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmUnRegDataChangeListener, IPC_CALL_ID_UNREG_LISTENER);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmCreateGroup, IPC_CALL_ID_CREATE_GROUP);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmDelGroup, IPC_CALL_ID_DEL_GROUP);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmAddMemberToGroup, IPC_CALL_ID_ADD_GROUP_MEMBER);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmDelMemberFromGroup, IPC_CALL_ID_DEL_GROUP_MEMBER);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmProcessData, IPC_CALL_ID_GM_PROC_DATA);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmConfirmRequest, IPC_CALL_ID_CFM_REQUEST);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmBindPeer, IPC_CALL_ID_BIND_PEER);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmUnBindPeer, IPC_CALL_ID_UNBIND_PEER);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmProcessLiteData, IPC_CALL_ID_PROC_LIGHT_DATA);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmSaveCredential, IPC_CALL_ID_SAVE_CREDENTIAL);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmApplyRegisterInfo, IPC_CALL_ID_APPLY_REG_INFO);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmAddGroupManager, IPC_CALL_ID_ADD_GROUP_MGR);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmAddGroupFriend, IPC_CALL_ID_ADD_GROUP_FRIEND);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmDelGroupManager, IPC_CALL_ID_DEL_GROUP_MGR);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmDelGroupFriend, IPC_CALL_ID_DEL_GROUP_FRIEND);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetGroupManagers, IPC_CALL_ID_GET_GROUP_MGR);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetGroupFriends, IPC_CALL_ID_GET_GROUP_FRIEND);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetGroupInfoById, IPC_CALL_ID_GET_GROUP_INFO);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetGroupInfo, IPC_CALL_ID_SEARCH_GROUPS);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetJoinedGroups, IPC_CALL_ID_GET_JOINED_GROUPS);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetRelatedGroups, IPC_CALL_ID_GET_RELATED_GROUPS);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetDeviceInfoById, IPC_CALL_ID_GET_DEV_INFO_BY_ID);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetTrustedDevices, IPC_CALL_ID_GET_TRUST_DEVICES);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGmIsDeviceInGroup, IPC_CALL_ID_IS_DEV_IN_GROUP);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGaProcessData, IPC_CALL_ID_GA_PROC_DATA);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGaQueryTrustedDeviceNum, IPC_CALL_ID_QUERY_TRUST_DEV_NUM);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGaIsTrustedDevice, IPC_CALL_ID_IS_TRUST_DEVICE);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGaGetAuthState, IPC_CALL_ID_GET_AUTH_STATE);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGaAuthDevice, IPC_CALL_ID_AUTH_DEVICE);
ret &= SetIpcCallMap(ipcInstance, IpcServiceGaInformDevDisconnection, IPC_CALL_ID_INFORM_DEV_DISCONN);
LOGI("process done, ret %u", ret);
return ret;
}
void DeMainRescInit(uintptr_t *serviceCtx)
{
if (g_devGroupMgrMethod.unRegDataChangeListener != NULL) {
(void)g_devGroupMgrMethod.unRegDataChangeListener(g_serviceAppId);
}
DeInitIpcCallBackList();
DestroyServiceInstance(serviceCtx);
return;
}
int32_t MainRescInit(void)
{
int32_t ret;
const DeviceGroupManager *gmInst = NULL;
const GroupAuthManager *gaInst = NULL;
LOGI("starting ...");
ret = InitIpcCallBackList();
if (ret != HC_SUCCESS) {
return ret;
}
gmInst = GetGmInstance();
gaInst = GetGaInstance();
if ((gmInst == NULL) || (gaInst == NULL)) {
DeInitIpcCallBackList();
LOGE("MainInit, GetGmInstance failed");
return HC_ERROR;
}
g_devGroupMgrMethod = (DeviceGroupManager)(*gmInst);
g_groupAuthMgrMethod = (GroupAuthManager)(*gaInst);
InitDevAuthListenerCbCtx(&g_listenCbAdt);
ret = gmInst->regDataChangeListener(g_serviceAppId, &g_listenCbAdt);
if (ret != HC_SUCCESS) {
DeInitIpcCallBackList();
LOGE("MainInit, register ipc listener failed, ret %d", ret);
return HC_ERROR;
}
LOGI("process done");
return HC_SUCCESS;
}
int32_t main(int32_t argc, char const *argv[])
{
uintptr_t serviceCtx = 0x0;
int32_t ret;
HcCondition cond;
(void)argc;
(void)argv;
LOGI("device authentication service starting ...");
ret = InitDeviceAuthService();
if (ret != HC_SUCCESS) {
LOGE("device auth service main, InitDeviceAuthService failed, ret %d", ret);
return 1;
}
ret = MainRescInit();
if (ret != HC_SUCCESS) {
DestroyDeviceAuthService();
LOGE("device auth service main, init work failed");
return 1;
}
ret = AddDevAuthServiceToManager(&serviceCtx);
if (ret != HC_SUCCESS) {
DeMainRescInit(&serviceCtx);
DestroyDeviceAuthService();
serviceCtx = 0x0;
LOGE("device auth service main, AddDevAuthServiceToManager failed, ret %d", ret);
return 1;
}
(void)AddMethodMap(serviceCtx);
LOGI("device authentication service register to IPC manager done, service running...");
(void)memset_s(&cond, sizeof(cond), 0, sizeof(cond));
InitHcCond(&cond, NULL);
cond.wait(&cond);
DestroyHcCond(&cond);
return 0;
}
#ifdef __cplusplus
}
#endif
security_lite/hichain_posix0/src/hichain_function_test.c 已删除 100644 → 0
浏览文件 @ 3af7a0fc
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// #include "hichain_function_test.h"
#include "log.h"
#include "distribution.h"
#include "hichain.h"
#include "hctest.h"
#include "hks_client.h"
#include "hks_types.h"
#include <securec.h>
#include <sys/time.h>
#include <sys/time.h>
#define MAX_SEND_MESSAGE_BUFF 1024
#define PRINT(...)
LITE_TEST_SUIT(security, securityData, HichainFunctionTestSuite);
/* *
* @tc.setup : setup for all testcases
* @return : setup result, TRUE is success, FALSE is fail
*/
static BOOL HichainFunctionTestSuiteSetUp(void)
{
int32_t status;
status = hks_init();
if (status != 0) {
status = hks_refresh_key_info();
}
TEST_ASSERT_EQUAL_INT(0, status);
return TRUE;
}
/* *
* @tc.teardown : teardown for all testcases
* @return : teardown result, TRUE is success, FALSE is fail
*/
static BOOL HichainFunctionTestSuiteTearDown(void)
{
printf("-+++++++++++++++++++++++++++++++++++++++++++++-\n");
return TRUE;
}
static char g_sendMessageBuf[MAX_SEND_MESSAGE_BUFF];
static struct hc_auth_id g_testClientAuthId = { sizeof("authClient") - 1, "authClient" };
static struct hc_auth_id g_testServerAuthId = { sizeof("authServer") - 1, "authServer" };
static struct hc_pin g_testPin = { sizeof("123456789012345") - 1, "123456789012345" };
static uint32_t g_sendLength = 0;
static int32_t g_serviceResult = 0;
static struct session_identity g_clientIdentity = {
0,
{ sizeof("testClient") - 1, "testClient" },
{ sizeof("testClient") - 1, "testClient" },
0
};
static struct session_identity g_serverIdentity = {
0,
{ sizeof("testServer") - 1, "testServer" },
{ sizeof("testServer") - 1, "testServer" },
0
};
void TransmitDoNothing(const struct session_identity *identity, const void *data, uint32_t length)
{
if (memcpy_s(g_sendMessageBuf, MAX_SEND_MESSAGE_BUFF, data, length) != EOK) {
return;
}
g_sendMessageBuf[length] = 0;
PRINT("Send data: %s\n", g_sendMessageBuf);
g_sendLength = length;
identity = identity;
}
void GetProtocolParams(const struct session_identity *identity, int32_t operationCode, struct hc_pin *pin,
struct operation_parameter *para)
{
(void)identity;
(void)operationCode;
*pin = g_testPin;
para->key_length = 32; // 传入128计算hkdf失败， 暂时改成32
para->peer_auth_id = g_testClientAuthId;
para->self_auth_id = g_testServerAuthId;
}
void SetSessionKey(const struct session_identity *identity, const struct hc_session_key *sessionKey)
{
(void)identity;
(void)sessionKey;
}
void SetServiceResult(const struct session_identity *identity, int32_t result)
{
(void)identity;
g_serviceResult = result;
}
int32_t ConfirmReceiveRequestOK(const struct session_identity *identity, int32_t operationCode)
{
(void)identity;
(void)operationCode;
return 0;
}
void GetProtocolParamsClient(const struct session_identity *identity, int32_t operationCode, struct hc_pin *pin,
struct operation_parameter *para)
{
(void)identity;
(void)operationCode;
*pin = g_testPin;
para->key_length = 32; // 传入128计算hkdf失败， 暂时改成32
para->peer_auth_id = g_testServerAuthId;
para->self_auth_id = g_testClientAuthId;
}
static void HcLogd(const char *tag, const char *func, const char *format, ...)
{
printf("%s Debug: %s: ", tag, func);
va_list args;
va_start(args, format);
(void)vprintf(format, args);
va_end(args);
printf("\n");
}
static void HcLogi(const char *tag, const char *func, const char *format, ...)
{
printf("%s Info: %s: ", tag, func);
va_list args;
va_start(args, format);
(void)vprintf(format, args);
va_end(args);
printf("\n");
}
static void HcLogw(const char *tag, const char *func, const char *format, ...)
{
printf("%s Warning: %s: ", tag, func);
va_list args;
va_start(args, format);
(void)vprintf(format, args);
va_end(args);
printf("\n");
}
static void HcLoge(const char *tag, const char *func, const char *format, ...)
{
PrintTime();
printf("%s Error: %s: ", tag, func);
va_list args;
va_start(args, format);
(void)vprintf(format, args);
va_end(args);
printf("\n");
}
/* *
* @tc.name: IntentParseUriToUri001
* @tc.desc: Binding end key exchange
* @tc.type: FUNC
* @tc.require:
* @tc.author: dingjinyan
*/
LITE_TEST_CASE(HichainFunctionTestSuite, HichainBindPeer, Function | MediumTest | Level1)
{
struct log_func_group g = {HcLogd, HcLogi, HcLogw, HcLoge};
registe_log(&g);
/* 设置回调函数 */
struct hc_call_back callBack = { TransmitDoNothing, GetProtocolParams, SetSessionKey, SetServiceResult,
ConfirmReceiveRequestOK };
struct hc_call_back callBackClient = { TransmitDoNothing, GetProtocolParamsClient, SetSessionKey, SetServiceResult,
ConfirmReceiveRequestOK };
/* 构造函数 */
hc_handle server = get_instance(&g_serverIdentity, HC_ACCESSORY, &callBack);
hc_handle client = get_instance(&g_clientIdentity, HC_CENTRE, &callBackClient);
struct operation_parameter params = { g_testClientAuthId, g_testServerAuthId, 32 };
int32_t ret = start_pake(client, &params);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, KEY_AGREEMENT_PROCESSING);
struct uint8_buff startRequest = { (uint8_t *)g_sendMessageBuf, g_sendLength, g_sendLength };
ret = receive_data(server, &startRequest);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, KEY_AGREEMENT_PROCESSING);
struct uint8_buff startResponse = { (uint8_t *)g_sendMessageBuf, g_sendLength, g_sendLength };
ret = receive_data(client, &startResponse);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, KEY_AGREEMENT_PROCESSING);
struct uint8_buff endRequest = { (uint8_t *)g_sendMessageBuf, g_sendLength, g_sendLength };
ret = receive_data(server, &endRequest);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, KEY_AGREEMENT_END);
struct uint8_buff endResponse = { (uint8_t *)g_sendMessageBuf, g_sendLength, g_sendLength };
ret = receive_data(client, &endResponse);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, KEY_AGREEMENT_END);
struct uint8_buff exchangeRequest = { (uint8_t *)g_sendMessageBuf, g_sendLength, g_sendLength };
ret = receive_data(server, &exchangeRequest);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, END_SUCCESS);
struct uint8_buff exchangeResponse = { (uint8_t *)g_sendMessageBuf, g_sendLength, g_sendLength };
ret = receive_data(client, &exchangeResponse);
TEST_ASSERT_EQUAL_INT(ret, HC_OK);
TEST_ASSERT_EQUAL_INT(g_serviceResult, END_SUCCESS);
destroy(&client);
destroy(&server);
}
RUN_TEST_SUITE(HichainFunctionTestSuite);
\ No newline at end of file
useriam/face_auth/js_api_test/function_test/userauth/BUILD.gn
浏览文件 @ 051d29ce
# Copyright (c) 2021 Huawei Device Co., Ltd.
# Copyright (c) 2022 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauth/entry/src/main/js/default/app.js
浏览文件 @ 051d29ce
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauth/entry/src/main/js/default/pages/index/index.css
浏览文件 @ 051d29ce
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauth/entry/src/main/js/default/pages/index/index.hml
浏览文件 @ 051d29ce
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauth/entry/src/main/js/default/pages/index/index.js
浏览文件 @ 051d29ce
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauth/entry/src/main/js/test/ListTest.js
浏览文件 @ 051d29ce
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauth/entry/src/main/js/test/execute.js
浏览文件 @ 051d29ce
/*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/BUILD.gn
浏览文件 @ 051d29ce
# Copyright (c) 2021 Huawei Device Co., Ltd.
# Copyright (c) 2022 Huawei Device Co., Ltd.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/default/app.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/default/pages/index/index.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/List.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Publicfunction-n.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......@@ -487,4 +487,4 @@ export{publicRegisterInputer, publicgetallAuthInfo,
publicunRegisterInputer, publicOpenSession, publicCloseSession,
publicaddCredential, publicupdateCred, publiccancel, publicdelUser,
publicdelCred, publicgetAuthInfo, publicgetAvailabeStatus, publicgetProperty,
publicsetProperty, publicauth, publicauthUser, publicgecancelAuth}
\ No newline at end of file
publicsetProperty, publicauth, publicauthUser, publicgecancelAuth}
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Coauth_DFX_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Coauth_Func_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Face_DFX_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Face_Func_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Interface_DFX_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_Interface_Func_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_PIN_DFX_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_PIN_Func_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
useriam/face_auth/js_api_test/function_test/userauthpart2/entry/src/main/js/test/Security_IAM_PIN_Kit_CallbackJsunit.test.js
浏览文件 @ 051d29ce
/*
* Copyright (C) 2021 Huawei Device Co., Ltd.
* Copyright (C) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或