openharmony/security_device_auth
1
0
Fork 0
mirror of https://github.com/openharmony/security_device_auth.git synced 2026-08-24 19:23:10 -04:00
Code Issues Packages Projects Releases Wiki Activity

optimization ipc callback

Browse Source 
Signed-off-by: tangjunyuan <tangjunyuan@huawei.com>
This commit is contained in:
tangjunyuan
2026-02-09 16:13:28 +08:00
parent f884df0120
commit ec0decd2f6
34 changed files with 1649 additions and 1336 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frameworks/inc/ipc_sdk_defines.h
+4 -4
View File
@@ -38,6 +38,10 @@ typedef struct {
SaStatusChangeCallbackFunc onReceivedSaRemoved;
} SaStatusChangeCallback;
typedef int32_t (*RegCallbackFunc)(const char *appId, const DeviceAuthCallback *callback, bool needCache);
typedef int32_t (*RegDataChangeListenerFunc)(const char *appId, const DataChangeListener *listener, bool needCache);
typedef int32_t (*RegCredChangeListenerFunc)(const char *appId, CredChangeListener *listener, bool needCache);
#define IPC_CALL_BACK_STUB_AUTH_ID 0
#define IPC_CALL_BACK_STUB_BIND_ID 1
#define IPC_CALL_BACK_STUB_DIRECT_AUTH_ID 2
@@ -47,10 +51,6 @@ typedef struct {
#define IPC_CALL_CONTEXT_INIT 0x0
#define DEVAUTH_CALLBACK 1
#define GROUP_CHANGE_LISTENER 2
#define CRED_CHANGE_LISTENER 3
/* params type for ipc call */
#define PARAM_TYPE_APPID 1
#define PARAM_TYPE_DEV_AUTH_CB 2
frameworks/inc/lite/ipc_adapt.h
+16 -4
View File
@@ -56,6 +56,11 @@ enum {
CB_ID_ON_DEV_UNTRUSTED,
CB_ID_ON_LAST_GROUP_DELETED,
CB_ID_ON_TRUST_DEV_NUM_CHANGED,
CB_ID_ON_TRANS_TMP,
CB_ID_SESS_KEY_DONE_TMP,
CB_ID_ON_FINISH_TMP,
CB_ID_ON_ERROR_TMP,
CB_ID_ON_REQUEST_TMP,
};
typedef int32_t (*IpcServiceCall)(const IpcDataInfo *, int32_t, uintptr_t);
@@ -79,14 +84,13 @@ int32_t InitIpcCallBackList(void);
void DeInitIpcCallBackList(void);
void InitDeviceAuthCbCtx(DeviceAuthCallback *ctx, int32_t type);
void InitDevAuthListenerCbCtx(DataChangeListener *ctx);
int32_t AddIpcCallBackByAppId(const char *appId, const uint8_t *cbPtr, int32_t cbSz, int32_t type);
int32_t AddIpcCallBackByAppId(const char *appId, int32_t type);
void DelIpcCallBackByAppId(const char *appId, int32_t type);
int32_t AddIpcCallBackByReqId(int64_t reqId, const uint8_t *cbPtr, int32_t cbSz, int32_t type);
int32_t AddIpcCallBackByReqId(int64_t reqId, int32_t type);
void DelIpcCallBackByReqId(int64_t reqId, int32_t type, bool withLock);
int32_t DecodeIpcData(uintptr_t data, int32_t *type, uint8_t **val, int32_t *valSz);
void ProcCbHook(int32_t callbackId, uintptr_t cbHook,
const IpcDataInfo *cbDataCache, int32_t cacheNum, uintptr_t replyCtx);
void ProcCbHook(int32_t callbackId, const IpcDataInfo *cbDataCache, int32_t cacheNum, uintptr_t replyCtx);
int32_t GetIpcRequestParamByType(const IpcDataInfo *ipcParams, int32_t paramNum,
int32_t type, uint8_t *paramCache, int32_t *cacheLen);
@@ -116,6 +120,14 @@ int32_t GetAndValSizeCbParam(const IpcDataInfo *ipcParams,
int32_t GetAndValNullParam(const IpcDataInfo *ipcParams,
int32_t paramNum, int32_t paramType, uint8_t *param, int32_t *paramSize);
int32_t InitSdkIpcCallBackList(void);
void DeInitSdkIpcCallBackList(void);
int32_t AddSdkCallBackByAppId(const char *appId, uint8_t cbType, uint8_t *val, int32_t valSize);
void RemoveSdkCallBackByAppId(const char *appId, uint8_t cbType);
int32_t AddSdkCallBackByRequestId(int64_t requestId, uint8_t cbType, uint8_t *val, int32_t valSize);
void RemoveSdkCallBackByRequestId(int64_t requestId, uint8_t cbType);
int32_t AddRequestIdByAppId(const char *appId, int64_t requestId);
#ifdef __cplusplus
}
#endif
frameworks/inc/lite/ipc_callback_proxy.h
+1 -1
View File
@@ -24,7 +24,7 @@
extern "C" {
#endif
void CbProxySendRequest(SvcIdentity sid, int32_t callbackId, uintptr_t cbHook, IpcIo *data, IpcIo *reply);
void CbProxySendRequest(SvcIdentity sid, int32_t callbackId, IpcIo *data, IpcIo *reply);
#ifdef __cplusplus
}
frameworks/inc/lite/ipc_dev_auth_stub.h
+1 -1
View File
@@ -40,7 +40,7 @@ int32_t SetCallMap(IpcServiceCall method, int32_t methodId);
int32_t SetRemoteObject(const SvcIdentity *object);
void AddCbDeathRecipient(int32_t cbStubIdx, int32_t cbDataIdx);
void ResetRemoteObject(int32_t idx);
void ActCallback(int32_t objIdx, int32_t callbackId, uintptr_t cbHook, IpcIo *dataParcel, IpcIo *reply);
void ActCallback(int32_t objIdx, int32_t callbackId, IpcIo *dataParcel, IpcIo *reply);
int32_t OnRemoteInvoke(IServerProxy *iProxy, int32_t reqId, void *origin, IpcIo *req, IpcIo *reply);
#ifdef __cplusplus
frameworks/inc/standard/ipc_adapt.h
+24 -4
View File
@@ -18,6 +18,7 @@
#include <stdint.h>
#include "device_auth.h"
#include "ipc_sdk_defines.h"
#ifdef __cplusplus
extern "C" {
@@ -53,6 +54,16 @@ enum {
CB_ID_ON_CRED_ADD,
CB_ID_ON_CRED_DELETE,
CB_ID_ON_CRED_UPDATE,
CB_ID_ON_TRANS_TMP,
CB_ID_SESS_KEY_DONE_TMP,
CB_ID_ON_FINISH_TMP,
CB_ID_ON_ERROR_TMP,
CB_ID_ON_REQUEST_TMP,
CB_ID_ON_TRANS_CRED,
CB_ID_SESS_KEY_DONE_CRED,
CB_ID_ON_FINISH_CRED,
CB_ID_ON_ERROR_CRED,
CB_ID_ON_REQUEST_CRED,
};
typedef int32_t (*IpcServiceCall)(const IpcDataInfo *, int32_t, uintptr_t);
@@ -76,14 +87,13 @@ int32_t InitIpcCallBackList(void);
void DeInitIpcCallBackList(void);
void InitDeviceAuthCbCtx(DeviceAuthCallback *ctx, int32_t type);
void InitDevAuthListenerCbCtx(DataChangeListener *ctx);
int32_t AddIpcCallBackByAppId(const char *appId, const uint8_t *cbPtr, int32_t cbSz, int32_t type);
int32_t AddIpcCallBackByAppId(const char *appId, int32_t type);
void DelIpcCallBackByAppId(const char *appId, int32_t type);
int32_t AddIpcCallBackByReqId(int64_t reqId, const uint8_t *cbPtr, int32_t cbSz, int32_t type);
int32_t AddIpcCallBackByReqId(int64_t reqId, int32_t type);
void DelIpcCallBackByReqId(int64_t reqId, int32_t type, bool withLock);
int32_t DecodeIpcData(uintptr_t data, int32_t *type, uint8_t **val, int32_t *valSz);
void ProcCbHook(int32_t callbackId, uintptr_t cbHook,
const IpcDataInfo *cbDataCache, int32_t cacheNum, uintptr_t replyCtx);
void ProcCbHook(int32_t callbackId, const IpcDataInfo *cbDataCache, int32_t cacheNum, uintptr_t replyCtx);
int32_t GetIpcRequestParamByType(const IpcDataInfo *ipcParams, int32_t paramNum,
int32_t type, uint8_t *paramCache, int32_t *cacheLen);
@@ -110,6 +120,16 @@ int32_t GetAndValSizeCbParam(const IpcDataInfo *ipcParams,
int32_t GetAndValNullParam(const IpcDataInfo *ipcParams,
int32_t paramNum, int32_t paramType, uint8_t *param, int32_t *paramSize);
int32_t InitSdkIpcCallBackList(void);
void DeInitSdkIpcCallBackList(void);
int32_t AddSdkCallBackByAppId(const char *appId, uint8_t cbType, uint8_t *val, int32_t valSize);
void RemoveSdkCallBackByAppId(const char *appId, uint8_t cbType);
int32_t AddSdkCallBackByRequestId(int64_t requestId, uint8_t cbType, uint8_t *val, int32_t valSize);
void RemoveSdkCallBackByRequestId(int64_t requestId, uint8_t cbType);
int32_t AddRequestIdByAppId(const char *appId, int64_t requestId);
void RegisterSdkCallBack(RegCallbackFunc regCallbackFunc, RegDataChangeListenerFunc regDataChangeListenerFunc,
RegCredChangeListenerFunc regCredChangeListenerFunc);
#ifdef __cplusplus
}
#endif
frameworks/inc/standard/ipc_callback_proxy.h
+2 -2
View File
@@ -24,8 +24,8 @@ class ProxyDevAuthCb : public IRemoteProxy<ICommIpcCallback> {
public:
explicit ProxyDevAuthCb(const sptr<IRemoteObject> &impl);
~ProxyDevAuthCb();
void DoCallBack(int32_t callbackId, uintptr_t cbHook,
MessageParcel &dataParcel, MessageParcel &reply, MessageOption &option) override;
void DoCallBack(int32_t callbackId, MessageParcel &dataParcel, MessageParcel &reply,
MessageOption &option) override;
private:
static inline BrokerDelegator<ProxyDevAuthCb> delegator_;
};
frameworks/inc/standard/ipc_callback_stub.h
+2 -2
View File
@@ -26,8 +26,8 @@ public:
~StubDevAuthCb();
int32_t OnRemoteRequest(uint32_t code, MessageParcel &data,
MessageParcel &reply, MessageOption &option) override;
void DoCallBack(int32_t callbackId, uintptr_t cbHook,
MessageParcel &dataParcel, MessageParcel &reply, MessageOption &option) override;
void DoCallBack(int32_t callbackId, MessageParcel &dataParcel, MessageParcel &reply,
MessageOption &option) override;
};
}
frameworks/inc/standard/ipc_dev_auth_stub.h
+1 -1
View File
@@ -42,7 +42,7 @@ public:
static void AddCbDeathRecipient(int32_t cbStubIdx, int32_t cbDataIdx);
static void ResetRemoteObject(int32_t idx);
static void ActCallback(int32_t objIdx, int32_t callbackId, bool sync,
uintptr_t cbHook, MessageParcel &dataParcel, MessageParcel &reply);
MessageParcel &dataParcel, MessageParcel &reply);
protected:
int32_t HandleRestoreCall(MessageParcel &data, MessageParcel &reply);
frameworks/inc/standard/ipc_iface.h
+2 -2
View File
@@ -31,8 +31,8 @@ public:
class ICommIpcCallback : public IRemoteBroker {
public:
DECLARE_INTERFACE_DESCRIPTOR(u"deviceauth.ICommIpcCallback");
virtual void DoCallBack(int32_t callbackId, uintptr_t cbHook,
MessageParcel &dataParcel, MessageParcel &reply, MessageOption &option) = 0;
virtual void DoCallBack(int32_t callbackId, MessageParcel &dataParcel, MessageParcel &reply,
MessageOption &option) = 0;
};
const int32_t DEV_AUTH_CALL_WAIT_TIME = 30; /* second */
frameworks/sdk/sa_load_on_demand/inc/sa_load_on_demand.h
-8
View File
@@ -25,14 +25,6 @@
extern "C" {
#endif
typedef int32_t (*RegCallbackFunc)(const char *appId, const DeviceAuthCallback *callback, bool needCache);
typedef int32_t (*RegDataChangeListenerFunc)(const char *appId, const DataChangeListener *listener, bool needCache);
typedef int32_t (*RegCredChangeListenerFunc)(const char *appId, CredChangeListener *listener, bool needCache);
int32_t AddCallbackInfoToList(const char *appId, const DeviceAuthCallback *callback,
const DataChangeListener *dataChangeListener, CredChangeListener *listener, int32_t callbackType);
int32_t RemoveCallbackInfoFromList(const char *appId, int32_t callbackType);
void SetRegCallbackFunc(RegCallbackFunc regCallbackFunc);
void SetRegDataChangeListenerFunc(RegDataChangeListenerFunc regDataChangeListenerFunc);
void SetRegCredChangeListenerFunc(RegCredChangeListenerFunc regCredChangeListenerFunc);
frameworks/sdk/sa_load_on_demand/src/mock/sa_load_on_demand_mock.cpp
-18
View File
@@ -16,24 +16,6 @@
#include "sa_load_on_demand.h"
#include "common_defs.h"
int32_t AddCallbackInfoToList(const char *appId, const DeviceAuthCallback *callback,
const DataChangeListener *dataChangeListener, CredChangeListener *credChangeListener, int32_t callbackType)
{
(void)appId;
(void)callback;
(void)dataChangeListener;
(void)credChangeListener;
(void)callbackType;
return HC_SUCCESS;
}
int32_t RemoveCallbackInfoFromList(const char *appId, int32_t callbackType)
{
(void)appId;
(void)callbackType;
return HC_SUCCESS;
}
void SetRegCallbackFunc(RegCallbackFunc regCallbackFunc)
{
(void)regCallbackFunc;
frameworks/sdk/sa_load_on_demand/src/sa_load_on_demand.cpp
+2 -236
View File
@@ -19,19 +19,16 @@
#include "hc_log.h"
#include "hc_types.h"
#include "iservice_registry.h"
#include "hc_vector.h"
#include "securec.h"
#include "system_ability_definition.h"
#include "parameter.h"
#include "sa_listener.h"
#include "string_util.h"
#include "ipc_adapt.h"
static OHOS::sptr<OHOS::DevAuth::SaListener> g_saListener = nullptr;
static std::recursive_mutex g_devAuthCallbackMutex;
DECLARE_HC_VECTOR(DevAuthCallbackInfoVec, DevAuthCallbackInfo)
IMPLEMENT_HC_VECTOR(DevAuthCallbackInfoVec, DevAuthCallbackInfo, 1)
static DevAuthCallbackInfoVec g_devAuthCallbackList;
static bool g_devAuthSaIsActive = false;
static bool volatile g_devAuthInitStatus = false;
@@ -39,193 +36,9 @@ static RegCallbackFunc g_regCallback;
static RegDataChangeListenerFunc g_regDataChangeListener;
static RegCredChangeListenerFunc g_regCredChangeListener;
static int32_t DoBuildDevAuthCallback(DevAuthCallbackInfo *callbackInfo, const DeviceAuthCallback *callback)
{
DeviceAuthCallback *copyCallback = (DeviceAuthCallback *)HcMalloc(sizeof(DeviceAuthCallback), 0);
if (copyCallback == nullptr) {
LOGE("[SDK]: Failed to malloc callback memory.");
return HC_ERR_ALLOC_MEMORY;
}
if (memcpy_s(copyCallback, sizeof(DeviceAuthCallback), callback, sizeof(DeviceAuthCallback)) != HC_SUCCESS) {
LOGE("[SDK]: Failed to copy callback.");
HcFree(copyCallback);
return HC_ERR_MEMORY_COPY;
}
callbackInfo->callback.deviceAuthCallback = copyCallback;
return HC_SUCCESS;
}
static int32_t DoBuildGroupChangeListener(DevAuthCallbackInfo *callbackInfo,
const DataChangeListener *dataChangeListener)
{
DataChangeListener *copyListener = (DataChangeListener *)HcMalloc(sizeof(DataChangeListener), 0);
if (copyListener == nullptr) {
LOGE("[SDK]: Failed to malloc copyListener memory.");
return HC_ERR_ALLOC_MEMORY;
}
if (memcpy_s(copyListener, sizeof(DataChangeListener), dataChangeListener, sizeof(DataChangeListener))
!= HC_SUCCESS) {
LOGE("[SDK]: Failed to copy dataChangeListener.");
HcFree(copyListener);
return HC_ERR_MEMORY_COPY;
}
callbackInfo->callback.dataChangeListener = copyListener;
return HC_SUCCESS;
}
static int32_t DoBuildCredChangeListener(DevAuthCallbackInfo *callbackInfo,
const CredChangeListener *credChangeListener)
{
CredChangeListener *copyListener = (CredChangeListener *)HcMalloc(sizeof(CredChangeListener), 0);
if (copyListener == nullptr) {
LOGE("[SDK]: Failed to malloc credChangeListener memory.");
return HC_ERR_ALLOC_MEMORY;
}
if (memcpy_s(copyListener, sizeof(CredChangeListener), credChangeListener, sizeof(CredChangeListener))
!= HC_SUCCESS) {
LOGE("[SDK]: Failed to copy copyListener.");
HcFree(copyListener);
return HC_ERR_MEMORY_COPY;
}
callbackInfo->callback.credChangeListener = copyListener;
return HC_SUCCESS;
}
static void FreeCallbackByType(DevAuthCallbackInfo *entry)
{
switch (entry->callbackType) {
case DEVAUTH_CALLBACK:
HcFree(entry->callback.deviceAuthCallback);
entry->callback.deviceAuthCallback = nullptr;
break;
case GROUP_CHANGE_LISTENER:
HcFree(entry->callback.dataChangeListener);
entry->callback.dataChangeListener = nullptr;
break;
case CRED_CHANGE_LISTENER:
HcFree(entry->callback.credChangeListener);
entry->callback.credChangeListener = nullptr;
break;
default:
LOGE("invalid callback type.");
break;
}
}
static int32_t CreateCallbackByType(DevAuthCallbackInfo *entry, const DeviceAuthCallback *callback,
const DataChangeListener *dataChangeListener, CredChangeListener *listener)
{
int32_t ret = HC_ERR_IPC_CALLBACK_TYPE;
switch (entry->callbackType) {
case DEVAUTH_CALLBACK:
ret = DoBuildDevAuthCallback(entry, callback);
break;
case GROUP_CHANGE_LISTENER:
ret = DoBuildGroupChangeListener(entry, dataChangeListener);
break;
case CRED_CHANGE_LISTENER:
ret = DoBuildCredChangeListener(entry, listener);
break;
default:
LOGE("invalid callback type.");
break;
}
return ret;
}
static int32_t BuildCallbackInfo(DevAuthCallbackInfo *callbackInfo, const char *appId,
const DeviceAuthCallback *callback, const DataChangeListener *dataChangeListener, CredChangeListener *listener)
{
uint32_t appIdLen = HcStrlen(appId) + 1;
char *copyAppId = static_cast<char *>(HcMalloc(appIdLen, 0));
if (copyAppId == nullptr) {
LOGE("[SDK]: Failed to malloc appId.");
return HC_ERR_ALLOC_MEMORY;
}
if (strcpy_s(copyAppId, appIdLen, appId) != HC_SUCCESS) {
LOGE("[SDK]: Failed to copy appId.");
HcFree(copyAppId);
return HC_ERR_ALLOC_MEMORY;
}
callbackInfo->appId = copyAppId;
int32_t ret = CreateCallbackByType(callbackInfo, callback, dataChangeListener, listener);
if (ret != HC_SUCCESS) {
LOGE("[SDK]: Do build callback failed.");
HcFree(copyAppId);
}
return ret;
}
static void ClearCallbackInfo(DevAuthCallbackInfo *callbackInfo)
{
HcFree(callbackInfo->appId);
FreeCallbackByType(callbackInfo);
}
static bool UpdateCallback(DevAuthCallbackInfo *callbackInfo, const DeviceAuthCallback *callback,
const DataChangeListener *dataChangeListener, CredChangeListener *listener)
{
DevAuthCallbackInfo tmpCallbackInfo;
tmpCallbackInfo.callbackType = callbackInfo->callbackType;
tmpCallbackInfo.callback = callbackInfo->callback;
if (CreateCallbackByType(callbackInfo, callback, dataChangeListener, listener) != HC_SUCCESS) {
LOGE("[SDK]: Update callback failed.");
return false;
}
FreeCallbackByType(&tmpCallbackInfo);
return true;
}
static bool UpdateCallbackInfoIfExist(const char *appId, const DeviceAuthCallback *callback,
const DataChangeListener *dataChangeListener, CredChangeListener *listener, int32_t callbackType)
{
uint32_t index;
DevAuthCallbackInfo *entry = nullptr;
std::lock_guard<std::recursive_mutex> autoLock(g_devAuthCallbackMutex);
FOR_EACH_HC_VECTOR(g_devAuthCallbackList, index, entry) {
if (entry == nullptr || entry->appId == nullptr) {
continue;
}
if (IsStrEqual(entry->appId, appId) && entry->callbackType == callbackType) {
LOGI("[SDK]:start to update callback, appId: %" LOG_PUB "s, callbackType: %" LOG_PUB "d",
appId, callbackType);
bool ret = UpdateCallback(entry, callback, dataChangeListener, listener);
return ret;
}
}
return false;
}
static void RegisterDevAuthCallback()
{
uint32_t index;
DevAuthCallbackInfo *callbackInfo = nullptr;
int32_t ret = HC_SUCCESS;
std::lock_guard<std::recursive_mutex> autoLock(g_devAuthCallbackMutex);
LOGI("[SDK]: cache list size: %" LOG_PUB "d", g_devAuthCallbackList.size(&g_devAuthCallbackList));
FOR_EACH_HC_VECTOR(g_devAuthCallbackList, index, callbackInfo) {
if (callbackInfo == nullptr || callbackInfo->appId == nullptr) {
continue;
}
switch (callbackInfo->callbackType) {
case DEVAUTH_CALLBACK:
LOGI("regCallback.");
ret = g_regCallback(callbackInfo->appId, callbackInfo->callback.deviceAuthCallback, false);
break;
case GROUP_CHANGE_LISTENER:
LOGI("regDataChangeListener.");
ret = g_regDataChangeListener(callbackInfo->appId, callbackInfo->callback.dataChangeListener, false);
break;
case CRED_CHANGE_LISTENER:
LOGI("regCredChangeListener.");
ret = g_regCredChangeListener(callbackInfo->appId, callbackInfo->callback.credChangeListener, false);
break;
default:
LOGE("invalid callback type: %" LOG_PUB "d.", callbackInfo->callbackType);
break;
}
LOGI("register result: %" LOG_PUB "d.", ret);
}
RegisterSdkCallBack(g_regCallback, g_regDataChangeListener, g_regCredChangeListener);
}
static void OnReceivedDevAuthAdded()
@@ -243,51 +56,6 @@ static void OnReceivedDevAuthRemoved()
g_devAuthSaIsActive = false;
}
int32_t AddCallbackInfoToList(const char *appId, const DeviceAuthCallback *callback,
const DataChangeListener *dataChangeListener, CredChangeListener *listener, int32_t callbackType)
{
if (UpdateCallbackInfoIfExist(appId, callback, dataChangeListener, listener, callbackType)) {
LOGI("[SDK]:Callback info exist, update successfully.");
return HC_SUCCESS;
}
DevAuthCallbackInfo callbackInfo;
callbackInfo.callbackType = callbackType;
int32_t ret = BuildCallbackInfo(&callbackInfo, appId, callback, dataChangeListener, listener);
if (ret != HC_SUCCESS) {
return ret;
}
std::lock_guard<std::recursive_mutex> autoLock(g_devAuthCallbackMutex);
if (g_devAuthCallbackList.pushBack(&g_devAuthCallbackList, &callbackInfo) == nullptr) {
LOGE("[SDK]: Failed to add callbackInfo.");
ClearCallbackInfo(&callbackInfo);
return HC_ERR_ALLOC_MEMORY;
}
LOGI("[SDK]: Add callback info successfully, cache list size: %" LOG_PUB "d.",
g_devAuthCallbackList.size(&g_devAuthCallbackList));
return HC_SUCCESS;
}
int32_t RemoveCallbackInfoFromList(const char *appId, int32_t callbackType)
{
uint32_t index;
DevAuthCallbackInfo *entry = nullptr;
int32_t ret = HC_SUCCESS;
std::lock_guard<std::recursive_mutex> autoLock(g_devAuthCallbackMutex);
FOR_EACH_HC_VECTOR(g_devAuthCallbackList, index, entry) {
if (entry == nullptr || entry->appId == nullptr) {
continue;
}
if (IsStrEqual(entry->appId, appId) && entry->callbackType == callbackType) {
LOGW("[SDK]: start to remove callbackInfo.");
DevAuthCallbackInfo deleteCallbackInfo;
HC_VECTOR_POPELEMENT(&g_devAuthCallbackList, &deleteCallbackInfo, index);
ClearCallbackInfo(&deleteCallbackInfo);
return ret;
}
}
return ret;
}
void SetRegCallbackFunc(RegCallbackFunc regCallbackFunc)
{
g_regCallback = regCallbackFunc;
@@ -361,7 +129,6 @@ void UnSubscribeDeviceAuthSa(void)
int32_t InitLoadOnDemand(void)
{
g_devAuthCallbackList = CREATE_HC_VECTOR(DevAuthCallbackInfoVec);
g_devAuthInitStatus = true;
return HC_SUCCESS;
}
@@ -369,5 +136,4 @@ int32_t InitLoadOnDemand(void)
void DeInitLoadOnDemand(void)
{
g_devAuthInitStatus = false;
DESTROY_HC_VECTOR(DevAuthCallbackInfoVec, &g_devAuthCallbackList);
}
frameworks/src/identity_service_ipc_sdk.c
+15 -4
View File
@@ -169,10 +169,13 @@ static int32_t IpcCmRegChangeListenerInner(const char *appId, CredChangeListener
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
AddIpcCliCallbackCtx(appId, 0, &g_ipcCredListenerCbList);
if (needCache) {
ret = AddCallbackInfoToList(appId, NULL, NULL, listener, CRED_CHANGE_LISTENER);
ret = AddSdkCallBackByAppId(appId, CB_TYPE_CRED_LISTENER, (uint8_t *)listener, sizeof(CredChangeListener));
}
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByAppId(appId, CB_TYPE_CRED_LISTENER);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -199,7 +202,7 @@ static int32_t IpcCmUnRegChangeListener(const char *appId)
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
DelIpcCliCallbackCtx(appId, &g_ipcCredListenerCbList);
ret = RemoveCallbackInfoFromList(appId, CRED_CHANGE_LISTENER);
RemoveSdkCallBackByAppId(appId, CB_TYPE_CRED_LISTENER);
} while (0);
DESTROY_IPC_CTX(callCtx);
@@ -499,18 +502,21 @@ static int32_t IpcCmAuthCredential(int32_t osAccountId, int64_t authReqId, const
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (caCallback == NULL)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(authReqId, CB_TYPE_CRED_DEV_AUTH, (uint8_t *)caCallback,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, caCallback, sizeof(*caCallback));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_AUTH_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_CA_AUTH_CREDENTIAL, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(authReqId, CB_TYPE_CRED_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
DestroyCallCtx(&callCtx);
return ret;
}
@@ -525,6 +531,8 @@ static int32_t IpcCmProcessCredData(int64_t authReqId, const uint8_t *data, uint
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED(!IS_COMM_DATA_VALID(data, dataLen) || (callback == NULL));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(authReqId, CB_TYPE_CRED_DEV_AUTH, (uint8_t *)callback,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
@@ -534,6 +542,9 @@ static int32_t IpcCmProcessCredData(int64_t authReqId, const uint8_t *data, uint
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(authReqId, CB_TYPE_CRED_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
frameworks/src/ipc_sdk.c
+63 -19
View File
@@ -135,6 +135,27 @@ static void GetIpcReplyByType(const IpcDataInfo *ipcData,
return;
}
static int32_t BindRequestIdWithAppId(const uint8_t *data, uint32_t dataLen)
{
CJson *dataJson = NULL;
int32_t ret = CreateJsonFromData(data, dataLen, &dataJson);
if (ret != HC_SUCCESS) {
LOGE("Failed to create json from data!");
return ret;
}
const char *appId = GetStringFromJson(dataJson, FIELD_APP_ID);
if (appId == NULL) {
LOGE("failed to get appId from json object!");
FreeJson(dataJson);
return HC_ERR_JSON_GET;
}
int64_t requestId = -1;
(void)GetInt64FromJson(dataJson, FIELD_REQUEST_ID, &requestId);
ret = AddRequestIdByAppId(appId, requestId);
FreeJson(dataJson);
return ret;
}
static int32_t IpcGmRegCallbackInner(const char *appId, const DeviceAuthCallback *callback, bool needCache)
{
uintptr_t callCtx = 0x0;
@@ -146,14 +167,13 @@ static int32_t IpcGmRegCallbackInner(const char *appId, const DeviceAuthCallback
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_REG_CB, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
AddIpcCliCallbackCtx(appId, 0, &g_ipcProxyCbList);
if (needCache) {
ret = AddCallbackInfoToList(appId, callback, NULL, NULL, DEVAUTH_CALLBACK);
ret = AddSdkCallBackByAppId(appId, CB_TYPE_DEV_AUTH, (uint8_t *)callback, sizeof(DeviceAuthCallback));
}
} while (0);
DESTROY_IPC_CTX(callCtx);
@@ -184,7 +204,7 @@ static int32_t IpcGmUnRegCallback(const char *appId)
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
DelIpcCliCallbackCtx(appId, &g_ipcProxyCbList);
ret = RemoveCallbackInfoFromList(appId, DEVAUTH_CALLBACK);
RemoveSdkCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
} while (0);
DESTROY_IPC_CTX(callCtx);
@@ -203,14 +223,13 @@ static int32_t IpcGmRegDataChangeListenerInner(const char *appId, const DataChan
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_LISTENER, listener, sizeof(*listener));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_BIND_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_REG_LISTENER, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
AddIpcCliCallbackCtx(appId, 0, &g_ipcListenerCbList);
if (needCache) {
ret = AddCallbackInfoToList(appId, NULL, listener, NULL, GROUP_CHANGE_LISTENER);
ret = AddSdkCallBackByAppId(appId, CB_TYPE_LISTENER, (uint8_t *)listener, sizeof(DataChangeListener));
}
} while (0);
DESTROY_IPC_CTX(callCtx);
@@ -241,7 +260,7 @@ static int32_t IpcGmUnRegDataChangeListener(const char *appId)
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
DelIpcCliCallbackCtx(appId, &g_ipcListenerCbList);
ret = RemoveCallbackInfoFromList(appId, GROUP_CHANGE_LISTENER);
RemoveSdkCallBackByAppId(appId, CB_TYPE_LISTENER);
} while (0);
DESTROY_IPC_CTX(callCtx);
@@ -261,6 +280,7 @@ static int32_t IpcGmCreateGroup(int32_t osAccountId, int64_t requestId, const ch
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(createParams)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddRequestIdByAppId(appId, requestId);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
@@ -287,6 +307,7 @@ static int32_t IpcGmDeleteGroup(int32_t osAccountId, int64_t requestId, const ch
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(delParams)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddRequestIdByAppId(appId, requestId);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
@@ -313,6 +334,7 @@ static int32_t IpcGmAddMemberToGroup(int32_t osAccountId, int64_t requestId, con
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(addParams)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddRequestIdByAppId(appId, requestId);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
@@ -339,6 +361,7 @@ static int32_t IpcGmDelMemberFromGroup(int32_t osAccountId, int64_t requestId, c
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(appId) || IsStrInvalid(delParams)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddRequestIdByAppId(appId, requestId);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_APPID, appId, HcStrlen(appId) + 1);
@@ -415,6 +438,7 @@ static int32_t IpcGmProcessData(int64_t requestId, const uint8_t *data, uint32_t
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((!IS_COMM_DATA_VALID(data, dataLen)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = BindRequestIdWithAppId(data, dataLen);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GM_PROC_DATA, true);
@@ -803,16 +827,19 @@ static int32_t IpcGaProcessData(int64_t authReqId,
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((!IS_COMM_DATA_VALID(data, dataLen) || (callback == NULL)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(authReqId, CB_TYPE_TMP_DEV_AUTH, (uint8_t *)callback,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
SetCbCtxToDataCtx(callCtx, 0x0);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_GA_PROC_DATA, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(authReqId, CB_TYPE_TMP_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -830,17 +857,20 @@ static int32_t IpcGaAuthDevice(int32_t osAccountId, int64_t authReqId, const cha
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (callback == NULL)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(authReqId, CB_TYPE_TMP_DEV_AUTH, (uint8_t *)callback,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_AUTH_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_AUTH_DEVICE, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(authReqId, CB_TYPE_TMP_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -1161,17 +1191,20 @@ static int32_t IpcLaStartLightAccountAuth(int32_t osAccountId, int64_t requestId
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(serviceId) || laCallBack == NULL));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH, (uint8_t *)laCallBack,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_SERVICE_ID, serviceId, HcStrlen(serviceId) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, laCallBack, sizeof(*laCallBack));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_LIGHT_AUTH_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_LA_START_LIGHT_ACCOUNT_AUTH, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -1188,17 +1221,20 @@ static int32_t IpcLaProcessLightAccountAuth(int32_t osAccountId, int64_t request
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((!IS_COMM_DATA_VALID(inMsg->data, inMsg->length) || (laCallBack == NULL)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH, (uint8_t *)laCallBack,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, &osAccountId, sizeof(osAccountId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_COMM_DATA, inMsg->data, inMsg->length);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, laCallBack, sizeof(*laCallBack));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_LIGHT_AUTH_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_LA_PROCESS_LIGHT_ACCOUNT_AUTH, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -1250,16 +1286,19 @@ DEVICE_AUTH_API_PUBLIC int32_t ProcessAuthDevice(
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (callback == NULL)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH, (uint8_t *)callback,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &requestId, sizeof(requestId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_DIRECT_AUTH_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DA_PROC_DATA, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -1276,16 +1315,19 @@ DEVICE_AUTH_API_PUBLIC int32_t StartAuthDevice(
RETURN_INT_IF_CHECK_IPC_PARAMS_FAILED((IsStrInvalid(authParams) || (callback == NULL)));
RETURN_INT_IF_CREATE_IPC_CTX_FAILED(callCtx);
do {
ret = AddSdkCallBackByRequestId(authReqId, CB_TYPE_TMP_DEV_AUTH, (uint8_t *)callback,
sizeof(DeviceAuthCallback));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_REQID, &authReqId, sizeof(authReqId));
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_AUTH_PARAMS, authParams, HcStrlen(authParams) + 1);
BREAK_IF_SET_IPC_PARAM_FAILED(callCtx, PARAM_TYPE_DEV_AUTH_CB, callback, sizeof(*callback));
SetCbCtxToDataCtx(callCtx, IPC_CALL_BACK_STUB_DIRECT_AUTH_ID);
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DA_AUTH_DEVICE, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
} while (0);
DESTROY_IPC_CTX(callCtx);
if (ret != HC_SUCCESS) {
RemoveSdkCallBackByRequestId(authReqId, CB_TYPE_TMP_DEV_AUTH);
}
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -1306,9 +1348,9 @@ DEVICE_AUTH_API_PUBLIC int32_t CancelAuthRequest(int64_t requestId, const char *
BREAK_IF_DO_IPC_CALL_FAILED(callCtx, IPC_CALL_ID_DA_CANCEL_REQUEST, true);
DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache));
BREAK_IF_CHECK_IPC_RESULT_FAILED(replyCache, ret);
RemoveSdkCallBackByRequestId(requestId, CB_TYPE_TMP_DEV_AUTH);
} while (0);
DESTROY_IPC_CTX(callCtx);
LOGI("process done, ret: %" LOG_PUB "d", ret);
return ret;
}
@@ -1340,6 +1382,7 @@ DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService(void)
DestroyHcMutex(&g_ipcMutex);
return ret;
}
(void)InitSdkIpcCallBackList();
g_devAuthServiceStatus = true;
SetRegCallbackFunc(IpcGmRegCallbackInner);
SetRegDataChangeListenerFunc(IpcGmRegDataChangeListenerInner);
@@ -1350,6 +1393,7 @@ DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService(void)
DEVICE_AUTH_API_PUBLIC void DestroyDeviceAuthService(void)
{
UnSubscribeDeviceAuthSa();
DeInitSdkIpcCallBackList();
UnInitProxyAdapt();
DeInitISIpc();
DeInitLoadOnDemand();
frameworks/src/ipc_service_common.c
+12 -85
View File
@@ -68,7 +68,6 @@ int32_t IpcServiceGmRegCallback(const IpcDataInfo *ipcParams, int32_t paramNum,
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const DeviceAuthCallback *callback = NULL;
int32_t cbObjIdx = -1;
int32_t inOutLen;
ret = GetAndValNullParam(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL);
@@ -76,12 +75,7 @@ int32_t IpcServiceGmRegCallback(const IpcDataInfo *ipcParams, int32_t paramNum,
LOGE("IpcServiceGmRegCallback failed, get app id error.");
return HC_ERR_IPC_BAD_PARAM;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&callback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
ret = AddIpcCallBackByAppId(appId, (const uint8_t *)callback, sizeof(DeviceAuthCallback), CB_TYPE_DEV_AUTH);
ret = AddIpcCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return HC_ERROR;
@@ -125,7 +119,6 @@ int32_t IpcServiceGmRegDataChangeListener(const IpcDataInfo *ipcParams, int32_t
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 inOutLen;
@@ -134,13 +127,7 @@ int32_t IpcServiceGmRegDataChangeListener(const IpcDataInfo *ipcParams, int32_t
LOGE("IpcServiceGmRegDataChangeListener failed, get app id error.");
return HC_ERR_IPC_BAD_PARAM;
}
inOutLen = sizeof(DataChangeListener);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_LISTENER, (uint8_t *)&callback, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(DataChangeListener))) {
LOGE("get param error, type %" LOG_PUB "d", PARAM_TYPE_LISTENER);
return HC_ERR_IPC_BAD_PARAM;
}
ret = AddIpcCallBackByAppId(appId, (const uint8_t *)callback, sizeof(DataChangeListener), CB_TYPE_LISTENER);
ret = AddIpcCallBackByAppId(appId, CB_TYPE_LISTENER);
if (ret != HC_SUCCESS) {
LOGE("IpcServiceGmRegDataChangeListener failed, add ipc callback failed.");
return HC_ERROR;
@@ -149,7 +136,7 @@ int32_t IpcServiceGmRegDataChangeListener(const IpcDataInfo *ipcParams, int32_t
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_CB_OBJECT, (uint8_t *)&cbObjIdx, &inOutLen);
if (ret != HC_SUCCESS) {
LOGE("IpcServiceGmRegDataChangeListener failed, get cb object error.");
DelIpcCallBackByAppId(appId, CB_TYPE_DEV_AUTH);
DelIpcCallBackByAppId(appId, CB_TYPE_LISTENER);
return HC_ERR_IPC_BAD_PARAM;
}
AddIpcCbObjByAppId(appId, cbObjIdx, CB_TYPE_LISTENER);
@@ -879,7 +866,6 @@ int32_t IpcServiceLaStartLightAccountAuth(const IpcDataInfo *ipcParams, int32_t
int32_t osAccountId;
int64_t requestId;
const char *serviceId = NULL;
const DeviceAuthCallback *laCallBack = NULL;
inOutLen = sizeof(int32_t);
ret = GetAndValSize32Param(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen);
if (ret != HC_SUCCESS) {
@@ -894,14 +880,8 @@ int32_t IpcServiceLaStartLightAccountAuth(const IpcDataInfo *ipcParams, int32_t
if (ret != HC_SUCCESS) {
return ret;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&laCallBack, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(requestId, (const uint8_t *)laCallBack,
sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
ret = AddIpcCallBackByReqId(requestId, CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
return ret;
}
@@ -928,7 +908,6 @@ int32_t IpcServiceLaProcessLightAccountAuth(const IpcDataInfo *ipcParams, int32_
int32_t cbObjIdx = -1;
int32_t osAccountId;
int64_t requestId;
const DeviceAuthCallback *laCallBack = NULL;
inOutLen = sizeof(int32_t);
ret = GetAndValSize32Param(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen);
if (ret != HC_SUCCESS) {
@@ -947,14 +926,8 @@ int32_t IpcServiceLaProcessLightAccountAuth(const IpcDataInfo *ipcParams, int32_
return HC_ERR_IPC_BAD_PARAM;
}
DataBuff inMsgBuff = { (uint8_t *)msgVal, (uint32_t)msgLen };
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&laCallBack, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(requestId, (const uint8_t *)laCallBack,
sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
ret = AddIpcCallBackByReqId(requestId, CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
return ret;
}
@@ -1005,7 +978,6 @@ int32_t IpcServiceGmIsDeviceInGroup(const IpcDataInfo *ipcParams, int32_t paramN
LOGE("IpcServiceGmIsDeviceInGroup failed, get group id error.");
return ret;
}
bRet = g_devGroupMgrMethod.isDeviceInGroup(osAccountId, appId, groupId, udid);
callRet = ((bRet == true) ? HC_SUCCESS : HC_ERROR);
ret = IpcEncodeCallReply(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t));
@@ -1039,7 +1011,6 @@ int32_t IpcServiceGaProcessData(const IpcDataInfo *ipcParams, int32_t paramNum,
{
int32_t callRet;
int32_t ret;
const DeviceAuthCallback *gaCallback = NULL;
int64_t reqId = 0;
uint8_t *data = NULL;
uint32_t dataLen = 0;
@@ -1056,13 +1027,8 @@ int32_t IpcServiceGaProcessData(const IpcDataInfo *ipcParams, int32_t paramNum,
LOGE("IpcServiceGaProcessData failed, get comm data error.");
return HC_ERR_IPC_BAD_PARAM;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&gaCallback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(reqId, (const uint8_t *)gaCallback, sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
ret = AddIpcCallBackByReqId(reqId, CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return ret;
@@ -1086,7 +1052,6 @@ int32_t IpcServiceGaProcessData(const IpcDataInfo *ipcParams, int32_t paramNum,
int32_t IpcServiceGaAuthDevice(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t ret;
DeviceAuthCallback *gaCallback = NULL;
int32_t osAccountId;
int64_t reqId = 0;
const char *authParams = NULL;
@@ -1107,14 +1072,9 @@ int32_t IpcServiceGaAuthDevice(const IpcDataInfo *ipcParams, int32_t paramNum, u
if (ret != HC_SUCCESS) {
return ret;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&gaCallback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(reqId, (const uint8_t *)gaCallback, sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
ret = AddIpcCallBackByReqId(reqId, CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
return ret;
}
@@ -1254,7 +1214,6 @@ int32_t IpcServiceDaProcessData(const IpcDataInfo *ipcParams, int32_t paramNum,
{
int32_t callRet;
int32_t ret;
const DeviceAuthCallback *callback = NULL;
int64_t authReqId = 0;
const char *authParams = NULL;
int32_t inOutLen;
@@ -1269,13 +1228,7 @@ int32_t IpcServiceDaProcessData(const IpcDataInfo *ipcParams, int32_t paramNum,
if (ret != HC_SUCCESS) {
return ret;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&callback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
ret = AddIpcCallBackByReqId(
authReqId, (const uint8_t *)callback, sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
ret = AddIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
return ret;
}
@@ -1301,7 +1254,6 @@ int32_t IpcServiceDaAuthDevice(const IpcDataInfo *ipcParams, int32_t paramNum, u
{
int32_t callRet;
int32_t ret;
DeviceAuthCallback *callback = NULL;
int64_t authReqId = 0;
const char *authParams = NULL;
int32_t inOutLen;
@@ -1317,13 +1269,7 @@ int32_t IpcServiceDaAuthDevice(const IpcDataInfo *ipcParams, int32_t paramNum, u
LOGE("IpcServiceDaAuthDevice failed, get auth params error.");
return ret;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&callback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
ret = AddIpcCallBackByReqId(
authReqId, (const uint8_t *)callback, sizeof(DeviceAuthCallback), CB_TYPE_TMP_DEV_AUTH);
ret = AddIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return ret;
@@ -1407,7 +1353,6 @@ int32_t IpcServiceCmRegCredChangeListener(const IpcDataInfo *ipcParams, int32_t
int32_t callRet;
int32_t ret;
const char *appId = NULL;
const CredChangeListener *listener = NULL;
static int32_t registered = 0;
int32_t cbObjIdx = -1;
int32_t inOutLen = sizeof(int32_t);
@@ -1416,13 +1361,7 @@ int32_t IpcServiceCmRegCredChangeListener(const IpcDataInfo *ipcParams, int32_t
LOGE("IpcServiceCmRegCredChangeListener failed, get app id error.");
return HC_ERR_IPC_BAD_PARAM;
}
inOutLen = sizeof(CredChangeListener);
ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_LISTENER, (uint8_t *)&listener, &inOutLen);
if ((ret != HC_SUCCESS) || (inOutLen != sizeof(CredChangeListener))) {
LOGE("IpcServiceCmRegCredChangeListener failed, get listener error.");
return HC_ERR_IPC_BAD_PARAM;
}
ret = AddIpcCallBackByAppId(appId, (const uint8_t *)listener, sizeof(CredChangeListener), CB_TYPE_CRED_LISTENER);
ret = AddIpcCallBackByAppId(appId, CB_TYPE_CRED_LISTENER);
if (ret != HC_SUCCESS) {
LOGE("add ipc listener failed");
return HC_ERROR;
@@ -1728,7 +1667,6 @@ int32_t IpcServiceCmBatchUpdateCredentials(const IpcDataInfo *ipcParams, int32_t
int32_t IpcServiceCaAuthCredential(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache)
{
int32_t ret;
DeviceAuthCallback *caCallback = NULL;
int32_t osAccountId;
int64_t reqId = 0;
const char *authParams = NULL;
@@ -1750,13 +1688,8 @@ int32_t IpcServiceCaAuthCredential(const IpcDataInfo *ipcParams, int32_t paramNu
if (ret != HC_SUCCESS) {
return ret;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&caCallback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(reqId, (const uint8_t *)caCallback, sizeof(DeviceAuthCallback), CB_TYPE_CRED_DEV_AUTH);
ret = AddIpcCallBackByReqId(reqId, CB_TYPE_CRED_DEV_AUTH);
if (ret != HC_SUCCESS) {
return ret;
}
@@ -1781,7 +1714,6 @@ int32_t IpcServiceCaProcessCredData(const IpcDataInfo *ipcParams, int32_t paramN
{
int32_t callRet;
int32_t ret;
const DeviceAuthCallback *caCallback = NULL;
int64_t reqId = 0;
uint8_t *data = NULL;
uint32_t dataLen = 0;
@@ -1797,13 +1729,8 @@ int32_t IpcServiceCaProcessCredData(const IpcDataInfo *ipcParams, int32_t paramN
LOGE("IpcServiceCaProcessCredData failed, get comm data error.");
return HC_ERR_IPC_BAD_PARAM;
}
inOutLen = sizeof(DeviceAuthCallback);
ret = GetAndValSizeCbParam(ipcParams, paramNum, PARAM_TYPE_DEV_AUTH_CB, (uint8_t *)&caCallback, &inOutLen);
if (ret != HC_SUCCESS) {
return ret;
}
/* add call back */
ret = AddIpcCallBackByReqId(reqId, (const uint8_t *)caCallback, sizeof(DeviceAuthCallback), CB_TYPE_CRED_DEV_AUTH);
ret = AddIpcCallBackByReqId(reqId, CB_TYPE_CRED_DEV_AUTH);
if (ret != HC_SUCCESS) {
LOGE("add ipc callback failed");
return ret;
frameworks/src/lite/ipc_adapt.c
+624 -314
View File
File diff suppressed because it is too large Load Diff
frameworks/src/lite/ipc_callback_proxy.c
+1 -2
View File
@@ -46,7 +46,7 @@ static void CbProxyFormReplyData(int32_t reqRetVal, IpcIo *replyDst, const IpcIo
return;
}
void CbProxySendRequest(SvcIdentity sid, int32_t callbackId, uintptr_t cbHook, IpcIo *data, IpcIo *reply)
void CbProxySendRequest(SvcIdentity sid, int32_t callbackId, IpcIo *data, IpcIo *reply)
{
int32_t ret;
IpcIo *reqData = NULL;
@@ -60,7 +60,6 @@ void CbProxySendRequest(SvcIdentity sid, int32_t callbackId, uintptr_t cbHook, I
return;
}
WriteInt32(reqData, callbackId);
WritePointer(reqData, cbHook);
dataSz = GetIpcIoDataLength((const IpcIo *)data);
LOGI("to form callback params data length(%" LOG_PUB "d)", dataSz);
if (dataSz > 0) {
frameworks/src/lite/ipc_callback_stub.c
+3 -10
View File
@@ -26,17 +26,12 @@
extern "C" {
#endif
static void DoCallBack(int32_t callbackId, uintptr_t cbHook, IpcIo *data, IpcIo *reply)
static void DoCallBack(int32_t callbackId, IpcIo *data, IpcIo *reply)
{
int32_t ret;
int32_t i;
IpcDataInfo cbDataCache[MAX_REQUEST_PARAMS_NUM] = { { 0 } };
if (cbHook == 0x0) {
LOGE("Invalid call back hook");
return;
}
uint32_t len = 0;
ReadUint32(data, &len); /* skip flat object length information */
for (i = 0; i < MAX_REQUEST_PARAMS_NUM; i++) {
@@ -47,7 +42,7 @@ static void DoCallBack(int32_t callbackId, uintptr_t cbHook, IpcIo *data, IpcIo
return;
}
}
ProcCbHook(callbackId, cbHook, cbDataCache, MAX_REQUEST_PARAMS_NUM, (uintptr_t)(reply));
ProcCbHook(callbackId, cbDataCache, MAX_REQUEST_PARAMS_NUM, (uintptr_t)(reply));
return;
}
@@ -55,7 +50,6 @@ int32_t CbStubOnRemoteRequest(uint32_t code, IpcIo *data, IpcIo *reply, MessageO
{
(void)option;
int32_t callbackId;
uintptr_t cbHook = 0x0;
LOGI("enter invoking callback...");
if (data == NULL) {
@@ -67,8 +61,7 @@ int32_t CbStubOnRemoteRequest(uint32_t code, IpcIo *data, IpcIo *reply, MessageO
switch (code) {
case DEV_AUTH_CALLBACK_REQUEST:
ReadInt32(data, &callbackId);
cbHook = ReadPointer(data);
DoCallBack(callbackId, cbHook, data, reply);
DoCallBack(callbackId, data, reply);
break;
default:
LOGE("Invoke callback cmd code(%" LOG_PUB "u) error", code);
frameworks/src/lite/ipc_dev_auth_stub.c
+2 -2
View File
@@ -345,7 +345,7 @@ void ResetRemoteObject(int32_t idx)
return;
}
void ActCallback(int32_t objIdx, int32_t callbackId, uintptr_t cbHook, IpcIo *dataParcel, IpcIo *reply)
void ActCallback(int32_t objIdx, int32_t callbackId, IpcIo *dataParcel, IpcIo *reply)
{
if ((objIdx < 0) || (objIdx >= MAX_CBSTUB_SIZE) || (!g_cbStub[objIdx].inUse)) {
LOGW("nothing to do, callback id %" LOG_PUB "d, remote object id %" LOG_PUB "d", callbackId, objIdx);
@@ -354,7 +354,7 @@ void ActCallback(int32_t objIdx, int32_t callbackId, uintptr_t cbHook, IpcIo *da
ShowIpcSvcInfo(&g_cbStub[objIdx].cbStub);
LockCbStubTable();
CbProxySendRequest(g_cbStub[objIdx].cbStub, callbackId, cbHook, dataParcel, reply);
CbProxySendRequest(g_cbStub[objIdx].cbStub, callbackId, dataParcel, reply);
UnLockCbStubTable();
return;
}
frameworks/src/standard/ipc_adapt.cpp
+738 -393
View File
File diff suppressed because it is too large Load Diff
frameworks/src/standard/ipc_callback_proxy.cpp
+1 -2
View File
@@ -25,7 +25,7 @@ ProxyDevAuthCb::ProxyDevAuthCb(const sptr<IRemoteObject> &impl) : IRemoteProxy<I
ProxyDevAuthCb::~ProxyDevAuthCb()
{}
void ProxyDevAuthCb::DoCallBack(int32_t callbackId, uintptr_t cbHook,
void ProxyDevAuthCb::DoCallBack(int32_t callbackId,
MessageParcel &dataParcel, MessageParcel &reply, MessageOption &option)
{
int32_t ret;
@@ -41,7 +41,6 @@ void ProxyDevAuthCb::DoCallBack(int32_t callbackId, uintptr_t cbHook,
return;
}
(void)data.WriteInt32(callbackId);
(void)data.WritePointer(cbHook);
if (dataParcel.GetDataSize() > 0) {
(void)data.WriteBuffer(reinterpret_cast<const void *>(dataParcel.GetData()), dataParcel.GetDataSize());
}
frameworks/src/standard/ipc_callback_stub.cpp
+3 -10
View File
@@ -27,7 +27,7 @@ StubDevAuthCb::StubDevAuthCb()
StubDevAuthCb::~StubDevAuthCb()
{}
void StubDevAuthCb::DoCallBack(int32_t callbackId, uintptr_t cbHook,
void StubDevAuthCb::DoCallBack(int32_t callbackId,
MessageParcel &dataParcel, MessageParcel &reply, MessageOption &option)
{
int32_t ret;
@@ -35,11 +35,6 @@ void StubDevAuthCb::DoCallBack(int32_t callbackId, uintptr_t cbHook,
MessageParcel retParcel;
IpcDataInfo cbDataCache[MAX_REQUEST_PARAMS_NUM] = { { 0 } };
if (cbHook == 0x0) {
LOGE("Invalid call back hook");
return;
}
for (i = 0; i < MAX_REQUEST_PARAMS_NUM; i++) {
ret = DecodeIpcData(reinterpret_cast<uintptr_t>(&dataParcel), &(cbDataCache[i].type),
&(cbDataCache[i].val), &(cbDataCache[i].valSz));
@@ -48,7 +43,7 @@ void StubDevAuthCb::DoCallBack(int32_t callbackId, uintptr_t cbHook,
return;
}
}
ProcCbHook(callbackId, cbHook, cbDataCache, MAX_REQUEST_PARAMS_NUM, reinterpret_cast<uintptr_t>(&reply));
ProcCbHook(callbackId, cbDataCache, MAX_REQUEST_PARAMS_NUM, reinterpret_cast<uintptr_t>(&reply));
return;
}
@@ -60,7 +55,6 @@ int32_t StubDevAuthCb::OnRemoteRequest(uint32_t code,
return -1;
}
int32_t callbackId;
uintptr_t cbHook = 0x0;
switch (code) {
case static_cast<uint32_t>(DevAuthCbInterfaceCode::DEV_AUTH_CALLBACK_REQUEST):
@@ -69,8 +63,7 @@ int32_t StubDevAuthCb::OnRemoteRequest(uint32_t code,
return -1;
}
callbackId = data.ReadInt32();
cbHook = data.ReadPointer();
StubDevAuthCb::DoCallBack(callbackId, cbHook, data, reply, option);
StubDevAuthCb::DoCallBack(callbackId, data, reply, option);
break;
default:
LOGE("Invoke call back cmd id error, %" LOG_PUB "u", code);
frameworks/src/standard/ipc_dev_auth_stub.cpp
+2 -2
View File
@@ -423,7 +423,7 @@ void ServiceDevAuth::ResetRemoteObject(int32_t idx)
}
void ServiceDevAuth::ActCallback(int32_t objIdx, int32_t callbackId, bool sync,
uintptr_t cbHook, MessageParcel &dataParcel, MessageParcel &reply)
MessageParcel &dataParcel, MessageParcel &reply)
{
std::lock_guard<std::mutex> autoLock(g_cBMutex);
if ((objIdx < 0) || (objIdx >= MAX_CBSTUB_SIZE) || (!g_cbStub[objIdx].inUse)) {
@@ -435,7 +435,7 @@ void ServiceDevAuth::ActCallback(int32_t objIdx, int32_t callbackId, bool sync,
option.SetFlags(MessageOption::TF_ASYNC);
}
sptr<ICommIpcCallback> proxy = iface_cast<ICommIpcCallback>(g_cbStub[objIdx].cbStub);
proxy->DoCallBack(callbackId, cbHook, dataParcel, reply, option);
proxy->DoCallBack(callbackId, dataParcel, reply, option);
return;
}
interfaces/inner_api/device_auth_defines.h
+1
View File
@@ -81,6 +81,7 @@ enum {
HC_ERR_IPC_GET_SAMGR_FAILED = 0x00003016, // 12310
HC_ERR_IPC_LOAD_SA_FAILED = 0x00003017, // 12311
HC_ERR_IPC_SA_IS_UNLOADING = 0x00003018, // 12312
HC_ERR_IPC_CALLBACK_NOT_MATCH = 0x00003019, // 12313
/* error code for module , 0x00004000 ~ 0x00004FFF */
HC_ERR_MODULE_NOT_FOUNT = 0x00004001, // 16385
test/fuzztest/devauthinterface_fuzzer/devauthinterface_fuzzer.cpp
+4 -4
View File
@@ -361,9 +361,9 @@ static void DevAuthInterfaceTestCase005()
(void)InitIpcCallBackList();
AddIpcCbObjByAppId(TEST_APP_ID, 0, 0);
DeInitIpcCallBackList();
AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
AddIpcCallBackByAppId(TEST_APP_ID, 0);
(void)InitIpcCallBackList();
AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
AddIpcCallBackByAppId(TEST_APP_ID, 0);
DeInitIpcCallBackList();
DelIpcCallBackByAppId(TEST_APP_ID, 0);
(void)InitIpcCallBackList();
@@ -377,9 +377,9 @@ static void DevAuthInterfaceTestCase005()
(void)InitIpcCallBackList();
AddIpcCbObjByReqId(TEST_REQ_ID, 0, 0);
DeInitIpcCallBackList();
(void)AddIpcCallBackByReqId(TEST_REQ_ID, nullptr, 0, 0);
(void)AddIpcCallBackByReqId(TEST_REQ_ID, 0);
(void)InitIpcCallBackList();
(void)AddIpcCallBackByReqId(TEST_REQ_ID, nullptr, 0, 0);
(void)AddIpcCallBackByReqId(TEST_REQ_ID, 0);
DeInitIpcCallBackList();
DelIpcCallBackByReqId(TEST_REQ_ID, 0, true);
DelIpcCallBackByReqId(TEST_REQ_ID, 0, false);
test/fuzztest/group_auth/authdevice_fuzzer/authdevice_fuzzer.cpp
+2
View File
@@ -57,6 +57,7 @@ namespace OHOS {
bool FuzzDoAuthDevice(const uint8_t* data, size_t size)
{
(void)InitDeviceAuthService();
const GroupAuthManager *gaInstance = GetGaInstance();
if (gaInstance == nullptr) {
return false;
@@ -78,6 +79,7 @@ namespace OHOS {
gaCallback.onTransmit = OnTransmit;
gaCallback.onRequest = OnRequest;
gaInstance->authDevice(osAccountId, authReqId, authParams.c_str(), &gaCallback);
DestroyDeviceAuthService();
return true;
}
}
test/fuzztest/group_auth/processauthdata_fuzzer/processauthdata_fuzzer.cpp
+2
View File
@@ -57,6 +57,7 @@ namespace OHOS {
bool FuzzDoProcessData(const uint8_t* data, size_t size)
{
(void)InitDeviceAuthService();
const GroupAuthManager *gaInstance = GetGaInstance();
if (gaInstance == nullptr) {
return false;
@@ -76,6 +77,7 @@ namespace OHOS {
gaCallback.onTransmit = OnTransmit;
gaCallback.onRequest = OnRequest;
gaInstance->processData(authReqId, data, (uint32_t)size, &gaCallback);
DestroyDeviceAuthService();
return true;
}
}
test/fuzztest/group_manage/addmember_fuzzer/addmember_fuzzer.cpp
+2
View File
@@ -19,6 +19,7 @@
namespace OHOS {
bool FuzzDoAddMemberToGroup(const uint8_t* data, size_t size)
{
(void)InitDeviceAuthService();
const DeviceGroupManager *gmInstance = GetGmInstance();
if (gmInstance == nullptr) {
return false;
@@ -37,6 +38,7 @@ namespace OHOS {
std::string appId(fdp.ConsumeBytesAsString(appIdLen));
std::string addParams(fdp.ConsumeBytesAsString(addParamsLen));
gmInstance->addMemberToGroup(osAccountId, requestId, appId.c_str(), addParams.c_str());
DestroyDeviceAuthService();
return true;
}
}
test/fuzztest/group_manage/creategroup_fuzzer/creategroup_fuzzer.cpp
+2
View File
@@ -19,6 +19,7 @@
namespace OHOS {
bool FuzzDoCreateGroup(const uint8_t* data, size_t size)
{
(void)InitDeviceAuthService();
const DeviceGroupManager *gmInstance = GetGmInstance();
if (gmInstance == nullptr) {
return false;
@@ -37,6 +38,7 @@ namespace OHOS {
std::string appId(fdp.ConsumeBytesAsString(appIdLen));
std::string createParams(fdp.ConsumeBytesAsString(createParamsLen));
gmInstance->createGroup(osAccountId, requestId, appId.c_str(), createParams.c_str());
DestroyDeviceAuthService();
return true;
}
}
test/fuzztest/group_manage/deletegroup_fuzzer/deletegroup_fuzzer.cpp
+2
View File
@@ -19,6 +19,7 @@
namespace OHOS {
bool FuzzDoDeleteGroup(const uint8_t* data, size_t size)
{
(void)InitDeviceAuthService();
const DeviceGroupManager *gmInstance = GetGmInstance();
if (gmInstance == nullptr) {
return false;
@@ -37,6 +38,7 @@ namespace OHOS {
std::string appId(fdp.ConsumeBytesAsString(appIdLen));
std::string deleteParams(fdp.ConsumeBytesAsString(createParamsLen));
gmInstance->deleteGroup(osAccountId, requestId, appId.c_str(), deleteParams.c_str());
DestroyDeviceAuthService();
return true;
}
}
test/fuzztest/group_manage/deletemember_fuzzer/deletemember_fuzzer.cpp
+2
View File
@@ -19,6 +19,7 @@
namespace OHOS {
bool FuzzDoDeleteMember(const uint8_t* data, size_t size)
{
(void)InitDeviceAuthService();
const DeviceGroupManager *gmInstance = GetGmInstance();
if (gmInstance == nullptr) {
return false;
@@ -37,6 +38,7 @@ namespace OHOS {
std::string appId(fdp.ConsumeBytesAsString(appIdLen));
std::string deleteParams(fdp.ConsumeBytesAsString(deleteParamsLen));
gmInstance->deleteMemberFromGroup(osAccountId, requestId, appId.c_str(), deleteParams.c_str());
DestroyDeviceAuthService();
return true;
}
}
test/fuzztest/saloadondemand_fuzzer/saloadondemand_fuzzer.cpp
+2 -175
View File
@@ -25,127 +25,6 @@
#include "base/security/device_auth/frameworks/sdk/sa_load_on_demand/src/sa_load_on_demand.cpp"
namespace OHOS {
#define TEST_APP_ID "TestUserId"
#define TEST_APP_ID_1 "TestUserId1"
static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
{
(void)requestId;
(void)operationCode;
(void)errorCode;
(void)errorReturn;
}
static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
{
(void)requestId;
(void)operationCode;
(void)authReturn;
}
static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
{
(void)requestId;
(void)sessionKey;
(void)sessionKeyLen;
}
static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
{
(void)requestId;
(void)data;
(void)dataLen;
return true;
}
static char *OnRequest(int64_t requestId, int operationCode, const char *reqParam)
{
(void)requestId;
(void)operationCode;
(void)reqParam;
return nullptr;
}
static void OnGroupCreated(const char *groupInfo)
{
(void)groupInfo;
}
static void OnGroupDeleted(const char *groupInfo)
{
(void)groupInfo;
}
static void OnDeviceBound(const char *peerUdid, const char *groupInfo)
{
(void)peerUdid;
(void)groupInfo;
}
static void OnDeviceUnBound(const char *peerUdid, const char *groupInfo)
{
(void)peerUdid;
(void)groupInfo;
}
static void OnDeviceNotTrusted(const char *peerUdid)
{
(void)peerUdid;
}
static void OnLastGroupDeleted(const char *peerUdid, int groupType)
{
(void)peerUdid;
(void)groupType;
}
static void OnTrustedDeviceNumChanged(int curTrustedDeviceNum)
{
(void)curTrustedDeviceNum;
}
static void TestOnCredAdd(const char *credId, const char *credInfo)
{
(void)credId;
(void)credInfo;
}
static void TestOnCredUpdate(const char *credId, const char *credInfo)
{
(void)credId;
(void)credInfo;
}
static void TestOnCredDelete(const char *credId, const char *credInfo)
{
(void)credId;
(void)credInfo;
}
static DeviceAuthCallback g_gmCallback = {
.onTransmit = OnTransmit,
.onSessionKeyReturned = OnSessionKeyReturned,
.onFinish = OnFinish,
.onError = OnError,
.onRequest = OnRequest,
};
static DataChangeListener g_listener = {
.onGroupCreated = OnGroupCreated,
.onGroupDeleted = OnGroupDeleted,
.onDeviceBound = OnDeviceBound,
.onDeviceUnBound = OnDeviceUnBound,
.onDeviceNotTrusted = OnDeviceNotTrusted,
.onLastGroupDeleted = OnLastGroupDeleted,
.onTrustedDeviceNumChanged = OnTrustedDeviceNumChanged,
};
static CredChangeListener g_credChangeListener = {
.onCredAdd = TestOnCredAdd,
.onCredDelete = TestOnCredDelete,
.onCredUpdate = TestOnCredUpdate,
};
static int32_t regCallbackMock(const char *appId, const DeviceAuthCallback *callback, bool needCache)
{
@@ -179,69 +58,17 @@ static void SaLoadOnDemandFuzz001(void)
RegisterDevAuthCallbackIfNeed();
}
static void SaLoadOnDemandFuzz002(void)
{
SetRegCallbackFunc(regCallbackMock);
SetRegDataChangeListenerFunc(regDataChangeListenerMock);
SetRegCredChangeListenerFunc(regCredChangeListenerMock);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, DEVAUTH_CALLBACK);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, GROUP_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, CRED_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, DEVAUTH_CALLBACK);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, GROUP_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, CRED_CHANGE_LISTENER);
}
static void SaLoadOnDemandFuzz003(void)
{
SetRegCallbackFunc(regCallbackMock);
SetRegDataChangeListenerFunc(regDataChangeListenerMock);
SetRegCredChangeListenerFunc(regCredChangeListenerMock);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, DEVAUTH_CALLBACK);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, DEVAUTH_CALLBACK);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, GROUP_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, GROUP_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, CRED_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, CRED_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, DEVAUTH_CALLBACK);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, GROUP_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, CRED_CHANGE_LISTENER);
}
static void SaLoadOnDemandFuzz004(void)
{
SetRegCallbackFunc(regCallbackMock);
SetRegDataChangeListenerFunc(regDataChangeListenerMock);
SetRegCredChangeListenerFunc(regCredChangeListenerMock);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, DEVAUTH_CALLBACK);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, GROUP_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID, &g_gmCallback, &g_listener, &g_credChangeListener, CRED_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID_1, &g_gmCallback, &g_listener, &g_credChangeListener, DEVAUTH_CALLBACK);
(void)AddCallbackInfoToList(TEST_APP_ID_1, &g_gmCallback, &g_listener, &g_credChangeListener,
GROUP_CHANGE_LISTENER);
(void)AddCallbackInfoToList(TEST_APP_ID_1, &g_gmCallback, &g_listener, &g_credChangeListener,
CRED_CHANGE_LISTENER);
RegisterDevAuthCallback();
(void)RemoveCallbackInfoFromList(TEST_APP_ID, DEVAUTH_CALLBACK);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, GROUP_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID, CRED_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID_1, DEVAUTH_CALLBACK);
(void)RemoveCallbackInfoFromList(TEST_APP_ID_1, GROUP_CHANGE_LISTENER);
(void)RemoveCallbackInfoFromList(TEST_APP_ID_1, CRED_CHANGE_LISTENER);
}
bool FuzzDoSaLoadOnDemandFuzz(const uint8_t* data, size_t size)
{
(void)data;
(void)size;
(void)InitLoadOnDemand();
(void)InitSdkIpcCallBackList();
SubscribeDeviceAuthSa();
SaLoadOnDemandFuzz001();
SaLoadOnDemandFuzz002();
SaLoadOnDemandFuzz003();
SaLoadOnDemandFuzz004();
UnSubscribeDeviceAuthSa();
DeInitLoadOnDemand();
DeInitSdkIpcCallBackList();
return true;
}
}
test/unittest/deviceauth/source/deviceauth_interface_test.cpp
+5 -5
View File
@@ -433,9 +433,9 @@ HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest005, TestSize.Level0)
(void)InitIpcCallBackList();
AddIpcCbObjByAppId(TEST_APP_ID, 0, 0);
DeInitIpcCallBackList();
AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
AddIpcCallBackByAppId(TEST_APP_ID, 0);
(void)InitIpcCallBackList();
AddIpcCallBackByAppId(TEST_APP_ID, nullptr, 0, 0);
AddIpcCallBackByAppId(TEST_APP_ID, 0);
DeInitIpcCallBackList();
DelIpcCallBackByAppId(TEST_APP_ID, 0);
(void)InitIpcCallBackList();
@@ -451,11 +451,11 @@ HWTEST_F(DeviceAuthInterfaceTest, DeviceAuthInterfaceTest005, TestSize.Level0)
(void)InitIpcCallBackList();
AddIpcCbObjByReqId(123, 0, 0);
DeInitIpcCallBackList();
res = AddIpcCallBackByReqId(123, nullptr, 0, 0);
res = AddIpcCallBackByReqId(123, 0);
ASSERT_NE(res, HC_SUCCESS);
(void)InitIpcCallBackList();
res = AddIpcCallBackByReqId(123, nullptr, 0, 0);
ASSERT_NE(res, HC_SUCCESS);
res = AddIpcCallBackByReqId(123, 0);
ASSERT_EQ(res, HC_SUCCESS);
DeInitIpcCallBackList();
DelIpcCallBackByReqId(123, 0, true);
DelIpcCallBackByReqId(123, 0, false);
test/unittest/deviceauth/source/ipc_adapt_test.cpp
+106 -26
View File
@@ -21,6 +21,10 @@
using namespace testing::ext;
namespace {
#define TEST_APP_ID "TestUserId"
#define TEST_APP_ID_1 "TestUserId1"
#define TEST_REQUEST_ID 121231231
class IpcAdaptParamTest : public testing::Test {
public:
IpcAdaptParamTest() = default; // 显式声明默认构造函数
@@ -291,21 +295,8 @@ void IpcDevAuthCredListenerTest::TearDown()
// 添加凭据监听器回调
static void AddCredListenerCallback()
{
CredChangeListener credListener = {
.onCredAdd = nullptr,
.onCredDelete = nullptr,
.onCredUpdate = nullptr
};
IpcDataInfo testParams[1];
testParams[0].type = CB_TYPE_CRED_LISTENER;
testParams[0].val = reinterpret_cast<uint8_t *>(&credListener);
testParams[0].valSz = sizeof(credListener);
testParams[0].idx = 0;
// 添加凭据监听器
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
}
// 测试 InitDevAuthCredListenerCbCtx 函数
@@ -335,8 +326,7 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredAdd_Valid, TestSize.Level
InitDevAuthCredListenerCbCtx(&credListener);
// 更新回调
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
// 添加回调对象
AddIpcCbObjByAppId("test.app.id", 0, CB_TYPE_CRED_LISTENER);
@@ -359,8 +349,7 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredAdd_NullCredId, TestSize.
InitDevAuthCredListenerCbCtx(&credListener);
// 更新回调
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
// 添加回调对象
AddIpcCbObjByAppId("test.app.id", 0, CB_TYPE_CRED_LISTENER);
@@ -382,8 +371,7 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredDelete_Valid, TestSize.Le
InitDevAuthCredListenerCbCtx(&credListener);
// 更新回调
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
// 添加回调对象
AddIpcCbObjByAppId("test.app.id", 0, CB_TYPE_CRED_LISTENER);
@@ -406,8 +394,7 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredDelete_NullCredId, TestSi
InitDevAuthCredListenerCbCtx(&credListener);
// 更新回调
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
// 添加回调对象
AddIpcCbObjByAppId("test.app.id", 0, CB_TYPE_CRED_LISTENER);
@@ -429,8 +416,7 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredUpdate_Valid, TestSize.Le
InitDevAuthCredListenerCbCtx(&credListener);
// 更新回调
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
// 添加回调对象
AddIpcCbObjByAppId("test.app.id", 0, CB_TYPE_CRED_LISTENER);
@@ -453,8 +439,7 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredUpdate_NullCredId, TestSi
InitDevAuthCredListenerCbCtx(&credListener);
// 更新回调
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", reinterpret_cast<const uint8_t *>(&credListener),
sizeof(credListener), CB_TYPE_CRED_LISTENER));
ASSERT_EQ(HC_SUCCESS, AddIpcCallBackByAppId("test.app.id", CB_TYPE_CRED_LISTENER));
// 添加回调对象
AddIpcCbObjByAppId("test.app.id", 0, CB_TYPE_CRED_LISTENER);
@@ -464,4 +449,99 @@ HWTEST_F(IpcDevAuthCredListenerTest, CredListenerOnCredUpdate_NullCredId, TestSi
credListener.onCredUpdate(nullptr, "test_cred_info");
}
}
static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn)
{
(void)requestId;
(void)operationCode;
(void)errorCode;
(void)errorReturn;
}
static void OnFinish(int64_t requestId, int operationCode, const char *authReturn)
{
(void)requestId;
(void)operationCode;
(void)authReturn;
}
static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen)
{
(void)requestId;
(void)sessionKey;
(void)sessionKeyLen;
}
static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen)
{
(void)requestId;
(void)data;
(void)dataLen;
return true;
}
static char *OnRequest(int64_t requestId, int operationCode, const char *reqParam)
{
(void)requestId;
(void)operationCode;
(void)reqParam;
return nullptr;
}
static DeviceAuthCallback g_gmCallback = {
.onTransmit = OnTransmit,
.onSessionKeyReturned = OnSessionKeyReturned,
.onFinish = OnFinish,
.onError = OnError,
.onRequest = OnRequest,
};
class SdkIpcDevAuthCredListenerTest : public testing::Test {
public:
SdkIpcDevAuthCredListenerTest() = default; // 显式声明默认构造函数
~SdkIpcDevAuthCredListenerTest() = default; // 显式声明默认析构函数
void SetUp();
void TearDown();
};
void SdkIpcDevAuthCredListenerTest::SetUp()
{
// 初始化回调列表
ASSERT_EQ(HC_SUCCESS, InitSdkIpcCallBackList());
}
void SdkIpcDevAuthCredListenerTest::TearDown()
{
// 清理回调列表
DeInitSdkIpcCallBackList();
}
// 测试 InitDevAuthCredListenerCbCtx 函数
HWTEST_F(SdkIpcDevAuthCredListenerTest, InitDevAuthCredListenerCbCtx_Valid, TestSize.Level0)
{
int32_t ret = AddSdkCallBackByAppId(TEST_APP_ID, CB_TYPE_DEV_AUTH, reinterpret_cast<uint8_t *>(&g_gmCallback),
sizeof(DeviceAuthCallback));
EXPECT_EQ(ret, HC_SUCCESS);
ret = AddSdkCallBackByAppId(TEST_APP_ID, CB_TYPE_DEV_AUTH, reinterpret_cast<uint8_t *>(&g_gmCallback),
sizeof(DeviceAuthCallback));
EXPECT_EQ(ret, HC_SUCCESS);
ret = AddSdkCallBackByRequestId(TEST_REQUEST_ID, CB_TYPE_DEV_AUTH, reinterpret_cast<uint8_t *>(&g_gmCallback),
sizeof(DeviceAuthCallback));
EXPECT_EQ(ret, HC_SUCCESS);
ret = AddSdkCallBackByRequestId(TEST_REQUEST_ID, CB_TYPE_DEV_AUTH, reinterpret_cast<uint8_t *>(&g_gmCallback),
sizeof(DeviceAuthCallback));
EXPECT_EQ(ret, HC_SUCCESS);
(void)RemoveSdkCallBackByAppId(TEST_APP_ID, CB_TYPE_DEV_AUTH);
ret = AddSdkCallBackByAppId(TEST_APP_ID_1, CB_TYPE_DEV_AUTH, reinterpret_cast<uint8_t *>(&g_gmCallback),
sizeof(DeviceAuthCallback));
EXPECT_EQ(ret, HC_SUCCESS);
ret = AddRequestIdByAppId(TEST_APP_ID, TEST_REQUEST_ID);
EXPECT_NE(ret, HC_SUCCESS);
ret = AddRequestIdByAppId(TEST_APP_ID_1, TEST_REQUEST_ID);
EXPECT_EQ(ret, HC_SUCCESS);
(void)RemoveSdkCallBackByAppId(TEST_APP_ID_1, CB_TYPE_DEV_AUTH);
(void)RemoveSdkCallBackByRequestId(TEST_REQUEST_ID, CB_TYPE_DEV_AUTH);
}
}