openharmony/communication_dsoftbus
1
0
Fork 0
mirror of https://gitee.com/openharmony/communication_dsoftbus synced 2025-03-04 17:17:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
gouwenbo 2024-05-07 16:25:44 +08:00
commit f712462eb6
96 changed files with 4204 additions and 295 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
CODEOWNERS
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 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
@ -14,117 +14,117 @@
*/
[Arch]
adapter/default_config/ zhangchunxin@huawei.com
BUILD.gn zhangchunxin@huawei.com
bundle.json zhangchunxin@huawei.com
config.py zhangchunxin@huawei.com
dsoftbus.gni zhangchunxin@huawei.com
Kconfig zhangchunxin@huawei.com
adapter/default_config/ liufeihu@huawei.com
BUILD.gn liufeihu@huawei.com
bundle.json liufeihu@huawei.com
config.py liufeihu@huawei.com
dsoftbus.gni liufeihu@huawei.com
Kconfig liufeihu@huawei.com
[Misc]
figures/ zhangchunxin@huawei.com
.clang-format zhangchunxin@huawei.com
.gitignore zhangchunxin@huawei.com
CODEOWNERS zhangchunxin@huawei.com
hisysevent.yaml zhangchunxin@huawei.com
OAT.xml zhangchunxin@huawei.com
README.md zhangchunxin@huawei.com
README_zh.md zhangchunxin@huawei.com
CODEOWNERS zhangchunxin@huawei.com
[Conn]
adapter/common/net/bluetooth/ songzhengteng@huawei.com
core/adapter/br/ songzhengteng@huawei.com
adapter/common/net/bluetooth/ wangjingen1@huawei.com
core/adapter/br/ wangjingen1@huawei.com
core/connection/ songzhengteng@huawei.com
tests/adapter/bluetooth/ songzhengteng@huawei.com
core/connection/ble/ wangjingen1@huawei.com
core/connection/br/ wangjingen1@huawei.com
core/connection/wifi_direct/ wuchunbo1@huawei.com
core/connection/wifi_direct_cpp/ wuchunbo1@huawei.com
tests/adapter/bluetooth/ wangjingen1@huawei.com
tests/adapter/fuzztest/softbussocketrecv_fuzzer/ songzhengteng@huawei.com
tests/adapter/unittest/softbus_wifi_api_test.cpp songzhengteng@huawei.com
tests/adapter/unittest/softbus_socket_test.cpp songzhengteng@huawei.com
tests/core/connection/ songzhengteng@huawei.com
tests/core/connection/ songzhengteng@huawei.com
tests/core/connection/ble/ wangjingen1@huawei.com
tests/core/connection/br/ wangjingen1@huawei.com
tests/core/connection/wifi_direct/ wuchunbo1@huawei.com
tests/core/connection/wifi_direct_cpp/ wuchunbo1@huawei.com
[Disc]
adapter/common/range/ liufeihu@huawei.com
core/discovery/ liufeihu@huawei.com
sdk/discovery/ liufeihu@huawei.com
tests/adapter/fuzztest/softbusadapterrange_fuzzer/ liufeihu@huawei.com
tests/adapter/unittest/softbus_adapter_range_test.cpp liufeihu@huawei.com
tests/core/discovery/ liufeihu@huawei.com
tests/sdk/discovery/ liufeihu@huawei.com
adapter/common/range/ fanjingya1@huawei.com
core/discovery/ fanjingya1@huawei.com
sdk/discovery/ fanjingya1@huawei.com
tests/adapter/fuzztest/softbusadapterrange_fuzzer/ fanjingya1@huawei.com
tests/adapter/unittest/softbus_adapter_range_test.cpp fanjingya1@huawei.com
tests/core/discovery/ fanjingya1@huawei.com
tests/sdk/discovery/ fanjingya1@huawei.com
[DiscInterface]
interfaces/kits/discovery/ liufeihu@huawei.com
interfaces/kits/discovery/ fanjingya1@huawei.com
[Lnn]
adapter/common/bus_center/ zhangshaojie3@huawei.com
adapter/common/net/hdi/ zhangshaojie3@huawei.com
adapter/common/net/wifi/ zhangshaojie3@huawei.com
adapter/common/perf/ zhangshaojie3@huawei.com
core/adapter/authentication/ zhangshaojie3@huawei.com
adapter/common/net/hdi/ fengyonghui@huawei.com
adapter/common/net/wifi/ fengyonghui@huawei.com
adapter/common/perf/ fengyonghui@huawei.com
core/adapter/authentication/ chenbotong1@huawei.com
core/adapter/bus_center/ zhangshaojie3@huawei.com
core/authentication/ zhangshaojie3@huawei.com
core/authentication/ chenbotong1@huawei.com
core/bus_center/ zhangshaojie3@huawei.com
sdk/bus_center/ zhangshaojie3@huawei.com
tests/adapter/unittest/softbus_adapter_wlan_extend_test.cpp zhangshaojie3@huawei.com
sdk/bus_center/ fengyonghui@huawei.com
tests/adapter/unittest/softbus_adapter_wlan_extend_test.cpp fengyonghui@huawei.com
tests/core/adapter/unittest/bus_center_adapter_test.cpp zhangshaojie3@huawei.com
tests/core/adapter/unittest/lnn_settingdata_event_monitor_test.cpp zhangshaojie3@huawei.com
tests/core/authentication/ zhangshaojie3@huawei.com
tests/core/authentication/ chenbotong1@huawei.com
tests/core/bus_center/ zhangshaojie3@huawei.com
tests/sdk/bus_center/ zhangshaojie3@huawei.com
tests/sdk/bus_center/ fengyonghui@huawei.com
[LnnInterface]
interfaces/kits/bus_center/ zhangshaojie3@huawei.com
[Trans]
core/adapter/transmission/ zhangchunxin@huawei.com
core/transmission/ zhangchunxin@huawei.com
sdk/transmission/ zhangchunxin@huawei.com
tests/core/transmission/ zhangchunxin@huawei.com
tests/sdk/transmission/ zhangchunxin@huawei.com
core/adapter/transmission/ jiazhenyu1@huawei.com
core/transmission/ jiazhenyu1@huawei.com
sdk/transmission/ jiazhenyu1@huawei.com
tests/core/transmission/ jiazhenyu1@huawei.com
tests/sdk/transmission/ jiazhenyu1@huawei.com
[TransInterface]
interfaces/inner_kits/transport/ zhangchunxin@huawei.com
interfaces/kits/transport/ zhangchunxin@huawei.com
interfaces/inner_kits/transport/ wuchengwen4@huawei.com
interfaces/kits/transport/ wuchengwen4@huawei.com
[Comm]
adapter/common/dfx/ zhangchunxin@huawei.com
adapter/common/include/ zhangchunxin@huawei.com
adapter/common/json/ zhangchunxin@huawei.com
adapter/common/kernel/ zhangchunxin@huawei.com
adapter/common/log/ zhangchunxin@huawei.com
tests/adapter/fuzztest/softbusadapterhisysevent_fuzzer/ zhangchunxin@huawei.com
tests/adapter/unittest/ zhangchunxin@huawei.com
tests/core/common/ zhangchunxin@huawei.com
tests/sdk/common/ zhangchunxin@huawei.com
tests/utils/ zhangchunxin@huawei.com
adapter/common/include/ zhusiyuan2@huawei.com
adapter/common/json/ zhusiyuan2@huawei.com
adapter/common/kernel/ zhusiyuan2@huawei.com
core/common/ zhusiyuan2@huawei.com
tests/core/common/ zhusiyuan2@huawei.com
[CommInterface]
interfaces/kits/common/ zhangchunxin@huawei.com
interfaces/kits/common/softbus_common.h zhusiyuan2@huawei.com
[DFX]
adapter/common/dfx/ zhusiyuan2@huawei.com
core/common/dfx/ zhusiyuan2@huawei.com
tests/core/common/dfx zhusiyuan2@huawei.com
[DFXInterface]
hisysevent.yaml litongxin3@huawei.com
interfaces/kits/common/softbus_error_code.h litongxin3@huawei.com
[Framework]
core/frame/ zhangshaojie3@huawei.com
sdk/frame/ zhangshaojie3@huawei.com
sdk/BUILD.gn zhangshaojie3@huawei.com
sdk/libsoftbus_client_map zhangshaojie3@huawei.com
tests/core/frame/ zhangshaojie3@huawei.com
tests/sdk/frame/ zhangshaojie3@huawei.com
core/frame/ zhangfengxi@huawei.com
sdk/frame/ zhangfengxi@huawei.com
sdk/BUILD.gn zhangfengxi@huawei.com
sdk/libsoftbus_client_map zhangfengxi@huawei.com
tests/core/frame/ zhangfengxi@huawei.com
tests/sdk/frame/ zhangfengxi@huawei.com
[Permission]
core/common/security/permission/ zhangchunxin@huawei.com
tests/core/common/security/permission/ zhangchunxin@huawei.com
core/common/security/permission/ liubao6@huawei.com
tests/core/common/security/permission/ liubao6@huawei.com
[Crypto]
adapter/common/mbedtls/ zhangshaojie3@huawei.com
adapter/common/openssl/ zhangshaojie3@huawei.com
components/mbedtls/ zhangshaojie3@huawei.com
core/adapter/huks/ zhangshaojie3@huawei.com
tests/adapter/fuzztest/softbusdecryptdata_fuzzer/ zhangshaojie3@huawei.com
tests/adapter/unittest/dsoftbus_aes_crypto_test.cpp zhangshaojie3@huawei.com
tests/adapter/unittest/dsoftbus_crypto_test.cpp zhangshaojie3@huawei.com
tests/core/adapter/unittest/dsoftbus_rsa_crypto_test.cpp zhangshaojie3@huawei.com
adapter/common/mbedtls/ chenbotong1@huawei.com
adapter/common/openssl/ chenbotong1@huawei.com
components/mbedtls/ chenbotong1@huawei.com
core/adapter/huks/ chenbotong1@huawei.com
[2nd-Party]
components/nstackx/ zhangchunxin@huawei.com
components/nstackx/ libing3@huawei.com xuxiaoqing16@huawei.com
[InterfaceCode]
# any change to core/common/include/softbus_server_ipc_interface_code.h needs to be reviewed by @leonchan5
core/common/include/softbus_server_ipc_interface_code.h @leonchan5 zhangchunxin@huawei.com zhangshaojie3@huawei.com
core/common/include/softbus_server_ipc_interface_code.h @leonchan5 liubao6@huawei.com

27
README.md
View File

@ -71,7 +71,19 @@ The DSoftBus directory structure is as follows:
/** Callback used to return the publish result. */
void (*OnPublishResult)(int publishId, PublishResult reason);
} IPublishCb;
// Publish information.
typedef struct {
int publishId; // Publish ID.
DiscoverMode mode; // Discovery mode.
ExchangeMedium medium; // Medium used for device discovery.
ExchangeFreq freq; // Device discovery frequency.
const char *capability; // Capability of the device that can be discovered.
unsigned char *capabilityData; // Custom data for service publishing
unsigned int dataLen; // Length of the data.
bool ranging; // Whether to measure the distance.
} PublishInfo;
// Publish a service.
int32_t PublishLNN(const char *pkgName, const PublishInfo *info, const IPublishCb *cb);
```
@ -224,17 +236,18 @@ The DSoftBus directory structure is as follows:
void (*OnStream)(int32_t socket, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param);
void (*OnFile)(int32_t socket, FileEvent *event);
void (*OnQos)(int32_t socket, QoSEvent eventId, const QosTV *qos, uint32_t qosCount);
void (*OnError)(int32_t socket, int32_t errCode);
} ISocketListener;
typedef enum {
QOS_TYPE_MIN_BW, // Minimum bandwidth.
QOS_TYPE_MAX_LATENCY, // Maximum link setup latency.
QOS_TYPE_MIN_LATENCY, // Minimum link setup latency.
QOS_TYPE_MAX_WAIT_TIMEOUT, // Maximum timeout period.
QOS_TYPE_MAX_BUFFER, // Maximum buffer size.
QOS_TYPE_FIRST_PACKAGE, // Size of the first packet.
QOS_TYPE_MAX_WAIT_TIMEOUT, // Maximum time allowed for the bind operation.
QOS_TYPE_MIN_LATENCY, // Minimum latency for link setup.
QOS_TYPE_RTT_LEVEL, // Level of the RTT.
QOS_TYPE_MAX_BUFFER, // Maximum buffer size (reserved).
QOS_TYPE_FIRST_PACKAGE, // Size of the first packet (reserved).
QOS_TYPE_MAX_IDLE_TIMEOUT, // Maximum idle time.
QOS_TYPE_TRANS_RELIABILITY,// Transmission reliability.
QOS_TYPE_TRANS_RELIABILITY,// Transmission reliability (reserved).
QOS_TYPE_BUTT,
} QosType;

3
adapter/common/bus_center/common_event/lnn_common_event_monitor.cpp
View File

@ -61,6 +61,8 @@ void CommonEventMonitor::OnReceiveEvent(const CommonEventData &data)
screenState = SOFTBUS_SCREEN_ON;
} else if (action == CommonEventSupport::COMMON_EVENT_USER_UNLOCKED) {
LnnNotifyScreenLockStateChangeEvent(SOFTBUS_SCREEN_UNLOCK);
} else if (action == CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED) {
LnnNotifyScreenLockStateChangeEvent(SOFTBUS_SCREEN_UNLOCK);
}
if (screenState != SOFTBUS_SCREEN_UNKNOWN) {
LnnNotifyScreenStateChangeEvent(screenState);
@ -95,6 +97,7 @@ int32_t SubscribeEvent::SubscribeCommonEvent()
matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_DISTRIBUTED_ACCOUNT_LOGOUT);
matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_DISTRIBUTED_ACCOUNT_LOGOFF);
matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_UNLOCKED);
matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED);
CommonEventSubscribeInfo subscriberInfo(matchingSkills);
subscriber_ = std::make_shared<CommonEventMonitor>(subscriberInfo);
if (!CommonEventManager::SubscribeCommonEvent(subscriber_)) {

8
adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
View File

@ -742,10 +742,10 @@ static bool SetLpParam(SensorHubServerType type,
lpParam.scanConfig = &scanConfig;
lpParam.rawData.advData = (unsigned char *)AssembleAdvData(&bcParam->advData,
(uint16_t *)&lpParam.rawData.advDataLen);
DISC_CHECK_AND_RETURN_RET_LOGE(lpParam.rawData.advData != NULL, SOFTBUS_ERR, DISC_BLE, "assemble adv data failed");
DISC_CHECK_AND_RETURN_RET_LOGE(lpParam.rawData.advData != NULL, false, DISC_BLE, "assemble adv data failed");
if (SetBtUuidByBroadCastType(type, &lpParam.uuid) != SOFTBUS_OK) {
DISC_LOGE(DISC_BLE_ADAPTER, "set bt uuid fail, advHandle=%{public}d", bcParam->advHandle);
return SOFTBUS_ERR;
return false;
}
if (bcParam->advData.rspData.payloadLen > 0 && bcParam->advData.rspData.payload != NULL) {
lpParam.rawData.rspData = (unsigned char *)AssembleRspData(&bcParam->advData.rspData,
@ -753,7 +753,7 @@ static bool SetLpParam(SensorHubServerType type,
if (lpParam.rawData.rspData == NULL) {
SoftBusFree(lpParam.rawData.advData);
DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advHandle=%{public}d", bcParam->advHandle);
return SOFTBUS_ERR;
return false;
}
}
lpParam.filter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * scanParam->filterSize);
@ -761,7 +761,7 @@ static bool SetLpParam(SensorHubServerType type,
SoftBusFree(lpParam.rawData.advData);
SoftBusFree(lpParam.rawData.rspData);
DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed, advHandle=%{public}d", bcParam->advHandle);
return SOFTBUS_MALLOC_ERR;
return false;
}
if (type == SOFTBUS_HEARTBEAT_TYPE) {
SoftbusSetManufactureData(lpParam.filter, scanParam->filterSize);

2
bundle.json
View File

@ -56,6 +56,7 @@
"cJSON",
"openssl",
"data_share",
"kv_store",
"device_auth",
"device_info_manager",
"device_certificate_manager",
@ -147,6 +148,7 @@
"//foundation/communication/dsoftbus/tests/sdk/transmission:benchmarktest",
"//foundation/communication/dsoftbus/tests/sdk/transmission:integration_test",
"//foundation/communication/dsoftbus/tests/sdk/frame/common:unittest",
"//foundation/communication/dsoftbus/tests/core/adapter:unittest",
"//foundation/communication/dsoftbus/tests/sdk/frame/standard:unittest",
"//foundation/communication/dsoftbus/tests/sdk/frame:fuzztest"
]

38
core/adapter/bus_center/include/lnn_kv_adapter_wrapper.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright (c) 2024 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 DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H
#define DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H
#include "lnn_data_cloud_sync.h"
#ifdef __cplusplus
extern "C" {
#endif
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId,
int32_t storeIdLen);
int32_t LnnDestroyKvAdapter(int32_t dbId);
int32_t LnnPutDBData(int32_t dbId, const char *key, int32_t keyLen, const char *value, int32_t valueLen);
int32_t LnnPutDBDataBatch(int32_t dbId, const CloudSyncInfo *localInfo);
int32_t LnnDeleteDBData(int32_t dbId, const char *key, int32_t keyLen);
int32_t LnnDeleteDBDataByPrefix(int32_t dbId, const char *keyPrefix, int32_t keyPrefixLen);
// *value need to be free by caller
int32_t LnnGetDBData(int32_t dbId, const char *key, int32_t keyLen, char **value);
int32_t LnnCloudSync(int32_t dbId);
#ifdef __cplusplus
};
#endif
#endif //DSOFTBUS_KV_STORE_LNN_KV_ADAPTER_WRAPPER_H

326
core/adapter/bus_center/src/lnn_kv_adapter_wrapper.cpp Normal file
View File

@ -0,0 +1,326 @@
/*
* Copyright (c) 2024 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 <string>
#include <cstring>
#include "lnn_kv_adapter_wrapper.h"
#include "lnn_log.h"
#include "softbus_errcode.h"
#include "lnn_kv_adapter.h"
#include "lnn_kv_data_change_listener.h"
#include "lnn_device_info_recovery.h"
using namespace OHOS;
using namespace OHOS::DistributedKv;
namespace {
constexpr int32_t MIN_DBID_COUNT = 1;
constexpr int32_t MAX_STRING_LEN = 4096;
constexpr int32_t MIN_STRING_LEN = 1;
const std::string SEPARATOR = "#";
std::mutex g_kvAdapterWrapperMutex;
}
static int32_t g_dbId = 1;
static std::map<int32_t, std::shared_ptr<OHOS::KVAdapter>> g_dbID2KvAdapter;
void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values);
void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values);
std::shared_ptr<OHOS::KVAdapter> FindKvStorePtr(int32_t& dbId);
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId,
int32_t storeIdLen)
{
if (dbId == nullptr || appId == nullptr || appIdLen < MIN_STRING_LEN || appIdLen > MAX_STRING_LEN ||
storeId == nullptr || storeIdLen < MIN_STRING_LEN || storeIdLen > MAX_STRING_LEN) {
return SOFTBUS_INVALID_PARAM;
}
std::string appIdStr(appId, appIdLen);
std::string storeIdStr(storeId, storeIdLen);
std::shared_ptr<KVAdapter> kvAdapter = nullptr;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
kvAdapter = std::make_shared<KVAdapter>(appIdStr, storeIdStr,
std::make_shared<KvDataChangeListener>());
int32_t initRet = kvAdapter->Init();
if (initRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter init failed, ret = %{public}d", initRet);
return initRet;
}
*dbId = g_dbId;
g_dbID2KvAdapter.insert(std::make_pair(g_dbId, kvAdapter));
g_dbId++;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter init success, dbId = %{public}d", *dbId);
return SOFTBUS_OK;
}
int32_t LnnDestroyKvAdapter(int32_t dbId)
{
int32_t unInitRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
unInitRet = kvAdapter->DeInit();
}
if (unInitRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter unInit failed, ret = %{public}d", unInitRet);
return unInitRet;
}
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
g_dbID2KvAdapter.erase(dbId);
}
LNN_LOGI(LNN_LEDGER, "kvAdapter unInit success, dbId = %{public}d", dbId);
return SOFTBUS_OK;
}
std::shared_ptr<KVAdapter> FindKvStorePtr(int32_t &dbId)
{
auto iter = g_dbID2KvAdapter.find(dbId);
if (iter == g_dbID2KvAdapter.end()) {
LNN_LOGE(LNN_LEDGER, "dbID is not exist, dbId = %{public}d", dbId);
return nullptr;
}
return iter->second;
}
int32_t LnnPutDBData(int32_t dbId, const char *key, int32_t keyLen, const char *value, int32_t valueLen)
{
int32_t putRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN ||
value == nullptr || valueLen < MIN_STRING_LEN || valueLen > MAX_STRING_LEN ||
dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::string keyStr(key, keyLen);
std::string valueStr(value, valueLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
putRet = kvAdapter->Put(keyStr, valueStr);
}
if (putRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter put failed, ret = %{public}d", putRet);
return putRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter put success, dbId = %{public}d", dbId);
return SOFTBUS_OK;
}
int32_t LnnDeleteDBData(int32_t dbId, const char *key, int32_t keyLen)
{
int32_t deleteRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN ||
dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::string keyStr(key, keyLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
deleteRet = kvAdapter->Delete(keyStr);
}
if (deleteRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter delete failed, ret = %{public}d", deleteRet);
return deleteRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter delete success, dbId = %{public}d", dbId);
return SOFTBUS_OK;
}
int32_t LnnGetDBData(int32_t dbId, const char *key, int32_t keyLen, char **value)
{
std::string valueStr;
int32_t getRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (value == nullptr || key == nullptr || keyLen < MIN_STRING_LEN || keyLen > MAX_STRING_LEN ||
dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::string keyStr(key, keyLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
getRet = kvAdapter->Get(keyStr, valueStr);
}
if (getRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter get failed, ret = %{public}d", getRet);
return getRet;
}
*value = strdup(valueStr.c_str());
if (*value == nullptr) {
LNN_LOGE(LNN_LEDGER, "strdup failed");
return SOFTBUS_MALLOC_ERR;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter get success, dbId = %{public}d", dbId);
return SOFTBUS_OK;
}
int32_t LnnDeleteDBDataByPrefix(int32_t dbId, const char *keyPrefix, int32_t keyPrefixLen)
{
int32_t deleteRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (keyPrefix == nullptr || keyPrefixLen < MIN_STRING_LEN || keyPrefixLen > MAX_STRING_LEN ||
dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::string keyPrefixStr(keyPrefix, keyPrefixLen);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
deleteRet = kvAdapter->DeleteByPrefix(keyPrefixStr);
}
if (deleteRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter delete failed, ret = %{public}d", deleteRet);
return deleteRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter delete success, dbId = %{public}d", dbId);
return SOFTBUS_OK;
}
int32_t LnnPutDBDataBatch(int32_t dbId, const CloudSyncInfo *localInfo)
{
int32_t putBatchRet;
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (localInfo == nullptr || dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
return SOFTBUS_INVALID_PARAM;
}
std::map<std::string, std::string> values;
BasicCloudSyncInfoToMap(localInfo, values);
ComplexCloudSyncInfoToMap(localInfo, values);
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
putBatchRet = kvAdapter->PutBatch(values);
}
if (putBatchRet != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "kvAdapter putBatch failed, ret = %{public}d", putBatchRet);
return putBatchRet;
}
LNN_LOGI(LNN_LEDGER, "kvAdapter putBatch success, dbId = %{public}d", dbId);
return SOFTBUS_OK;
}
int32_t LnnCloudSync(int32_t dbId)
{
std::lock_guard<std::mutex> lock(g_kvAdapterWrapperMutex);
if (dbId < MIN_DBID_COUNT || dbId >= g_dbId) {
LNN_LOGI(LNN_LEDGER, "Invalid dbId ");
return SOFTBUS_INVALID_PARAM;
}
auto kvAdapter = FindKvStorePtr(dbId);
if (kvAdapter == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvAdapter is not exist, dbId = %{public}d", dbId);
return SOFTBUS_NOT_FIND;
}
return (kvAdapter->CloudSync());
}
void BasicCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values)
{
if (localInfo == nullptr) {
LNN_LOGE(LNN_LEDGER, "localInfo is null");
return;
}
std::string keyPrefix = std::to_string(localInfo->accountId) + SEPARATOR + localInfo->deviceUdid + SEPARATOR;
std::string stateVersionStr = SEPARATOR + std::to_string(localInfo->stateVersion);
values[keyPrefix + DEVICE_INFO_NETWORK_ID] = localInfo->networkId + stateVersionStr;
values[keyPrefix + DEVICE_INFO_DEVICE_NAME] = localInfo->deviceName + stateVersionStr;
values[keyPrefix + DEVICE_INFO_UNIFIED_DEVICE_NAME] = localInfo->unifiedName + stateVersionStr;
values[keyPrefix + DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME] = localInfo->unifiedDefaultName + stateVersionStr;
values[keyPrefix + DEVICE_INFO_SETTINGS_NICK_NAME] = localInfo->nickName + stateVersionStr;
values[keyPrefix + DEVICE_INFO_DEVICE_TYPE] = std::to_string(localInfo->deviceTypeId) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_DEVICE_UDID] = localInfo->deviceUdid + stateVersionStr;
values[keyPrefix + DEVICE_INFO_DEVICE_UUID] = localInfo->uuid + stateVersionStr;
values[keyPrefix + DEVICE_INFO_SW_VERSION] = localInfo->softBusVersion + stateVersionStr;
values[keyPrefix + DEVICE_INFO_BLE_P2P] = (localInfo->isBleP2p ? "true" : "false") + stateVersionStr;
values[keyPrefix + DEVICE_INFO_TRANSPORT_PROTOCOL] = std::to_string(localInfo->supportedProtocols) +
stateVersionStr;
values[keyPrefix + DEVICE_INFO_PKG_VERSION] = localInfo->pkgVersion + stateVersionStr;
values[keyPrefix + DEVICE_INFO_WIFI_VERSION] = std::to_string(localInfo->wifiVersion) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_BLE_VERSION] = std::to_string(localInfo->bleVersion) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_BT_MAC] = localInfo->macAddr + stateVersionStr;
values[keyPrefix + DEVICE_INFO_ACCOUNT_ID] = std::to_string(localInfo->accountId) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_FEATURE] = std::to_string(localInfo->feature) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_CONN_SUB_FEATURE] = std::to_string(localInfo->connSubFeature) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_AUTH_CAP] = std::to_string(localInfo->authCapacity) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_OS_TYPE] = std::to_string(localInfo->osType) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_OS_VERSION] = localInfo->osVersion + stateVersionStr;
values[keyPrefix + DEVICE_INFO_STATE_VERSION] = std::to_string(localInfo->stateVersion) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_P2P_MAC_ADDR] = localInfo->p2pMac + stateVersionStr;
}
void ComplexCloudSyncInfoToMap(const CloudSyncInfo *localInfo, std::map<std::string, std::string>& values)
{
if (localInfo == nullptr) {
LNN_LOGE(LNN_LEDGER, "localInfo is null");
return;
}
std::string keyPrefix = std::to_string(localInfo->accountId) + SEPARATOR + localInfo->deviceUdid + SEPARATOR;
std::string stateVersionStr = SEPARATOR + std::to_string(localInfo->stateVersion);
char peerIrkStr[LFINDER_IRK_LEN];
for (int32_t i = 0; i < LFINDER_IRK_LEN; i++) {
peerIrkStr[i] = static_cast<char>(localInfo->peerIrk[i]);
}
values[keyPrefix + DEVICE_INFO_DEVICE_IRK] = peerIrkStr + stateVersionStr;
char publicAddressStr[LFINDER_MAC_ADDR_LEN];
for (int32_t i = 0; i < LFINDER_MAC_ADDR_LEN; i++) {
publicAddressStr[i] = static_cast<char>(localInfo->publicAddress[i]);
}
values[keyPrefix + DEVICE_INFO_DEVICE_PUB_MAC] = publicAddressStr + stateVersionStr;
values[keyPrefix + DEVICE_INFO_PTK] = localInfo->remotePtk + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TABLE_MIAN] = localInfo->tableMain + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TOTAL_LIFE] = std::to_string(localInfo->lifeTotal) + stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN] = std::to_string(localInfo->curBeginTime) +
stateVersionStr;
values[keyPrefix + DEVICE_INFO_JSON_KEY_CURRENT_INDEX] = std::to_string(localInfo->currentIndex) + stateVersionStr;
char cipherKeyStr[SESSION_KEY_LENGTH];
for (int32_t i = 0; i < SESSION_KEY_LENGTH; i++) {
cipherKeyStr[i] = static_cast<char>(localInfo->cipherKey[i]);
}
values[keyPrefix + DEVICE_INFO_BROADCAST_CIPHER_KEY] = cipherKeyStr + stateVersionStr;
char cipherIvStr[BROADCAST_IV_LEN];
for (int32_t i = 0; i < BROADCAST_IV_LEN; i++) {
cipherIvStr[i] = static_cast<char>(localInfo->cipherIv[i]);
}
values[keyPrefix + DEVICE_INFO_BROADCAST_CIPHER_IV] = cipherIvStr + stateVersionStr;
values[keyPrefix + DEVICE_INFO_DISTRIBUTED_SWITCH] = (localInfo->distributedSwitch ? "true" : "false") +
stateVersionStr;
}

81
core/adapter/bus_center/src/lnn_kv_adapter_wrapper_virtual.cpp Normal file
View File

@ -0,0 +1,81 @@
/*
* Copyright (c) 2024 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 "lnn_kv_adapter_wrapper.h"
#include "softbus_errcode.h"
int32_t LnnCreateKvAdapter(int32_t *dbId, const char *appId, int32_t appIdLen, const char *storeId,
int32_t storeIdLen)
{
(void)dbId;
(void)appId;
(void)appIdLen;
(void)storeId;
(void)storeIdLen;
return SOFTBUS_OK;
}
int32_t LnnDestroyKvAdapter(int32_t dbId)
{
(void)dbId;
return SOFTBUS_OK;
}
int32_t LnnPutDBData(int32_t dbId, const char *key, int32_t keyLen, const char *value, int32_t valueLen)
{
(void)dbId;
(void)key;
(void)keyLen;
(void)value;
(void)valueLen;
return SOFTBUS_OK;
}
int32_t LnnDeleteDBData(int32_t dbId, const char *key, int32_t keyLen)
{
(void)dbId;
(void)key;
(void)keyLen;
return SOFTBUS_OK;
}
int32_t LnnGetDBData(int32_t dbId, const char *key, int32_t keyLen, char **value)
{
(void)dbId;
(void)key;
(void)keyLen;
(void)value;
return SOFTBUS_OK;
}
int32_t LnnDeleteDBDataByPrefix(int32_t dbId, const char *keyPrefix, int32_t keyPrefixLen)
{
(void)dbId;
(void)keyPrefix;
(void)keyPrefixLen;
return SOFTBUS_OK;
}
int32_t LnnPutDBDataBatch(int32_t dbId, const CloudSyncInfo *localInfo)
{
(void)dbId;
(void)localInfo;
return SOFTBUS_OK;
}
int32_t LnnCloudSync(int32_t dbId)
{
(void)dbId;
return SOFTBUS_OK;
}

13
core/adapter/core_adapter.gni
View File

@ -29,6 +29,19 @@ bus_center_core_adapter_inc = [ "$dsoftbus_root_path/adapter/common/include" ]
bus_center_core_adapter_deps = [ "$dsoftbus_dfx_path/log:softbus_dfx_log" ]
bus_center_core_adapter_external_deps = [ "init:libbegetutil" ]
if (dsoftbus_feature_lnn_cloud_sync) {
bus_center_core_adapter_external_deps += [ "kv_store:distributeddata_inner" ]
bus_center_core_adapter_src += [
"$dsoftbus_root_path/core/adapter/bus_center/src/lnn_kv_adapter_wrapper.cpp",
"$dsoftbus_root_path/core/adapter/kv_store/src/lnn_kv_adapter.cpp",
"$dsoftbus_root_path/core/adapter/kv_store/src/lnn_kv_data_change_listener.cpp",
]
bus_center_core_adapter_inc +=
[ "$dsoftbus_root_path/core/adapter/kv_store/include" ]
} else {
bus_center_core_adapter_src += [ "$dsoftbus_root_path/core/adapter/bus_center/src/lnn_kv_adapter_wrapper_virtual.cpp" ]
}
if (defined(ohos_lite)) {
bus_center_core_adapter_src += [
"$dsoftbus_root_path/core/adapter/bus_center/src/lnn_settingdata_event_monitor_virtual.cpp",

62
core/adapter/kv_store/include/lnn_kv_adapter.h Normal file
View File

@ -0,0 +1,62 @@
/*
* Copyright (c) 2024 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 LNN_KV_ADAPTER_H
#define LNN_KV_ADAPTER_H
#include <map>
#include <memory>
#include <string>
#include "distributed_kv_data_manager.h"
#include "kvstore_observer.h"
namespace OHOS {
class KVAdapter {
public:
KVAdapter(const std::string &appId, const std::string &storeId,
const std::shared_ptr<DistributedKv::KvStoreObserver> &dataChangeListener);
virtual ~KVAdapter();
int32_t Init();
int32_t DeInit();
int32_t Put(const std::string& key, const std::string& value);
int32_t PutBatch(const std::map<std::string, std::string>& values);
int32_t Delete(const std::string& key);
int32_t DeleteByPrefix(const std::string& keyPrefix);
int32_t Get(const std::string& key, std::string& value);
int32_t DeleteKvStore();
int32_t CloudSync();
private:
DistributedKv::Status GetKvStorePtr();
int32_t DeleteKvStorePtr();
int32_t RegisterDataChangeListener();
int32_t UnRegisterDataChangeListener();
int32_t DeleteDataChangeListener();
private:
DistributedKv::AppId appId_;
DistributedKv::StoreId storeId_;
DistributedKv::DistributedKvDataManager kvDataMgr_;
std::shared_ptr<DistributedKv::SingleKvStore> kvStorePtr_ = nullptr;
std::shared_ptr<DistributedKv::KvStoreObserver> dataChangeListener_ = nullptr;
std::mutex kvAdapterMutex_;
};
} // namespace OHOS
#endif // LNN_KV_ADAPTER_H

38
core/adapter/kv_store/include/lnn_kv_data_change_listener.h Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright (c) 2024 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 LNN_KV_DATA_CHANGE_LISTENER_H
#define LNN_KV_DATA_CHANGE_LISTENER_H
#include <vector>
#include "kvstore_observer.h"
namespace OHOS {
class KvDataChangeListener : public DistributedKv::KvStoreObserver {
public:
KvDataChangeListener();
~KvDataChangeListener();
void OnChange(const DistributedKv::DataOrigin& origin, Keys &&keys) override;
private:
std::vector<DistributedKv::Entry> ConvertCloudChangeDataToEntries(const std::vector<std::string> &keys);
void HandleAddChange(const std::vector<DistributedKv::Entry> &insertRecords);
void HandleUpdateChange(const std::vector<DistributedKv::Entry> &updateRecords);
void HandleDeleteChange(const std::vector<DistributedKv::Entry> &deleteRecords);
};
} // namespace OHOS
#endif // LNN_KV_DATA_CHANGE_LISTENER_H

361
core/adapter/kv_store/src/lnn_kv_adapter.cpp Normal file
View File

@ -0,0 +1,361 @@
/*
* Copyright (c) 2024 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 <cinttypes>
#include <mutex>
#include <unistd.h>
#include <vector>
#include "lnn_kv_adapter.h"
#include "anonymizer.h"
#include "lnn_log.h"
#include "softbus_errcode.h"
#include "datetime_ex.h"
namespace OHOS {
using namespace OHOS::DistributedKv;
namespace {
constexpr int32_t MAX_STRING_LEN = 4096;
constexpr int32_t MAX_INIT_RETRY_TIMES = 30;
constexpr int32_t INIT_RETRY_SLEEP_INTERVAL = 500 * 1000; // 500ms
constexpr int32_t MAX_MAP_SIZE = 10000;
const std::string DATABASE_DIR = "/data/service/el1/public/database/dsoftbus";
}
KVAdapter::KVAdapter(const std::string &appId, const std::string &storeId,
const std::shared_ptr<DistributedKv::KvStoreObserver> &dataChangeListener)
{
this->appId_.appId = appId;
this->storeId_.storeId = storeId;
this->dataChangeListener_ = dataChangeListener;
LNN_LOGI(LNN_LEDGER, "KVAdapter Constructor Success, appId: %{public}s, storeId: %{public}s",
appId.c_str(), storeId.c_str());
}
KVAdapter::~KVAdapter()
{
LNN_LOGI(LNN_LEDGER, "KVAdapter Destruction!");
}
int32_t KVAdapter::Init()
{
LNN_LOGI(LNN_LEDGER, "Init kvAdapter, storeId: %s", storeId_.storeId.c_str());
int32_t tryTimes = MAX_INIT_RETRY_TIMES;
int64_t beginTime = GetTickCount();
while (tryTimes > 0) {
DistributedKv::Status status = GetKvStorePtr();
if (kvStorePtr_ && status == DistributedKv::Status::SUCCESS) {
int64_t endTime = GetTickCount();
LNN_LOGI(LNN_LEDGER, "Init KvStorePtr Success, spend %{public}" PRId64 " ms", endTime - beginTime);
RegisterDataChangeListener();
return SOFTBUS_OK;
}
LNN_LOGI(LNN_LEDGER, "CheckKvStore, left times: %{public}d, status: %{public}d", tryTimes, status);
if (status == DistributedKv::Status::SECURITY_LEVEL_ERROR) {
DeleteKvStore();
}
usleep(INIT_RETRY_SLEEP_INTERVAL);
tryTimes--;
}
return SOFTBUS_KV_DB_INIT_FAIL;
}
int32_t KVAdapter::DeInit()
{
LNN_LOGI(LNN_LEDGER, "DBAdapter DeInit");
UnRegisterDataChangeListener();
DeleteDataChangeListener();
DeleteKvStorePtr();
return SOFTBUS_OK;
}
int32_t KVAdapter::RegisterDataChangeListener()
{
LNN_LOGI(LNN_LEDGER, "Register db data change listener");
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvStoragePtr_ is null");
return SOFTBUS_KV_DB_PTR_NULL;
}
DistributedKv::Status status =
kvStorePtr_->SubscribeKvStore(DistributedKv::SubscribeType::SUBSCRIBE_TYPE_CLOUD, dataChangeListener_);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "Register db data change listener failed, ret: %{public}d", status);
return SOFTBUS_KV_REGISTER_DATA_LISTENER_FAILED;
}
}
return SOFTBUS_OK;
}
int32_t KVAdapter::UnRegisterDataChangeListener()
{
LNN_LOGI(LNN_LEDGER, "UnRegister db data change listener");
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvStoragePtr_ is null");
return SOFTBUS_KV_DB_PTR_NULL;
}
DistributedKv::Status status =
kvStorePtr_->UnSubscribeKvStore(DistributedKv::SubscribeType::SUBSCRIBE_TYPE_CLOUD, dataChangeListener_);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "UnRegister db data change listener failed, ret: %{public}d", status);
return SOFTBUS_KV_UNREGISTER_DATA_LISTENER_FAILED;
}
}
return SOFTBUS_OK;
}
int32_t KVAdapter::DeleteDataChangeListener()
{
LNN_LOGI(LNN_LEDGER, "Delete DataChangeListener!");
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
dataChangeListener_ = nullptr;
}
return SOFTBUS_OK;
}
int32_t KVAdapter::Put(const std::string& key, const std::string& value)
{
if (key.empty() || key.size() > MAX_STRING_LEN || value.empty() || value.size() > MAX_STRING_LEN) {
LNN_LOGE(LNN_LEDGER, "Param is invalid!");
return SOFTBUS_INVALID_PARAM;
}
DistributedKv::Status status;
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvDBPtr is null!");
return SOFTBUS_KV_DB_PTR_NULL;
}
DistributedKv::Key kvKey(key);
DistributedKv::Value oldV;
if (kvStorePtr_->Get(kvKey, oldV) == DistributedKv::Status::SUCCESS && oldV.ToString() == value) {
char *anonyKey = nullptr;
char *anonyValue = nullptr;
Anonymize(key.c_str(), &anonyKey);
Anonymize(value.c_str(), &anonyValue);
LNN_LOGI(LNN_LEDGER, "The key-value pair already exists. key=%{public}s, value=%{public}s",
anonyKey, anonyValue);
AnonymizeFree(anonyKey);
AnonymizeFree(anonyValue);
return SOFTBUS_OK;
}
DistributedKv::Value kvValue(value);
status = kvStorePtr_->Put(kvKey, kvValue);
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "Put kv to db failed, ret: %{public}d", status);
return SOFTBUS_KV_PUT_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "KVAdapter Put succeed");
return SOFTBUS_OK;
}
int32_t KVAdapter::PutBatch(const std::map<std::string, std::string>& values)
{
if (values.empty() || values.size() > MAX_MAP_SIZE) {
LNN_LOGE(LNN_LEDGER, "Param is invalid!");
return SOFTBUS_INVALID_PARAM;
}
DistributedKv::Status status;
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvDBPtr is null!");
return SOFTBUS_KV_DB_PTR_NULL;
}
std::vector<DistributedKv::Entry> entries;
DistributedKv::Value oldV;
DistributedKv::Key kvKey;
for (auto item : values) {
kvKey = item.first;
if (kvStorePtr_->Get(kvKey, oldV) == DistributedKv::Status::SUCCESS && oldV.ToString() == item.second) {
char *anonyKey = nullptr;
char *anonyValue = nullptr;
Anonymize(item.first.c_str(), &anonyKey);
Anonymize(item.second.c_str(), &anonyValue);
LNN_LOGI(LNN_LEDGER, "The key-value pair already exists. key=%{public}s, value=%{public}s", anonyKey,
anonyValue);
AnonymizeFree(anonyKey);
AnonymizeFree(anonyValue);
continue;
}
Entry entry;
entry.key = kvKey;
entry.value = item.second;
entries.emplace_back(entry);
}
if (entries.empty()) {
LNN_LOGI(LNN_LEDGER, "All key-value pair already exists.");
return SOFTBUS_OK;
}
status = kvStorePtr_->PutBatch(entries);
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "PutBatch kv to db failed, ret: %d", status);
return SOFTBUS_KV_PUT_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "KVAdapter PutBatch succeed");
return SOFTBUS_OK;
}
int32_t KVAdapter::Delete(const std::string& key)
{
DistributedKv::Status status;
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvDBPtr is null!");
return SOFTBUS_KV_DB_PTR_NULL;
}
DistributedKv::Key kvKey(key);
status = kvStorePtr_->Delete(kvKey);
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "Delete kv by key failed!");
return SOFTBUS_KV_DEL_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "Delete kv by key success!");
return SOFTBUS_OK;
}
int32_t KVAdapter::DeleteByPrefix(const std::string& keyPrefix)
{
LNN_LOGI(LNN_LEDGER, "call");
if (keyPrefix.empty() || keyPrefix.size() > MAX_STRING_LEN) {
LNN_LOGE(LNN_LEDGER, "Param is invalid!");
return SOFTBUS_INVALID_PARAM;
}
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvStoragePtr_ is null");
return SOFTBUS_KV_DB_PTR_NULL;
}
// if prefix is empty, get all entries.
DistributedKv::Key allEntryKeyPrefix(keyPrefix);
std::vector<DistributedKv::Entry> allEntries;
DistributedKv::Status status = kvStorePtr_->GetEntries(allEntryKeyPrefix, allEntries);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "GetEntries failed, ret: %{public}d", status);
return SOFTBUS_KV_DEL_DB_FAIL;
}
std::vector<DistributedKv::Key> keys;
for (auto item : allEntries) {
keys.push_back(item.key);
}
status = kvStorePtr_->DeleteBatch(keys);
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "DeleteBatch failed, ret: %{public}d", status);
return SOFTBUS_KV_DEL_DB_FAIL;
}
LNN_LOGI(LNN_LEDGER, "DeleteByPrefix succeed");
return SOFTBUS_OK;
}
int32_t KVAdapter::Get(const std::string& key, std::string& value)
{
char *anonyKey = nullptr;
Anonymize(key.c_str(), &anonyKey);
LNN_LOGI(LNN_LEDGER, "Get data by key: %{public}s", anonyKey);
AnonymizeFree(anonyKey);
DistributedKv::Key kvKey(key);
DistributedKv::Value kvValue;
DistributedKv::Status status;
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvStoragePtr_ is null");
return SOFTBUS_KV_DB_PTR_NULL;
}
status = kvStorePtr_->Get(kvKey, kvValue);
}
if (status != DistributedKv::Status::SUCCESS) {
anonyKey = nullptr;
Anonymize(key.c_str(), &anonyKey);
LNN_LOGE(LNN_LEDGER, "Get data from kv failed, key: %{public}s", anonyKey);
AnonymizeFree(anonyKey);
return SOFTBUS_KV_GET_DB_FAIL;
}
value = kvValue.ToString();
LNN_LOGI(LNN_LEDGER, "Get succeed");
return SOFTBUS_OK;
}
DistributedKv::Status KVAdapter::GetKvStorePtr()
{
LNN_LOGI(LNN_LEDGER, "called");
DistributedKv::Options options = {
.encrypt = true,
.autoSync = false,
.securityLevel = DistributedKv::SecurityLevel::S1,
.area = 1,
.kvStoreType = KvStoreType::SINGLE_VERSION,
.baseDir = DATABASE_DIR,
.isPublic = true
};
DistributedKv::Status status;
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
status = kvDataMgr_.GetSingleKvStore(options, appId_, storeId_, kvStorePtr_);
}
return status;
}
int32_t KVAdapter::DeleteKvStore()
{
LNN_LOGI(LNN_LEDGER, "Delete KvStore!");
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
kvDataMgr_.CloseKvStore(appId_, storeId_);
kvDataMgr_.DeleteKvStore(appId_, storeId_, DATABASE_DIR);
}
return SOFTBUS_OK;
}
int32_t KVAdapter::DeleteKvStorePtr()
{
LNN_LOGI(LNN_LEDGER, "Delete KvStore Ptr!");
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
kvStorePtr_ = nullptr;
}
return SOFTBUS_OK;
}
int32_t KVAdapter::CloudSync()
{
LNN_LOGI(LNN_LEDGER, "call!");
DistributedKv::Status status;
{
std::lock_guard<std::mutex> lock(kvAdapterMutex_);
if (kvStorePtr_ == nullptr) {
LNN_LOGE(LNN_LEDGER, "kvDBPtr is null!");
return SOFTBUS_KV_DB_PTR_NULL;
}
status = kvStorePtr_->CloudSync(nullptr);
}
if (status != DistributedKv::Status::SUCCESS) {
LNN_LOGE(LNN_LEDGER, "cloud sync failed, ret: %{public}d", status);
return SOFTBUS_KV_CLOUD_SYNC_FAIL;
}
LNN_LOGI(LNN_LEDGER, "cloud sync ok, ret: %{public}d", status);
return SOFTBUS_OK;
}
} // namespace OHOS

148
core/adapter/kv_store/src/lnn_kv_data_change_listener.cpp Normal file
View File

@ -0,0 +1,148 @@
/*
* Copyright (c) 2024 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 "lnn_kv_data_change_listener.h"
#include <cinttypes>
#include <cstring>
#include "softbus_errcode.h"
#include "anonymizer.h"
#include "lnn_log.h"
#include "lnn_data_cloud_sync.h"
#include "lnn_kv_adapter_wrapper.h"
#include "softbus_adapter_mem.h"
namespace OHOS {
namespace {
const std::string APP_ID = "dsoftbus";
const std::string STORE_ID = "dsoftbus_kv_db";
constexpr int32_t APP_ID_LEN = 8;
constexpr int32_t STORE_ID_LEN = 14;
constexpr int32_t MAX_DB_RECORD_SIZE = 10000;
}
KvDataChangeListener::KvDataChangeListener()
{
LNN_LOGI(LNN_LEDGER, "construct!");
}
KvDataChangeListener::~KvDataChangeListener()
{
LNN_LOGI(LNN_LEDGER, "destruct!");
}
void KvDataChangeListener::OnChange(const DistributedKv::DataOrigin &origin, Keys &&keys)
{
LNN_LOGI(LNN_LEDGER, "Cloud data change.store=%{public}s", origin.store.c_str());
std::vector<DistributedKv::Entry> insertRecords = ConvertCloudChangeDataToEntries(keys[ChangeOp::OP_INSERT]);
if (!insertRecords.empty() && insertRecords.size() <= MAX_DB_RECORD_SIZE) {
HandleAddChange(insertRecords);
}
std::vector<DistributedKv::Entry> updateRecords = ConvertCloudChangeDataToEntries(keys[ChangeOp::OP_UPDATE]);
if (!updateRecords.empty() && updateRecords.size() <= MAX_DB_RECORD_SIZE) {
HandleUpdateChange(updateRecords);
}
std::vector<std::string> delKeys = keys[ChangeOp::OP_DELETE];
if (!delKeys.empty() && delKeys.size() <= MAX_DB_RECORD_SIZE) {
std::vector<DistributedKv::Entry> deleteRecords;
for (const auto &key : delKeys) {
DistributedKv::Entry entry;
DistributedKv::Key kvKey(key);
entry.key = kvKey;
deleteRecords.emplace_back(entry);
}
HandleDeleteChange(deleteRecords);
}
}
std::vector<DistributedKv::Entry> KvDataChangeListener::ConvertCloudChangeDataToEntries(
const std::vector<std::string> &keys)
{
LNN_LOGI(LNN_LEDGER, "call!");
int32_t dbId = 0;
char *anonyKey = nullptr;
LnnCreateKvAdapter(&dbId, APP_ID.c_str(), APP_ID_LEN, STORE_ID.c_str(), STORE_ID_LEN);
std::vector<DistributedKv::Entry> entries;
if (keys.empty()) {
LNN_LOGE(LNN_LEDGER, "keys empty");
return entries;
}
for (const auto &key : keys) {
char *value = nullptr;
if (LnnGetDBData(dbId, key.c_str(), key.length(), &value) != SOFTBUS_OK) {
anonyKey = nullptr;
Anonymize(key.c_str(), &anonyKey);
LNN_LOGE(LNN_LEDGER, "get value failed, key = %{public}s", anonyKey);
AnonymizeFree(anonyKey);
continue;
}
DistributedKv::Entry entry;
entry.key = key;
entry.value = value;
entries.emplace_back(entry);
SoftBusFree(value);
}
LnnDestroyKvAdapter(dbId);
return entries;
}
void KvDataChangeListener::HandleAddChange(const std::vector<DistributedKv::Entry>& insertRecords)
{
LNN_LOGI(LNN_LEDGER, "Handle kv data add change!");
int32_t insertSize = insertRecords.size();
char **keys = (char **)SoftBusCalloc(insertSize * sizeof(char *));
if (keys == nullptr) {
LNN_LOGE(LNN_LEDGER, "malloc failed");
return;
}
char **values = (char **)SoftBusCalloc(insertSize * sizeof(char *));
if (values == nullptr) {
LNN_LOGE(LNN_LEDGER, "malloc failed");
SoftBusFree(keys);
return;
}
for (int32_t i = 0; i < insertSize; ++i) {
std::string dbKey = insertRecords[i].key.ToString();
std::string dbValue = insertRecords[i].value.ToString();
keys[i] = strdup(dbKey.c_str());
values[i] = strdup(dbValue.c_str());
}
LnnDBDataAddChangeSyncToCache(const_cast<const char**>(keys), const_cast<const char**>(values), insertSize);
}
void KvDataChangeListener::HandleUpdateChange(const std::vector<DistributedKv::Entry>& updateRecords)
{
LNN_LOGI(LNN_LEDGER, "Handle kv data update change!");
for (const auto& item : updateRecords) {
std::string dbKey = item.key.ToString();
std::string dbValue = item.value.ToString();
LnnDBDataChangeSyncToCache(dbKey.c_str(), dbValue.c_str(), ChangeType::DB_UPDATE);
}
}
void KvDataChangeListener::HandleDeleteChange(const std::vector<DistributedKv::Entry>& deleteRecords)
{
LNN_LOGI(LNN_LEDGER, "Handle kv data delete change!");
for (const auto& item : deleteRecords) {
std::string dbKey = item.key.ToString();
char *dbValue = nullptr;
LnnDBDataChangeSyncToCache(dbKey.c_str(), dbValue, ChangeType::DB_DELETE);
}
}
} // namespace OHOS

2
core/authentication/src/auth_normalize_request.c
View File

@ -69,7 +69,7 @@ static int32_t GetRequestListByUdidHash(char *udidHash, bool isNeedClear,
if (strncmp(item->udidHash, udidHash, UDID_SHORT_HASH_STR) != 0 || index >= (*num)) {
continue;
}
*(requests[index++]) = *item;
(*requests)[index++] = *item;
if (!isNeedClear) {
continue;
}

10
core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_ctrl.c
View File

@ -24,11 +24,14 @@
#include "lnn_async_callback_utils.h"
#include "lnn_ble_heartbeat.h"
#include "lnn_common_utils.h"
#include "lnn_data_cloud_sync.h"
#include "lnn_decision_center.h"
#include "lnn_distributed_net_ledger.h"
#include "lnn_device_info_recovery.h"
#include "lnn_deviceinfo_to_profile.h"
#include "lnn_heartbeat_strategy.h"
#include "lnn_heartbeat_utils.h"
#include "lnn_local_net_ledger.h"
#include "lnn_log.h"
#include "lnn_meta_node_ledger.h"
#include "lnn_network_manager.h"
@ -419,6 +422,13 @@ static void HbScreenLockChangeEventHandler(const LnnEventBasicInfo *info)
case SOFTBUS_SCREEN_UNLOCK:
LNN_LOGI(LNN_HEART_BEAT, "HB handle SOFTBUS_SCREEN_UNLOCK");
LnnUpdateOhosAccount();
const NodeInfo *info = LnnGetLocalNodeInfo();
if ((LnnSaveLocalDeviceInfo(info)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "screen unlocked event, update all ledgerinfo to local store fail");
}
if (LnnLedgerAllDataSyncToDB(info) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "screen unlocked event, ledgerinf sync to cloud fail");
}
HbConditionChanged(false);
break;
case SOFTBUS_SCREEN_LOCK:

1
core/bus_center/lnn/lane_hub/lane_hub.gni
View File

@ -89,6 +89,7 @@ if (dsoftbus_feature_lnn_net) {
bus_center_hub_inc += [
"$dsoftbus_root_path/adapter/common/net/bluetooth/include",
"$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/interface",
"$dsoftbus_core_path/bus_center/lnn/net_ledger/local_ledger/include",
"$dsoftbus_core_path/core/adapter/bus_center/include",
"$dsoftbus_core_path/core/authentication/interface",
"$dsoftbus_core_path/connection/p2p/interface",

6
core/bus_center/lnn/lane_hub/lane_manager/src/lnn_lane_link.c
View File

@ -871,11 +871,7 @@ static int32_t FillWlanLinkInfo(ProtocolType protocol, const LinkRequest *reqInf
if (!isConnected) {
LNN_LOGE(LNN_LANE, "wlan is disconnected");
}
if (is5GBand) {
linkInfo->type = LANE_WLAN_5G;
} else {
linkInfo->type = LANE_WLAN_2P4G;
}
linkInfo->type = reqInfo->linkType;
WlanLinkInfo *wlan = &(linkInfo->linkInfo.wlan);
wlan->channel = channel;
wlan->bw = LANE_BW_RANDOM;

18
core/bus_center/lnn/lane_hub/lane_manager/src/lnn_lane_link_p2p.c
View File

@ -560,7 +560,7 @@ static void NotifyLinkFail(AsyncResultType type, uint32_t requestId, int32_t rea
reqInfo.laneRequestInfo.linkType);
}
if (reqInfo.auth.authHandle.authId != INVAILD_AUTH_ID) {
AuthFreeConn(&reqInfo.auth.authHandle);
AuthCloseConn(reqInfo.auth.authHandle);
}
if (reqInfo.proxyChannelInfo.channelId > 0) {
TransProxyPipelineCloseChannel(reqInfo.proxyChannelInfo.channelId);
@ -622,7 +622,7 @@ static void NotifyLinkSucc(AsyncResultType type, uint32_t requestId, LaneLinkInf
}
}
if (reqInfo.auth.authHandle.authId != INVAILD_AUTH_ID) {
AuthFreeConn(&reqInfo.auth.authHandle);
AuthCloseConn(reqInfo.auth.authHandle);
}
if (reqInfo.proxyChannelInfo.channelId > 0) {
TransProxyPipelineCloseChannelDelay(reqInfo.proxyChannelInfo.channelId);
@ -1072,8 +1072,16 @@ FAIL:
static int32_t OpenAuthTriggerToConn(const LinkRequest *request, uint32_t laneReqId, const LaneLinkCb *callback)
{
AuthConnInfo connInfo;
(void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
bool isMetaAuth = GetAuthType(request->peerNetworkId);
int32_t ret = GetPreferAuth(request->peerNetworkId, &connInfo, isMetaAuth);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_LANE, "no auth conn exist");
return ret;
}
uint32_t authRequestId = AuthGenRequestId();
int32_t ret = AddP2pLinkReqItem(ASYNC_RESULT_AUTH, authRequestId, laneReqId, request, callback);
ret = AddP2pLinkReqItem(ASYNC_RESULT_AUTH, authRequestId, laneReqId, request, callback);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_LANE, "add new connect node failed");
return ret;
@ -1083,8 +1091,8 @@ static int32_t OpenAuthTriggerToConn(const LinkRequest *request, uint32_t laneRe
.onConnOpened = OnAuthTriggerConnOpened,
.onConnOpenFailed = OnAuthConnOpenFailed,
};
LNN_LOGI(LNN_LANE, "auth alloc conn with authRequestId=%{public}u", authRequestId);
ret = AuthAllocConn(request->peerNetworkId, authRequestId, &cb);
LNN_LOGI(LNN_LANE, "open auth trigger with authRequestId=%{public}u", authRequestId);
ret = AuthOpenConn(&connInfo, authRequestId, &cb, isMetaAuth);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_LANE, "open auth conn fail");
(void)DelP2pLinkReqByReqId(ASYNC_RESULT_AUTH, authRequestId);

4
core/bus_center/lnn/lane_hub/lane_manager/src/lnn_trans_lane.c
View File

@ -1168,6 +1168,10 @@ static void HandleWholeProcessTimeout(uint32_t laneReqId)
return;
}
int32_t failReason = nodeInfo->p2pErrCode;
if (nodeInfo->p2pErrCode == SOFTBUS_OK) {
nodeInfo->p2pErrCode = SOFTBUS_TIMOUT;
failReason = SOFTBUS_TIMOUT;
}
bool hasSucc = false;
for (uint32_t i = 0; i < nodeInfo->listNum; i++) {
LaneLinkType linkType = nodeInfo->linkList->linkType[i];

5
core/bus_center/lnn/net_builder/include/lnn_cipherkey_manager.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 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
@ -20,6 +20,7 @@
#include "cJSON.h"
#include "softbus_common.h"
#include "lnn_data_cloud_sync.h"
#include "lnn_node_info.h"
#ifdef __cplusplus
@ -45,7 +46,7 @@ int32_t LnnLoadLocalBroadcastCipherKey(void);
int32_t LnnGetLocalBroadcastCipherKey(BroadcastCipherKey *broadcastKey);
int32_t LnnSaveLocalBroadcastCipherKey(const BroadcastCipherKey *broadcastKey);
int32_t LnnUpdateLocalBroadcastCipherKey(BroadcastCipherKey *broadcastKey);
int32_t LnnGetLocalBroadcastCipherInfo(CloudSyncInfo *info);
#ifdef __cplusplus
}
#endif

82
core/bus_center/lnn/net_builder/include/lnn_data_cloud_sync.h Normal file
View File

@ -0,0 +1,82 @@
/*
* Copyright (c) 2024 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 LNN_DATA_CLOUD_SYNC_H
#define LNN_DATA_CLOUD_SYNC_H
#include <stdint.h>
#include "lnn_node_info.h"
#include "softbus_adapter_crypto.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
char networkId[NETWORK_ID_BUF_LEN];
char deviceName[DEVICE_NAME_BUF_LEN];
char unifiedName[DEVICE_NAME_BUF_LEN];
char unifiedDefaultName[DEVICE_NAME_BUF_LEN];
char nickName[DEVICE_NAME_BUF_LEN];
uint16_t deviceTypeId;
char deviceUdid[UDID_BUF_LEN];
char uuid[UUID_BUF_LEN];
char softBusVersion[VERSION_MAX_LEN];
bool isBleP2p;
uint64_t supportedProtocols;
char pkgVersion[VERSION_MAX_LEN];
int64_t wifiVersion;
int64_t bleVersion;
char macAddr[MAC_LEN];
int64_t accountId;
uint64_t feature;
uint64_t connSubFeature;
uint32_t authCapacity;
int32_t osType;
char osVersion[OS_VERSION_BUF_LEN];
int32_t stateVersion;
char p2pMac[MAC_LEN];
uint8_t peerIrk[LFINDER_IRK_LEN];
unsigned char publicAddress[LFINDER_MAC_ADDR_LEN];
char remotePtk[PTK_DEFAULT_LEN];
char tableMain[BLE_BROADCAST_IV_LEN + 1];
int64_t lifeTotal;
uint64_t curBeginTime;
uint8_t currentIndex;
unsigned char cipherKey[SESSION_KEY_LENGTH];
unsigned char cipherIv[BROADCAST_IV_LEN];
bool distributedSwitch;
} CloudSyncInfo;
typedef enum {
DB_ADD = 0,
DB_UPDATE = 1,
DB_DELETE = 2,
DB_CHANGE_TYPE_MAX,
} ChangeType;
void LnnInitCloudSyncModule(void);
void LnnDeInitCloudSyncModule(void);
int32_t LnnLedgerAllDataSyncToDB(const NodeInfo *info);
int32_t LnnLedgerDataChangeSyncToDB(const char *key, const char *value, size_t valueLength);
int32_t LnnDeleteSyncToDB(void);
int32_t LnnDBDataChangeSyncToCache(const char *key, const char *value, ChangeType changeType);
int32_t LnnDBDataAddChangeSyncToCache(const char **key, const char **value, int32_t keySize);
int32_t LnnGetAccountIdfromLocalCache(int64_t *buf);
#ifdef __cplusplus
}
#endif
#endif // LNN_DATA_CLOUD_SYNC_H

67
core/bus_center/lnn/net_builder/include/lnn_device_info_recovery.h
View File

@ -18,11 +18,74 @@
#include <stdint.h>
#include "lnn_node_info.h"
#include "lnn_map.h"
#include "softbus_adapter_crypto.h"
#ifdef __cplusplus
extern "C" {
#endif
#define DEVICE_INFO_P2P_MAC_ADDR "P2P_MAC_ADDR"
#define DEVICE_INFO_DEVICE_NAME "DEVICE_NAME"
#define DEVICE_INFO_SETTINGS_NICK_NAME "SETTINGS_NICK_NAME"
#define DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME "UNIFIED_DEFAULT_DEVICE_NAME"
#define DEVICE_INFO_UNIFIED_DEVICE_NAME "UNIFIED_DEVICE_NAME"
#define DEVICE_INFO_DEVICE_TYPE "DEVICE_TYPE"
#define DEVICE_INFO_VERSION_TYPE "VERSION_TYPE"
#define DEVICE_INFO_SW_VERSION "SW_VERSION"
#define DEVICE_INFO_PKG_VERSION "PKG_VERSION"
#define DEVICE_INFO_DEVICE_UDID "DEVICE_UDID"
#define DEVICE_INFO_DEVICE_UUID "DEVICE_UUID"
#define DEVICE_INFO_OS_TYPE "OS_TYPE"
#define DEVICE_INFO_OS_VERSION "OS_VERSION"
#define DEVICE_INFO_WIFI_VERSION "WIFI_VERSION"
#define DEVICE_INFO_BLE_VERSION "BLE_VERSION"
#define DEVICE_INFO_CONNECT_INFO "CONNECT_INFO"
#define DEVICE_INFO_BT_MAC "BT_MAC"
#define DEVICE_INFO_BR_MAC_ADDR "BR_MAC_ADDR"
#define DEVICE_INFO_HML_MAC "HML_MAC"
#define DEVICE_INFO_REMAIN_POWER "REMAIN_POWER"
#define DEVICE_INFO_IS_CHARGING "IS_CHARGING"
#define DEVICE_INFO_IS_SCREENON "IS_SCREENON"
#define DEVICE_INFO_IP_MAC "IP_MAC"
#define DEVICE_INFO_P2P_ROLE "P2P_ROLE"
#define DEVICE_INFO_NETWORK_ID "NETWORK_ID"
#define DEVICE_INFO_NODE_WEIGHT "NODE_WEIGHT"
#define DEVICE_INFO_ACCOUNT_ID "ACCOUNT_ID"
#define DEVICE_INFO_DISTRIBUTED_SWITCH "DISTRIBUTED_SWITCH"
#define DEVICE_INFO_TRANSPORT_PROTOCOL "TRANSPORT_PROTOCOL"
#define DEVICE_INFO_TRANS_FLAGS "TRANS_FLAGS"
#define DEVICE_INFO_BLE_P2P "BLE_P2P"
#define DEVICE_INFO_BLE_TIMESTAMP "BLE_TIMESTAMP"
#define DEVICE_INFO_WIFI_BUFF_SIZE "WIFI_BUFF_SIZE"
#define DEVICE_INFO_BR_BUFF_SIZE "BR_BUFF_SIZE"
#define DEVICE_INFO_FEATURE "FEATURE"
#define DEVICE_INFO_CONN_SUB_FEATURE "CONN_SUB_FEATURE"
#define DEVICE_INFO_META_INFO_JSON_TAG "MetaNodeInfoOfEar"
#define DEVICE_INFO_CONN_CAP "CONN_CAP"
#define DEVICE_INFO_NEW_CONN_CAP "NEW_CONN_CAP"
#define DEVICE_INFO_AUTH_CAP "AUTH_CAP"
#define DEVICE_INFO_EXTDATA "EXTDATA"
#define DEVICE_INFO_STATE_VERSION "STATE_VERSION"
#define DEVICE_INFO_LOCAL_STATE_VERSION "LOCAL_STATE_VERSION"
#define DEVICE_INFO_BD_KEY "BD_KEY"
#define DEVICE_INFO_BDKEY_TIME "BDKEY_TIME"
#define DEVICE_INFO_IV "IV"
#define DEVICE_INFO_IV_TIME "IV_TIME"
#define DEVICE_INFO_NETWORK_ID_TIMESTAMP "NETWORK_ID_TIMESTAMP"
#define DEVICE_INFO_DEVICE_IRK "IRK"
#define DEVICE_INFO_DEVICE_PUB_MAC "PUB_MAC"
#define DEVICE_INFO_BROADCAST_CIPHER_KEY "BROADCAST_CIPHER_KEY"
#define DEVICE_INFO_BROADCAST_CIPHER_IV "BROADCAST_CIPHER_IV"
#define DEVICE_INFO_DEVICE_SECURITY_LEVEL "DEVICE_SECURITY_LEVEL"
#define DEVICE_INFO_PTK "PTK"
#define DEVICE_INFO_STATIC_CAP "STATIC_CAP"
#define DEVICE_INFO_STATIC_CAP_LEN "STATIC_CAP_LEN"
#define DEVICE_INFO_JSON_KEY_TABLE_MIAN "JSON_KEY_TABLE_MIAN"
#define DEVICE_INFO_JSON_KEY_TOTAL_LIFE "JSON_KEY_TOTAL_LIFE"
#define DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN "JSON_KEY_TIMESTAMP_BEGIN"
#define DEVICE_INFO_JSON_KEY_CURRENT_INDEX "JSON_KEY_CURRENT_INDEX"
int32_t LnnLoadLocalDeviceInfo(void);
int32_t LnnLoadRemoteDeviceInfo(void);
int32_t LnnSaveLocalDeviceInfo(const NodeInfo *deviceInfo);
@ -34,7 +97,9 @@ NodeInfo *LnnRetrieveDeviceInfoByNetworkId(const char *networkId);
void LnnDeleteDeviceInfo(const char *udid);
void ClearDeviceInfo(void);
int32_t LnnGetUdidByBrMac(const char *brMac, char *udid, uint32_t udidLen);
int32_t LnnGetLocalCacheNodeInfo(NodeInfo *info);
int32_t LnnGetRemoteCacheNodeInfo(Map *devMap);
int32_t LnnLoadLocalDeviceAccountIdInfo(void);
#ifdef __cplusplus
}
#endif

8
core/bus_center/lnn/net_builder/net_builder.gni
View File

@ -78,3 +78,11 @@ bus_center_builder_deps = []
if (dsoftbus_feature_lnn_net && enhanced) {
bus_center_builder_deps += [ "$dsoftbus_root_path/dsoftbus_enhance/core/bus_center/lnn/net_builder/fast_offline:fast_offline" ]
}
if (dsoftbus_feature_lnn_cloud_sync) {
bus_center_builder_src += [ "$dsoftbus_root_path/core/bus_center/lnn/net_builder/src/lnn_data_cloud_sync.c" ]
bus_center_builder_inc +=
[ "$dsoftbus_root_path/core/adapter/bus_center/include" ]
} else {
bus_center_builder_src += [ "$dsoftbus_root_path/core/bus_center/lnn/net_builder/src/lnn_data_cloud_sync_virtual.c" ]
}

6
core/bus_center/lnn/net_builder/src/lnn_cipherkey_manager_virtual.c
View File

@ -85,4 +85,10 @@ int32_t LnnUpdateLocalBroadcastCipherKey(BroadcastCipherKey *broadcastKey)
{
(void)broadcastKey;
return SOFTBUS_OK;
}
int32_t LnnGetLocalBroadcastCipherInfo(CloudSyncInfo *info)
{
(void)info;
return SOFTBUS_OK;
}

999
core/bus_center/lnn/net_builder/src/lnn_data_cloud_sync.c Normal file
View File

@ -0,0 +1,999 @@
/*
* Copyright (c) 2023 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 "lnn_data_cloud_sync.h"
#include <securec.h>
#include "stdlib.h"
#include "anonymizer.h"
#include "lnn_cipherkey_manager.h"
#include "lnn_device_info_recovery.h"
#include "lnn_distributed_net_ledger.h"
#include "lnn_heartbeat_utils.h"
#include "lnn_kv_adapter_wrapper.h"
#include "lnn_link_finder.h"
#include "lnn_log.h"
#include "lnn_node_info.h"
#include "lnn_map.h"
#include "lnn_p2p_info.h"
#include "softbus_adapter_thread.h"
#include "softbus_errcode.h"
#include "softbus_json_utils.h"
#include "softbus_utils.h"
#include "softbus_adapter_mem.h"
#define APPID "dsoftbus"
#define STOREID "dsoftbus_kv_db"
#define FIELDNAME_MAX_LEN 32
#define KEY_MAX_LEN 128
#define SPLIT_MAX_LEN 128
#define SPLIT_KEY_NUM 3
#define SPLIT_VALUE_NUM 2
#define PUT_VALUE_MAX_LEN 136
static int32_t g_dbId = 0;
static int32_t ConvertNameInfoInternal(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
cloudSyncInfo->accountId = nodeInfo->accountId;
if (strcpy_s(cloudSyncInfo->deviceName, DEVICE_NAME_BUF_LEN, nodeInfo->deviceInfo.deviceName) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s devicename fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->unifiedName, DEVICE_NAME_BUF_LEN, nodeInfo->deviceInfo.unifiedName) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifiedname fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->unifiedDefaultName, DEVICE_NAME_BUF_LEN, nodeInfo->deviceInfo.unifiedDefaultName) !=
EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifieddefaultname fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->nickName, DEVICE_NAME_BUF_LEN, nodeInfo->deviceInfo.nickName) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s nickname fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t ConvertVersionInfoInternal(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
if (strcpy_s(cloudSyncInfo->softBusVersion, VERSION_MAX_LEN, nodeInfo->softBusVersion) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s softbusversion fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->pkgVersion, VERSION_MAX_LEN, nodeInfo->pkgVersion) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s pkgversion fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->osVersion, OS_VERSION_BUF_LEN, nodeInfo->deviceInfo.osVersion) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s osversion fail");
return SOFTBUS_MEM_ERR;
}
cloudSyncInfo->wifiVersion = nodeInfo->wifiVersion;
cloudSyncInfo->bleVersion = nodeInfo->bleVersion;
cloudSyncInfo->osType = nodeInfo->deviceInfo.osType;
cloudSyncInfo->stateVersion = nodeInfo->stateVersion;
return SOFTBUS_OK;
}
static int32_t ConvertDevIdInfoInternal(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
if (strcpy_s(cloudSyncInfo->networkId, NETWORK_ID_BUF_LEN, nodeInfo->networkId) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s networkid fail");
return SOFTBUS_MEM_ERR;
}
cloudSyncInfo->deviceTypeId = nodeInfo->deviceInfo.deviceTypeId;
if (strcpy_s(cloudSyncInfo->deviceUdid, UDID_BUF_LEN, nodeInfo->deviceInfo.deviceUdid) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s deviceudid fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->uuid, UUID_BUF_LEN, nodeInfo->uuid) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s uuid fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t ConvertCipherInfoInternal(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
if (memcpy_s(cloudSyncInfo->cipherKey, SESSION_KEY_LENGTH, nodeInfo->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:memcpy_s cipherkey fail");
return SOFTBUS_MEM_ERR;
}
if (memcpy_s(cloudSyncInfo->cipherIv, BROADCAST_IV_LEN, nodeInfo->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:memcpy_s cipheriv fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t ConvertAbilityInfoInternal(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
cloudSyncInfo->isBleP2p = nodeInfo->isBleP2p;
cloudSyncInfo->supportedProtocols = nodeInfo->supportedProtocols;
cloudSyncInfo->feature = nodeInfo->feature;
cloudSyncInfo->connSubFeature = nodeInfo->connSubFeature;
cloudSyncInfo->authCapacity = nodeInfo->authCapacity;
return SOFTBUS_OK;
}
static int32_t ConvertAddressInfoInternal(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
if (strcpy_s(cloudSyncInfo->macAddr, MAC_LEN, nodeInfo->connectInfo.macAddr) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s macaddr fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->p2pMac, MAC_LEN, nodeInfo->p2pInfo.p2pMac) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s p2pmac fail");
return SOFTBUS_MEM_ERR;
}
if (memcpy_s((char *)cloudSyncInfo->peerIrk, LFINDER_IRK_LEN, (char *)nodeInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN) !=
EOK) {
LNN_LOGE(LNN_BUILDER, "fail:memcpy_s peerirk fail");
return SOFTBUS_MEM_ERR;
}
if (memcpy_s((char *)cloudSyncInfo->publicAddress, LFINDER_MAC_ADDR_LEN, (char *)nodeInfo->rpaInfo.publicAddress,
LFINDER_MAC_ADDR_LEN) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:memcpy_s publicaddress fail");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(cloudSyncInfo->remotePtk, PTK_DEFAULT_LEN, nodeInfo->remotePtk) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s remoteptk fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t ConvertNodeInfoToCloudSyncInfo(CloudSyncInfo *cloudSyncInfo, const NodeInfo *nodeInfo)
{
if (cloudSyncInfo == NULL || nodeInfo == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (ConvertNameInfoInternal(cloudSyncInfo, nodeInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s name info fail");
return SOFTBUS_MEM_ERR;
}
if (ConvertVersionInfoInternal(cloudSyncInfo, nodeInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s version info fail");
return SOFTBUS_MEM_ERR;
}
if (ConvertDevIdInfoInternal(cloudSyncInfo, nodeInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s devid info fail");
return SOFTBUS_MEM_ERR;
}
if (ConvertAbilityInfoInternal(cloudSyncInfo, nodeInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s alibity info fail");
return SOFTBUS_MEM_ERR;
}
if (ConvertAddressInfoInternal(cloudSyncInfo, nodeInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s address info fail");
return SOFTBUS_MEM_ERR;
}
if (ConvertCipherInfoInternal(cloudSyncInfo, nodeInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s cipher info fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t DBDataChangeSyncToCacheInternal(NodeInfo *cacheInfo, char *fieldName, const char *value,
size_t valueLength, const char *udid)
{
LNN_LOGI(LNN_BUILDER, "DBDataChangeSyncToCacheInternal enter.");
if (cacheInfo == NULL || fieldName == NULL || value == NULL || udid == NULL || strlen(udid) > UDID_BUF_LEN - 1) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0 && valueLength < SESSION_KEY_LENGTH) {
if (memcpy_s(cacheInfo->cipherInfo.key, SESSION_KEY_LENGTH, value, SESSION_KEY_LENGTH) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:memcpy_s cipherkey fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0 && valueLength < BROADCAST_IV_LEN) {
if (memcpy_s(cacheInfo->cipherInfo.iv, BROADCAST_IV_LEN, value, BROADCAST_IV_LEN) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:memcpy_s cipheriv fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0 && valueLength < NETWORK_ID_BUF_LEN) {
if (strcpy_s(cacheInfo->networkId, NETWORK_ID_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s networkid fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0) {
cacheInfo->stateVersion = atoi(value);
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s devicename fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifiedname fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifieddefaultname fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s nickname fail");
return SOFTBUS_MEM_ERR;
}
} else {
LNN_LOGE(LNN_BUILDER, "fail:invalid fieldname or valuelength over range");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t DBCipherInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
{
LNN_LOGI(LNN_BUILDER, "DBCipherInfoSyncToCache enter.");
if (cacheInfo == NULL || fieldName == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0 && valueLength < SESSION_KEY_LENGTH) {
if (strcpy_s((char *)cacheInfo->cipherInfo.key, SESSION_KEY_LENGTH, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s cipherkey fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0 && valueLength < BROADCAST_IV_LEN) {
if (strcpy_s((char *)cacheInfo->cipherInfo.iv, BROADCAST_IV_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s cipheriv fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_JSON_KEY_TABLE_MIAN) == 0 && valueLength < BLE_BROADCAST_IV_LEN + 1) {
LNN_LOGI(LNN_BUILDER, "cipher table mian info no need update into nodeinfo");
} else if (strcmp(fieldName, DEVICE_INFO_JSON_KEY_TOTAL_LIFE) == 0) {
LNN_LOGI(LNN_BUILDER, "cipher total life info no need update into nodeinfo");
} else if (strcmp(fieldName, DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN) == 0) {
LNN_LOGI(LNN_BUILDER, "cipher timestamp begin info no need update into nodeinfo");
} else if (strcmp(fieldName, DEVICE_INFO_JSON_KEY_CURRENT_INDEX) == 0) {
LNN_LOGI(LNN_BUILDER, "cipher current index info no need update into nodeinfo");
} else if (strcmp(fieldName, DEVICE_INFO_DISTRIBUTED_SWITCH) == 0) {
LNN_LOGI(LNN_BUILDER, "distributed switch info no need update into nodeinfo");
} else {
LNN_LOGE(LNN_BUILDER, "fail:invalid fieldname or cipher info valuelength over range");
return SOFTBUS_MEM_ERR;
}
LNN_LOGI(LNN_BUILDER, "DBCipherInfoSyncToCache success.");
return SOFTBUS_OK;
}
static int32_t DBDeviceBasicInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
{
LNN_LOGI(LNN_BUILDER, "DBDeviceBasicInfoSyncToCache enter.");
if (cacheInfo == NULL || fieldName == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s devicename fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifiedname fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s unifieddefaultname fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0 && valueLength < DEVICE_NAME_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s nickname fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_UDID) == 0 && valueLength < UDID_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s deviceUdid fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_TYPE) == 0 && valueLength < DEVICE_TYPE_BUF_LEN) {
uint16_t typeId = 0;
if (LnnConvertDeviceTypeToId(value, &typeId) != SOFTBUS_OK) {
cacheInfo->deviceInfo.deviceTypeId = 0;
}
cacheInfo->deviceInfo.deviceTypeId = typeId;
} else if (strcmp(fieldName, DEVICE_INFO_OS_TYPE) == 0) {
cacheInfo->deviceInfo.osType = atoi(value);
} else if (strcmp(fieldName, DEVICE_INFO_OS_VERSION) == 0 && valueLength < OS_VERSION_BUF_LEN) {
if (strcpy_s(cacheInfo->deviceInfo.osVersion, OS_VERSION_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s osVersion fail");
return SOFTBUS_MEM_ERR;
}
} else {
LNN_LOGE(LNN_BUILDER, "fail:device basicinfo valuelength over range");
return SOFTBUS_MEM_ERR;
}
LNN_LOGI(LNN_BUILDER, "DBDeviceBasicInfoSyncToCache success.");
return SOFTBUS_OK;
}
static int32_t DBNumInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value)
{
LNN_LOGI(LNN_BUILDER, "DBNumInfoSyncToCache enter.");
if (cacheInfo == NULL || fieldName == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0) {
cacheInfo->stateVersion = atoi(value);
} else if (strcmp(fieldName, DEVICE_INFO_TRANSPORT_PROTOCOL) == 0) {
cacheInfo->supportedProtocols = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_WIFI_VERSION) == 0) {
cacheInfo->wifiVersion = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_BLE_VERSION) == 0) {
cacheInfo->bleVersion = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_ACCOUNT_ID) == 0) {
cacheInfo->accountId = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_FEATURE) == 0) {
cacheInfo->feature = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_CONN_SUB_FEATURE) == 0) {
cacheInfo->connSubFeature = atoll(value);
} else if (strcmp(fieldName, DEVICE_INFO_AUTH_CAP) == 0) {
cacheInfo->authCapacity = atoi(value);
}
LNN_LOGI(LNN_BUILDER, "DBNumInfoSyncToCache success.");
return SOFTBUS_OK;
}
static int32_t DBConnectInfoSyncToCache(NodeInfo *cacheInfo, char *fieldName, const char *value, size_t valueLength)
{
LNN_LOGI(LNN_BUILDER, "DBConnectInfoSyncToCache enter.");
if (cacheInfo == NULL || fieldName == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0 && valueLength < NETWORK_ID_BUF_LEN) {
if (strcpy_s(cacheInfo->networkId, NETWORK_ID_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s networkid fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_PKG_VERSION) == 0 && valueLength < VERSION_MAX_LEN) {
if (strcpy_s(cacheInfo->pkgVersion, VERSION_MAX_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s pkgVersion fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_BT_MAC) == 0 && valueLength < MAC_LEN) {
if (strcpy_s(cacheInfo->connectInfo.macAddr, MAC_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s macAddress fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_P2P_MAC_ADDR) == 0 && valueLength < MAC_LEN) {
if (strcpy_s(cacheInfo->p2pInfo.p2pMac, MAC_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s p2pMac fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_IRK) == 0 && valueLength < LFINDER_IRK_LEN) {
if (strcpy_s((char *)cacheInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s peerIrk fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_PUB_MAC) == 0 && valueLength < LFINDER_MAC_ADDR_LEN) {
if (strcpy_s((char *)cacheInfo->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s publicAddress fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_PTK) == 0 && valueLength < PTK_DEFAULT_LEN) {
if (strcpy_s(cacheInfo->remotePtk, PTK_DEFAULT_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s remotePtk fail");
return SOFTBUS_MEM_ERR;
}
} else {
LNN_LOGE(LNN_BUILDER, "fail:connect info valuelength over range");
return SOFTBUS_MEM_ERR;
}
LNN_LOGI(LNN_BUILDER, "DBConnectInfoSyncToCache success.");
return SOFTBUS_OK;
}
static bool JudgeFieldNameIsDeviceBasicInfo(char *fieldName)
{
if (fieldName == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return false;
}
if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0 || strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0 ||
strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0 ||
strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0 || strcmp(fieldName, DEVICE_INFO_DEVICE_UDID) == 0 ||
strcmp(fieldName, DEVICE_INFO_DEVICE_TYPE) == 0 || strcmp(fieldName, DEVICE_INFO_OS_TYPE) == 0 ||
strcmp(fieldName, DEVICE_INFO_OS_VERSION) == 0) {
return true;
}
return false;
}
static bool JudgeFieldNameIsNumInfo(char *fieldName)
{
if (fieldName == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return false;
}
if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0 || strcmp(fieldName, DEVICE_INFO_TRANSPORT_PROTOCOL) == 0 ||
strcmp(fieldName, DEVICE_INFO_WIFI_VERSION) == 0 || strcmp(fieldName, DEVICE_INFO_BLE_VERSION) == 0 ||
strcmp(fieldName, DEVICE_INFO_ACCOUNT_ID) == 0 || strcmp(fieldName, DEVICE_INFO_FEATURE) == 0 ||
strcmp(fieldName, DEVICE_INFO_CONN_SUB_FEATURE) == 0 || strcmp(fieldName, DEVICE_INFO_AUTH_CAP) == 0) {
return true;
}
return false;
}
static bool JudgeFieldNameIsConnectInfo(char *fieldName)
{
if (fieldName == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return false;
}
if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0 || strcmp(fieldName, DEVICE_INFO_PKG_VERSION) == 0 ||
strcmp(fieldName, DEVICE_INFO_BT_MAC) == 0 || strcmp(fieldName, DEVICE_INFO_P2P_MAC_ADDR) == 0 ||
strcmp(fieldName, DEVICE_INFO_DEVICE_IRK) == 0 || strcmp(fieldName, DEVICE_INFO_DEVICE_PUB_MAC) == 0 ||
strcmp(fieldName, DEVICE_INFO_PTK) == 0) {
return true;
}
return false;
}
static bool JudgeFieldNameIsCipherInfo(char *fieldName)
{
if (fieldName == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return false;
}
if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0 ||
strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0 ||
strcmp(fieldName, DEVICE_INFO_JSON_KEY_TABLE_MIAN) == 0 ||
strcmp(fieldName, DEVICE_INFO_JSON_KEY_TOTAL_LIFE) == 0 ||
strcmp(fieldName, DEVICE_INFO_JSON_KEY_TIMESTAMP_BEGIN) == 0 ||
strcmp(fieldName, DEVICE_INFO_JSON_KEY_CURRENT_INDEX) == 0 ||
strcmp(fieldName, DEVICE_INFO_DISTRIBUTED_SWITCH) == 0) {
return true;
}
return false;
}
static int32_t DBDataChangeBatchSyncToCacheInternal(NodeInfo *cacheInfo, char *fieldName, const char *value,
size_t valueLength, const char *udid)
{
if (cacheInfo == NULL || fieldName == NULL || value == NULL || udid == NULL || strlen(udid) > UDID_BUF_LEN - 1) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (JudgeFieldNameIsDeviceBasicInfo(fieldName) == true) {
if (DBDeviceBasicInfoSyncToCache(cacheInfo, fieldName, value, valueLength) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s device basic info to cache fail");
return SOFTBUS_MEM_ERR;
}
} else if (JudgeFieldNameIsNumInfo(fieldName) == true) {
if (DBNumInfoSyncToCache(cacheInfo, fieldName, value) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s device name fail");
return SOFTBUS_MEM_ERR;
}
} else if (JudgeFieldNameIsConnectInfo(fieldName) == true) {
if (DBConnectInfoSyncToCache(cacheInfo, fieldName, value, valueLength) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s connect info fail");
return SOFTBUS_MEM_ERR;
}
} else if (JudgeFieldNameIsCipherInfo(fieldName) == true) {
if (DBCipherInfoSyncToCache(cacheInfo, fieldName, value, valueLength) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s cipher info fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_UUID) == 0 && valueLength < UUID_BUF_LEN) {
if (strcpy_s(cacheInfo->uuid, UUID_BUF_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s uuid fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_SW_VERSION) == 0 && valueLength < VERSION_MAX_LEN) {
if (strcpy_s(cacheInfo->softBusVersion, VERSION_MAX_LEN, value) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s softbusVersion fail");
return SOFTBUS_MEM_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_BLE_P2P) == 0) {
if (strcmp(value, "true") == 0) {
cacheInfo->isBleP2p = true;
} else {
cacheInfo->isBleP2p = false;
}
} else {
LNN_LOGE(LNN_BUILDER, "fail:invalid fieldname");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t SplitKeyOrValue(const char *key, char splitKeyValue[][SPLIT_MAX_LEN])
{
if (key == NULL || splitKeyValue == NULL) {
LNN_LOGE(LNN_BUILDER, "key or splitKeyValue is NULL");
return SOFTBUS_INVALID_PARAM;
}
int index = 0;
char *infoStr = NULL;
char *nextToken = NULL;
infoStr = strtok_s((char *)key, "#", &nextToken);
while (infoStr != NULL) {
if (strcpy_s(splitKeyValue[index++], SPLIT_MAX_LEN, infoStr) != EOK) {
LNN_LOGE(LNN_BUILDER, "strcpy_s SplitKeyOrValue fail");
return SOFTBUS_MEM_ERR;
}
infoStr = strtok_s(NULL, "#", &nextToken);
}
return SOFTBUS_OK;
}
static int32_t GetInfoFromSplitKey(char splitKey[][SPLIT_MAX_LEN], int64_t *accountId, char *deviceUdid,
char *fieldName)
{
if (splitKey == NULL || accountId == NULL || deviceUdid == NULL || fieldName == NULL) {
LNN_LOGE(LNN_BUILDER, "invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (sscanf_s(splitKey[0], "%ld", accountId) <= 0) {
LNN_LOGE(LNN_BUILDER, "fail:sscanf_s accountId fail.");
return SOFTBUS_ERR;
}
if (strcpy_s(deviceUdid, UDID_BUF_LEN, splitKey[1]) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s deviceUdid fail.");
return SOFTBUS_MEM_ERR;
}
if (strcpy_s(fieldName, FIELDNAME_MAX_LEN, splitKey[SPLIT_VALUE_NUM]) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s fieldName fail.");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t SplitString(char splitKey[][SPLIT_MAX_LEN], char splitValue[][SPLIT_MAX_LEN], const char *key,
const char *value, int32_t *stateVersion)
{
if (key == NULL || value == NULL || splitKey == NULL || splitValue == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (SplitKeyOrValue(key, splitKey) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "split key error");
return SOFTBUS_ERR;
}
if (SplitKeyOrValue(value, splitValue) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "split value error");
return SOFTBUS_ERR;
}
*stateVersion = atoi(splitValue[1]);
return SOFTBUS_OK;
}
static int32_t HandleDBAddChangeInternal(const char *key, const char *value, NodeInfo *cacheInfo)
{
LNN_LOGI(LNN_BUILDER, "HandleDBAddChangeInternal enter.");
if (key == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
int64_t accountId = 0;
char deviceUdid[UDID_BUF_LEN] = {0};
char fieldName[FIELDNAME_MAX_LEN] = {0};
int32_t stateVersion = 0;
char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN] = {0};
char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN] = {0};
if (SplitString(splitKey, splitValue, key, value, &stateVersion) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "split string error");
return SOFTBUS_ERR;
}
if (GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get info from splitkey error");
return SOFTBUS_ERR;
}
char trueValue[SPLIT_MAX_LEN] = {0};
if (strcpy_s(trueValue, SPLIT_MAX_LEN, splitValue[0]) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s true value fail.");
return SOFTBUS_ERR;
}
NodeInfo localCaheInfo = { 0 };
if (LnnGetLocalCacheNodeInfo(&localCaheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
return SOFTBUS_ERR;
}
if (strcmp(deviceUdid, localCaheInfo.deviceInfo.deviceUdid) == 0) {
return SOFTBUS_OK;
}
if (DBDataChangeBatchSyncToCacheInternal(cacheInfo, fieldName, trueValue, strlen(trueValue), deviceUdid) !=
SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:DB data change batch sync to cache fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
static int32_t SetDBDataToDistributedLedger(NodeInfo *cacheInfo, char *deviceUdid, size_t udidLength, char *fieldName)
{
LNN_LOGI(LNN_BUILDER, "SetDBDataToDistributedLedger enter.");
if (cacheInfo == NULL || deviceUdid == NULL || udidLength > UDID_BUF_LEN - 1 || fieldName == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return SOFTBUS_INVALID_PARAM;
}
if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_KEY) == 0) {
if (LnnSetDLDeviceBroadcastCipherKey(deviceUdid, (char *)cacheInfo->cipherInfo.key) != true) {
LNN_LOGE(LNN_BUILDER, "set device cipherkey to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_BROADCAST_CIPHER_IV) == 0) {
if (LnnSetDLDeviceBroadcastCipherIv(deviceUdid, (char *)cacheInfo->cipherInfo.iv) != true) {
LNN_LOGE(LNN_BUILDER, "set device cipheriv to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_NETWORK_ID) == 0) {
if (LnnUpdateNetworkId(cacheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "set device networkId to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_STATE_VERSION) == 0) {
if (LnnSetDLDeviceStateVersion(deviceUdid, cacheInfo->stateVersion) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "set device stateversion to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_DEVICE_NAME) == 0) {
if (LnnSetDLDeviceInfoName(deviceUdid, cacheInfo->deviceInfo.deviceName) != true) {
LNN_LOGE(LNN_BUILDER, "set device name to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEVICE_NAME) == 0) {
if (LnnSetDLUnifiedDeviceName(deviceUdid, cacheInfo->deviceInfo.unifiedName) != true) {
LNN_LOGE(LNN_BUILDER, "set device unifiedName to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME) == 0) {
if (LnnSetDLUnifiedDefaultDeviceName(deviceUdid, cacheInfo->deviceInfo.unifiedDefaultName) != true) {
LNN_LOGE(LNN_BUILDER, "set device unifiedDefaultName to distributedLedger fail");
return SOFTBUS_ERR;
}
} else if (strcmp(fieldName, DEVICE_INFO_SETTINGS_NICK_NAME) == 0) {
if (LnnSetDLDeviceNickNameByUdid(deviceUdid, cacheInfo->deviceInfo.nickName) != true) {
LNN_LOGE(LNN_BUILDER, "set device nickName to distributedLedger fail");
return SOFTBUS_ERR;
}
} else {
LNN_LOGE(LNN_BUILDER, "fail:invalid fieldname");
return SOFTBUS_ERR;
}
return SOFTBUS_OK;
}
static void UpdateInfoToCacheAndLedger(NodeInfo *cacheInfo, char *deviceUdid, char *fieldName, char *value)
{
LNN_LOGI(LNN_BUILDER, "UpdateInfoToCacheAndLedger enter");
if (cacheInfo == NULL || deviceUdid == NULL || strlen(deviceUdid) > UDID_BUF_LEN - 1 || fieldName == NULL ||
value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param");
return;
}
if (DBDataChangeSyncToCacheInternal(cacheInfo, fieldName, value, strlen(value), deviceUdid) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:DB data change sync to cache fail");
return;
}
if (SetDBDataToDistributedLedger(cacheInfo, deviceUdid, strlen(deviceUdid), fieldName) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "set DB data to distributedLedger fail");
}
}
static int32_t HandleDBUpdateChangeInternal(const char *key, const char *value)
{
if (key == NULL || value == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param.");
return SOFTBUS_INVALID_PARAM;
}
int64_t accountId = 0;
char deviceUdid[UDID_BUF_LEN] = {0};
char fieldName[FIELDNAME_MAX_LEN] = {0};
int32_t stateVersion = 0;
char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN] = {0};
char splitValue[SPLIT_VALUE_NUM][SPLIT_MAX_LEN] = {0};
if (SplitString(splitKey, splitValue, key, value, &stateVersion) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "split string error");
return SOFTBUS_ERR;
}
if (GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get info from splitkey error");
return SOFTBUS_ERR;
}
char trueValue[SPLIT_MAX_LEN] = {0};
if (strcpy_s(trueValue, SPLIT_MAX_LEN, splitValue[0]) != EOK) {
LNN_LOGE(LNN_BUILDER, "fail:strcpy_s true value fail.");
return SOFTBUS_ERR;
}
NodeInfo localCaheInfo = { 0 };
if (LnnGetLocalCacheNodeInfo(&localCaheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
return SOFTBUS_ERR;
}
if (strcmp(deviceUdid, localCaheInfo.deviceInfo.deviceUdid) == 0) {
return SOFTBUS_OK;
}
Map deviceCacheInfoMap = { 0 };
if (LnnGetRemoteCacheNodeInfo(&deviceCacheInfoMap) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get remote cache node map info fail");
return SOFTBUS_ERR;
}
NodeInfo *cacheInfo = (NodeInfo *)LnnMapGet(&deviceCacheInfoMap, deviceUdid);
if (cacheInfo == NULL) {
LNN_LOGI(LNN_BUILDER, "no this device info in deviceCacheInfoMap");
return SOFTBUS_ERR;
}
if (cacheInfo->stateVersion >= stateVersion && stateVersion != 1) {
LNN_LOGI(LNN_BUILDER, "cache is up-to-date, no need to update");
return SOFTBUS_OK;
}
cacheInfo->stateVersion = stateVersion;
UpdateInfoToCacheAndLedger(cacheInfo, deviceUdid, fieldName, trueValue);
(void)LnnSaveRemoteDeviceInfo(cacheInfo);
return SOFTBUS_OK;
}
static int32_t HandleDBDeleteChangeInternal(const char *key, const char *value)
{
LNN_LOGI(LNN_BUILDER, "HandleDBDeleteChangeInternal enter.");
if (key == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param key");
return SOFTBUS_INVALID_PARAM;
}
int64_t accountId = 0;
char deviceUdid[UDID_BUF_LEN] = {0};
char fieldName[FIELDNAME_MAX_LEN] = {0};
char splitKey[SPLIT_KEY_NUM][SPLIT_MAX_LEN] = {0};
if (SplitKeyOrValue(key, splitKey) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "split key error");
return SOFTBUS_ERR;
}
if (GetInfoFromSplitKey(splitKey, &accountId, deviceUdid, fieldName) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get info from splitkey error");
return SOFTBUS_ERR;
}
Map deviceCacheInfoMap = { 0 };
if (LnnGetRemoteCacheNodeInfo(&deviceCacheInfoMap) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get remote cache node map info fail");
return SOFTBUS_ERR;
}
if (LnnMapGet(&deviceCacheInfoMap, (const char *)deviceUdid) == NULL) {
LNN_LOGI(LNN_BUILDER, "no device info in deviceCacheInfoMap, no need to delete");
return SOFTBUS_OK;
}
LnnDeleteDeviceInfo(deviceUdid);
LnnRemoveNode(deviceUdid);
LNN_LOGI(LNN_BUILDER, "HandleDBDeleteChangeInternal success");
return SOFTBUS_OK;
}
int32_t LnnGetAccountIdfromLocalCache(int64_t *buf)
{
LNN_LOGI(LNN_BUILDER, "LnnGetAccountIdfromLocalCache enter.");
if (buf == NULL) {
LNN_LOGE(LNN_BUILDER, "invalid param");
return SOFTBUS_INVALID_PARAM;
}
NodeInfo localCaheInfo = { 0 };
if (LnnGetLocalCacheNodeInfo(&localCaheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
return SOFTBUS_ERR;
}
*buf = localCaheInfo.accountId;
return SOFTBUS_OK;
}
static void FreeKeyAndValue(const char **key, const char **value, int32_t keySize)
{
for (int32_t i = 0; i < keySize; i++) {
SoftBusFree((void *)key[i]);
SoftBusFree((void *)value[i]);
}
SoftBusFree(key);
SoftBusFree(value);
}
int32_t LnnDBDataAddChangeSyncToCache(const char **key, const char **value, int32_t keySize)
{
LNN_LOGI(LNN_BUILDER, "LnnDBDataAddChangeSyncToCache enter.");
if (key == NULL || value == NULL || keySize == 0) {
LNN_LOGE(LNN_BUILDER, "invalid param or keySize is none");
return SOFTBUS_INVALID_PARAM;
}
NodeInfo cacheInfo = { 0 };
for (int32_t i = 0; i < keySize; i++) {
if (HandleDBAddChangeInternal(key[i], value[i], &cacheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:handle db data add change internal fail");
FreeKeyAndValue(key, value, keySize);
return SOFTBUS_ERR;
}
}
FreeKeyAndValue(key, value, keySize);
(void)LnnSaveRemoteDeviceInfo(&cacheInfo);
LNN_LOGI(LNN_BUILDER, "LnnDBDataAddChangeSyncToCache success.");
if (LnnUpdateDistributedNodeInfo(&cacheInfo, cacheInfo.deviceInfo.deviceUdid) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:Cache info add sync to Ledger fail");
return SOFTBUS_ERR;
}
return SOFTBUS_OK;
}
int32_t LnnDBDataChangeSyncToCache(const char *key, const char *value, ChangeType changeType)
{
LNN_LOGI(LNN_BUILDER, "LnnDBDataChangeSyncToCache enter.");
if (key == NULL) {
LNN_LOGE(LNN_BUILDER, "fail:invalid param key.");
return SOFTBUS_INVALID_PARAM;
}
int32_t ret = SOFTBUS_OK;
switch (changeType) {
case DB_UPDATE:
ret = HandleDBUpdateChangeInternal(key, value);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:handle db data update change internal fail");
return SOFTBUS_ERR;
}
break;
case DB_DELETE:
ret = HandleDBDeleteChangeInternal(key, value);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:handle db data delete change internal fail");
return SOFTBUS_ERR;
}
break;
default:
LNN_LOGE(LNN_BUILDER, "changeType is invalid");
return SOFTBUS_INVALID_PARAM;
}
LNN_LOGI(LNN_BUILDER, "LnnDBDataChangeSyncToCache success.");
return SOFTBUS_OK;
}
int32_t LnnLedgerDataChangeSyncToDB(const char *key, const char *value, size_t valueLength)
{
LNN_LOGI(LNN_BUILDER, "LnnLedgerDataChangeSyncToDB enter.");
if (key == NULL || value == NULL || valueLength > KEY_MAX_LEN - 1) {
LNN_LOGE(LNN_BUILDER, "fail:Ledger param is invalid.");
return SOFTBUS_INVALID_PARAM;
}
NodeInfo localCaheInfo = { 0 };
if (LnnGetLocalCacheNodeInfo(&localCaheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
return SOFTBUS_ERR;
}
char putKey[KEY_MAX_LEN] = {0};
if (sprintf_s(putKey, KEY_MAX_LEN, "%ld#%s#%s", localCaheInfo.accountId, localCaheInfo.deviceInfo.deviceUdid,
key) < 0) {
LNN_LOGE(LNN_BUILDER, "sprintf_s key fail");
return SOFTBUS_ERR;
}
char putValue[PUT_VALUE_MAX_LEN] = {0};
if (sprintf_s(putValue, PUT_VALUE_MAX_LEN, "%s#%d", value, localCaheInfo.stateVersion) < 0) {
LNN_LOGE(LNN_BUILDER, "sprintf_s value fail");
return SOFTBUS_ERR;
}
int32_t dbId = g_dbId;
int32_t ret = LnnPutDBData(dbId, putKey, strlen(putKey), putValue, strlen(putValue));
if (ret != 0) {
LNN_LOGE(LNN_BUILDER, "fail:data sync to DB fail, errorcode: %{public}d", ret);
return ret;
}
LNN_LOGI(LNN_BUILDER, "LnnLedgerDataChangeSyncToDB success.");
ret = LnnCloudSync(dbId);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:data change cloud sync fail, errorcode:%{public}d", ret);
return ret;
}
return SOFTBUS_OK;
}
int32_t LnnLedgerAllDataSyncToDB(const NodeInfo *info)
{
LNN_LOGI(LNN_BUILDER, "LnnLedgerAllDataSyncToDB enter.");
if (info == NULL) {
LNN_LOGE(LNN_BUILDER, "invalid param, info is NULL");
return SOFTBUS_INVALID_PARAM;
}
if (info->accountId == 0) {
LNN_LOGE(LNN_BUILDER, "ledger accountid is null, all data no need sync to cloud");
return SOFTBUS_ERR;
}
CloudSyncInfo syncInfo = { 0 };
syncInfo.distributedSwitch = true;
if (ConvertNodeInfoToCloudSyncInfo(&syncInfo, info) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:Ledger all data sync to cache fail.");
return SOFTBUS_ERR;
}
if (LnnGetLocalBroadcastCipherInfo(&syncInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get broadcastcipherinfo fail");
return SOFTBUS_ERR;
}
int32_t dbId = g_dbId;
int32_t ret = LnnPutDBDataBatch(dbId, &syncInfo);
if (ret != 0) {
LNN_LOGE(LNN_BUILDER, "fail:data batch sync to DB fail, errorcode:%{public}d", ret);
return ret;
}
LNN_LOGI(LNN_BUILDER, "LnnLedgerAllDataSyncToDB success.");
ret = LnnCloudSync(dbId);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:data batch cloud sync fail, errorcode:%{public}d", ret);
return ret;
}
return SOFTBUS_OK;
}
int32_t LnnDeleteSyncToDB(void)
{
LNN_LOGI(LNN_BUILDER, "LnnDeleteSyncToDB enter");
NodeInfo localCaheInfo = { 0 };
if (LnnGetLocalCacheNodeInfo(&localCaheInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "get local cache node info fail");
return SOFTBUS_ERR;
}
char key[KEY_MAX_LEN] = {0};
if (sprintf_s(key, KEY_MAX_LEN, "%ld#%s", localCaheInfo.accountId, localCaheInfo.deviceInfo.deviceUdid) < 0) {
LNN_LOGE(LNN_BUILDER, "sprintf_s key fail");
return SOFTBUS_ERR;
}
int32_t dbId = g_dbId;
int32_t ret = LnnDeleteDBDataByPrefix(dbId, key, strlen(key));
if (ret != 0) {
LNN_LOGE(LNN_BUILDER, "fail:data delete sync to DB fail");
return ret;
}
LNN_LOGI(LNN_BUILDER, "LnnDeleteSyncToDB success.");
ret = LnnCloudSync(dbId);
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "fail:data delete cloud sync fail, errorcode:%{public}d", ret);
return ret;
}
return SOFTBUS_OK;
}
void LnnInitCloudSyncModule(void)
{
LNN_LOGI(LNN_BUILDER, "LnnInitCloudSyncModule enter.");
int32_t dbId = 0;
if (LnnCreateKvAdapter(&dbId, APPID, strlen(APPID), STOREID, strlen(STOREID)) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "Lnn Init Cloud Sync Module fail");
return;
}
g_dbId = dbId;
}
void LnnDeInitCloudSyncModule(void)
{
LNN_LOGI(LNN_BUILDER, "LnnDeInitCloudSyncModule enter.");
int32_t dbId = g_dbId;
if (LnnDestroyKvAdapter(dbId) != SOFTBUS_OK) {
LNN_LOGE(LNN_BUILDER, "DeInit Cloud Sync module fail");
}
}

69
core/bus_center/lnn/net_builder/src/lnn_data_cloud_sync_virtual.c Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright (c) 2024 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 "lnn_data_cloud_sync.h"
#include "softbus_errcode.h"
void LnnInitCloudSyncModule(void)
{
return;
}
void LnnDeInitCloudSyncModule(void)
{
return;
}
int32_t LnnLedgerAllDataSyncToDB(const NodeInfo *info)
{
(void)info;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnLedgerDataChangeSyncToDB(const char *key, const char *value, size_t valueLength)
{
(void)key;
(void)value;
(void)valueLength;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnDeleteSyncToDB(void)
{
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnDBDataChangeSyncToCache(const char *key, const char *value, ChangeType changeType)
{
(void)key;
(void)value;
(void)changeType;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnDBDataAddChangeSyncToCache(const char **key, const char **value, int32_t keySize)
{
(void)key;
(void)value;
(void)keySize;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnGetAccountIdfromLocalCache(int64_t *buf)
{
(void)buf;
return SOFTBUS_NOT_IMPLEMENT;
}

17
core/bus_center/lnn/net_builder/src/lnn_device_info_recovery_virtual.c
View File

@ -82,3 +82,20 @@ int32_t LnnGetUdidByBrMac(const char *brMac, char *udid, uint32_t udidLen)
(void)udidLen;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnGetLocalCacheNodeInfo(NodeInfo *info)
{
(void)info;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnGetRemoteCacheNodeInfo(Map *devMap)
{
(void)devMap;
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t LnnLoadLocalDeviceAccountIdInfo(void)
{
return SOFTBUS_NOT_IMPLEMENT;
}

4
core/bus_center/lnn/net_ledger/common/src/lnn_net_ledger.c
View File

@ -24,6 +24,7 @@
#include "bus_center_event.h"
#include "bus_center_manager.h"
#include "lnn_cipherkey_manager.h"
#include "lnn_data_cloud_sync.h"
#include "lnn_decision_db.h"
#include "lnn_distributed_net_ledger.h"
#include "lnn_huks_utils.h"
@ -162,6 +163,8 @@ static void LnnRestoreLocalDeviceInfo()
int32_t LnnInitNetLedgerDelay(void)
{
LnnLoadLocalDeviceAccountIdInfo();
LnnInitCloudSyncModule();
if (LnnInitLocalLedgerDelay() != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "delay init local ledger fail");
return SOFTBUS_ERR;
@ -181,6 +184,7 @@ void LnnDeinitNetLedger(void)
LnnDeinitLocalLedger();
LnnDeinitHuksInterface();
LnnDeinitMetaNodeExtLedger();
LnnDeInitCloudSyncModule();
}
static int32_t LnnGetNodeKeyInfoLocal(const char *networkId, int key, uint8_t *info, uint32_t infoLen)

7
core/bus_center/lnn/net_ledger/distributed_ledger/include/lnn_distributed_net_ledger.h
View File

@ -94,6 +94,13 @@ NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type);
bool LnnSetDlPtk(const char *networkId, const char *remotePtk);
bool LnnSetDLWifiDirectAddr(const char *networkId, const char *addr);
int32_t LnnGetOsTypeByNetworkId(const char *networkId, int32_t *osType);
bool LnnSetDLUnifiedDeviceName(const char *udid, const char *name);
bool LnnSetDLUnifiedDefaultDeviceName(const char *udid, const char *name);
bool LnnSetDLDeviceNickNameByUdid(const char *udid, const char *name);
bool LnnSetDLDeviceStateVersion(const char *udid, int32_t stateVersion);
int32_t LnnUpdateDistributedNodeInfo(NodeInfo *newInfo, const char *udid);
bool LnnSetDLDeviceBroadcastCipherKey(const char *udid, const char *cipherKey);
bool LnnSetDLDeviceBroadcastCipherIv(const char *udid, const char *cipherIv);
#ifdef __cplusplus
}
#endif

252
core/bus_center/lnn/net_ledger/distributed_ledger/src/lnn_distributed_net_ledger.c
View File

@ -2139,6 +2139,258 @@ EXIT:
return false;
}
bool LnnSetDLUnifiedDeviceName(const char *udid, const char *name)
{
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *info = NULL;
if (udid == NULL || name == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return false;
}
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return false;
}
info = GetNodeInfoFromMap(map, udid);
if (info == NULL) {
LNN_LOGE(LNN_LEDGER, "udid not exist");
goto EXIT;
}
if (strcmp(info->deviceInfo.unifiedName, name) == 0) {
LNN_LOGI(LNN_LEDGER, "deviceunifiedname not change");
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
}
if (strncpy_s(info->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
LNN_LOGE(LNN_LEDGER, "set deviceunifiedname error");
goto EXIT;
}
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
EXIT:
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return false;
}
bool LnnSetDLUnifiedDefaultDeviceName(const char *udid, const char *name)
{
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *info = NULL;
if (udid == NULL || name == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return false;
}
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return false;
}
info = GetNodeInfoFromMap(map, udid);
if (info == NULL) {
LNN_LOGE(LNN_LEDGER, "udid not exist");
goto EXIT;
}
if (strcmp(info->deviceInfo.unifiedDefaultName, name) == 0) {
LNN_LOGI(LNN_LEDGER, "deviceunifiedDefaultName not change");
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
}
if (strncpy_s(info->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
LNN_LOGE(LNN_LEDGER, "set deviceunifiedDefaultName error");
goto EXIT;
}
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
EXIT:
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return false;
}
bool LnnSetDLDeviceNickNameByUdid(const char *udid, const char *name)
{
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *info = NULL;
if (udid == NULL || name == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return false;
}
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return false;
}
info = GetNodeInfoFromMap(map, udid);
if (info == NULL) {
LNN_LOGE(LNN_LEDGER, "udid not exist");
goto EXIT;
}
if (strcmp(info->deviceInfo.nickName, name) == 0) {
LNN_LOGI(LNN_LEDGER, "devicenickName not change");
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
}
if (strncpy_s(info->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, name, strlen(name)) != EOK) {
LNN_LOGE(LNN_LEDGER, "set devicenickName error");
goto EXIT;
}
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
EXIT:
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return false;
}
bool LnnSetDLDeviceStateVersion(const char *udid, int32_t stateVersion)
{
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *info = NULL;
if (udid == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return false;
}
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return false;
}
info = GetNodeInfoFromMap(map, udid);
if (info == NULL) {
LNN_LOGE(LNN_LEDGER, "udid not exist");
goto EXIT;
}
if (info->stateVersion == stateVersion) {
LNN_LOGI(LNN_LEDGER, "device stateversion not change");
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
}
info->stateVersion = stateVersion;
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
EXIT:
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return false;
}
bool LnnSetDLDeviceBroadcastCipherKey(const char *udid, const char *cipherKey)
{
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *info = NULL;
if (udid == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return false;
}
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return false;
}
info = GetNodeInfoFromMap(map, udid);
if (info == NULL) {
LNN_LOGE(LNN_LEDGER, "udid not exist");
goto EXIT;
}
if (memcpy_s(info->cipherInfo.key, SESSION_KEY_LENGTH, cipherKey, strlen(cipherKey)) != EOK) {
LNN_LOGE(LNN_LEDGER, "set BroadcastcipherKey error");
goto EXIT;
}
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
EXIT:
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return false;
}
bool LnnSetDLDeviceBroadcastCipherIv(const char *udid, const char *cipherIv)
{
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *info = NULL;
if (udid == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return false;
}
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return false;
}
info = GetNodeInfoFromMap(map, udid);
if (info == NULL) {
LNN_LOGE(LNN_LEDGER, "udid not exist");
goto EXIT;
}
if (memcpy_s(info->cipherInfo.iv, BROADCAST_IV_LEN, cipherIv, strlen(cipherIv)) != EOK) {
LNN_LOGE(LNN_LEDGER, "set BroadcastcipherKey error");
goto EXIT;
}
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return true;
EXIT:
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return false;
}
static void UpdateDistributedLedger(NodeInfo *newInfo, NodeInfo *oldInfo)
{
if (newInfo == NULL || oldInfo == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return;
}
(void)strcpy_s(oldInfo->networkId, NETWORK_ID_BUF_LEN, newInfo->networkId);
(void)strcpy_s(oldInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.deviceName);
(void)strcpy_s(oldInfo->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.unifiedName);
(void)strcpy_s(oldInfo->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.unifiedDefaultName);
(void)strcpy_s(oldInfo->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, newInfo->deviceInfo.nickName);
oldInfo->deviceInfo.deviceTypeId = newInfo->deviceInfo.deviceTypeId;
(void)strcpy_s(oldInfo->deviceInfo.deviceUdid, UDID_BUF_LEN, newInfo->deviceInfo.deviceUdid);
(void)strcpy_s(oldInfo->uuid, UUID_BUF_LEN, newInfo->uuid);
(void)strcpy_s(oldInfo->softBusVersion, VERSION_MAX_LEN, newInfo->softBusVersion);
oldInfo->isBleP2p = newInfo->isBleP2p;
oldInfo->supportedProtocols = newInfo->supportedProtocols;
(void)strcpy_s(oldInfo->pkgVersion, VERSION_MAX_LEN, newInfo->pkgVersion);
oldInfo->wifiVersion = newInfo->wifiVersion;
oldInfo->bleVersion = newInfo->bleVersion;
(void)strcpy_s(oldInfo->connectInfo.macAddr, MAC_LEN, newInfo->connectInfo.macAddr);
oldInfo->accountId = newInfo->accountId;
oldInfo->feature = newInfo->feature;
oldInfo->connSubFeature = newInfo->connSubFeature;
oldInfo->authCapacity = newInfo->authCapacity;
oldInfo->deviceInfo.osType = newInfo->deviceInfo.osType;
oldInfo->stateVersion = newInfo->stateVersion;
(void)strcpy_s(oldInfo->deviceInfo.osVersion, OS_VERSION_BUF_LEN, newInfo->deviceInfo.osVersion);
(void)strcpy_s(oldInfo->p2pInfo.p2pMac, MAC_LEN, newInfo->p2pInfo.p2pMac);
(void)memcpy_s((char *)oldInfo->rpaInfo.peerIrk, LFINDER_IRK_LEN, (char *)newInfo->rpaInfo.peerIrk,
LFINDER_IRK_LEN);
(void)strcpy_s((char *)oldInfo->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN,
(char *)newInfo->rpaInfo.publicAddress);
(void)strcpy_s(oldInfo->remotePtk, PTK_DEFAULT_LEN, newInfo->remotePtk);
(void)memcpy_s(oldInfo->cipherInfo.key, SESSION_KEY_LENGTH, newInfo->cipherInfo.key, SESSION_KEY_LENGTH);
(void)memcpy_s(oldInfo->cipherInfo.iv, BROADCAST_IV_LEN, newInfo->cipherInfo.iv, BROADCAST_IV_LEN);
}
int32_t LnnUpdateDistributedNodeInfo(NodeInfo *newInfo, const char *udid)
{
if (newInfo == NULL || udid == NULL) {
LNN_LOGE(LNN_LEDGER, "param error");
return SOFTBUS_INVALID_PARAM;
}
DoubleHashMap *map = &g_distributedNetLedger.distributedInfo;
NodeInfo *oldInfo = (NodeInfo *)LnnMapGet(&map->udidMap, udid);
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
LNN_LOGE(LNN_LEDGER, "lock mutex fail");
return SOFTBUS_LOCK_ERR;
}
if (oldInfo == NULL) {
LNN_LOGI(LNN_LEDGER, "no this device info in ledger, need to insert");
int32_t ret = LnnMapSet(&map->udidMap, udid, newInfo, sizeof(NodeInfo));
if (ret != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "lnn map set failed, ret=%{public}d", ret);
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_ERR;
}
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_OK;
}
UpdateDistributedLedger(newInfo, oldInfo);
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_OK;
}
bool LnnSetDLP2pInfo(const char *networkId, const P2pInfo *info)
{
NodeInfo *node = NULL;

129
core/bus_center/lnn/net_ledger/local_ledger/src/lnn_local_net_ledger.c
View File

@ -25,6 +25,7 @@
#include "bus_center_adapter.h"
#include "bus_center_manager.h"
#include "lnn_cipherkey_manager.h"
#include "lnn_data_cloud_sync.h"
#include "lnn_device_info_recovery.h"
#include "lnn_parameter_utils.h"
#include "lnn_log.h"
@ -49,6 +50,8 @@
#define SUPPORT_EXCHANGE_NETWORKID 1
#define SUPPORT_NORMALIZED_LINK 2
#define DEFAULT_CONN_SUB_FEATURE 1
#define CACHE_KEY_LENGTH 32
#define STATE_VERSION_VALUE_LENGTH 8
typedef struct {
NodeInfo localInfo;
@ -57,6 +60,7 @@ typedef struct {
} LocalNetLedger;
static LocalNetLedger g_localNetLedger;
static int64_t g_memAccount;
static void UpdateStateVersionAndStore(void)
{
@ -70,6 +74,16 @@ static void UpdateStateVersionAndStore(void)
if ((ret = LnnSaveLocalDeviceInfo(&g_localNetLedger.localInfo)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "update local store fail");
}
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return;
}
char value[STATE_VERSION_VALUE_LENGTH] = {0};
(void)sprintf_s(value, STATE_VERSION_VALUE_LENGTH, "%d", g_localNetLedger.localInfo.stateVersion);
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_STATE_VERSION, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger state version change sync to cloud failed");
}
}
static int32_t LlGetNodeSoftBusVersion(void *buf, uint32_t len)
@ -310,6 +324,42 @@ static int32_t LocalUpdateNodeAccountId(const void *buf)
if (buf == NULL) {
return SOFTBUS_INVALID_PARAM;
}
if (info->accountId == 0) {
if (*((int64_t *)buf) == 0) {
LNN_LOGI(LNN_LEDGER, "no accountid login, default is 0");
return SOFTBUS_OK;
}
LNN_LOGI(LNN_LEDGER, "accountid login");
info->accountId = *((int64_t *)buf);
if (g_memAccount != 0 && g_memAccount != *((int64_t *)buf)) {
LNN_LOGI(LNN_LEDGER, "accountid change");
info->stateVersion++;
if (info->stateVersion > MAX_STATE_VERSION) {
info->stateVersion = 1;
}
}
if (LnnSaveLocalDeviceInfo(info) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "update all info to local store fail");
}
if (LnnLedgerAllDataSyncToDB(info) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "lnn ledger all data sync to cloud fail");
return SOFTBUS_MEM_ERR;
}
return SOFTBUS_OK;
}
if (*((int64_t *)buf) == 0) {
LNN_LOGI(LNN_LEDGER, "accountid logout");
if (LnnDeleteSyncToDB() != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "lnn clear local cache fail");
return SOFTBUS_MEM_ERR;
}
g_memAccount = info->accountId;
info->accountId = *((int64_t *)buf);
LnnSaveLocalDeviceInfo(info);
return SOFTBUS_OK;
}
info->accountId = *((int64_t *)buf);
return SOFTBUS_OK;
}
@ -527,6 +577,15 @@ static int32_t UpdateStateVersion(const void *buf)
*(int32_t *)buf = 1;
}
info->stateVersion = *(int32_t *)buf;
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char value[STATE_VERSION_VALUE_LENGTH] = {0};
(void)sprintf_s(value, STATE_VERSION_VALUE_LENGTH, "%d", g_localNetLedger.localInfo.stateVersion);
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_STATE_VERSION, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger state version change sync to cloud failed");
}
return SOFTBUS_OK;
}
@ -933,6 +992,14 @@ static int32_t UpdateLocalDeviceName(const void *name)
return SOFTBUS_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = g_localNetLedger.localInfo.deviceInfo.deviceName;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_DEVICE_NAME, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger device name change sync to cloud failed");
}
}
return SOFTBUS_OK;
}
@ -949,6 +1016,14 @@ static int32_t UpdateUnifiedName(const void *name)
return SOFTBUS_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = g_localNetLedger.localInfo.deviceInfo.unifiedName;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_UNIFIED_DEVICE_NAME, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger unified device name change sync to cloud failed");
}
}
return SOFTBUS_OK;
}
@ -964,6 +1039,15 @@ static int32_t UpdateUnifiedDefaultName(const void *name)
DEVICE_NAME_BUF_LEN, (char *)name) != EOK) {
return SOFTBUS_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = g_localNetLedger.localInfo.deviceInfo.unifiedDefaultName;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_UNIFIED_DEFAULT_DEVICE_NAME, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger unified default device name change sync to cloud failed");
}
}
return SOFTBUS_OK;
}
@ -980,6 +1064,14 @@ static int32_t UpdateNickName(const void *name)
return SOFTBUS_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = g_localNetLedger.localInfo.deviceInfo.nickName;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_SETTINGS_NICK_NAME, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger nick name change sync to cloud failed");
}
}
return SOFTBUS_OK;
}
@ -990,6 +1082,14 @@ static int32_t UpdateLocalNetworkId(const void *id)
return SOFTBUS_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_ERR;
}
char *value = g_localNetLedger.localInfo.networkId;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_NETWORK_ID, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger networkId change sync to cloud failed");
}
return SOFTBUS_OK;
}
@ -1094,6 +1194,17 @@ static int32_t UpdateLocalBtMac(const void *mac)
return SOFTBUS_INVALID_PARAM;
}
LnnSetBtMac(&g_localNetLedger.localInfo, (char *)mac);
if (LnnSaveLocalDeviceInfo(&g_localNetLedger.localInfo) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "update Bt mac to localdevinfo store fail");
}
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = g_localNetLedger.localInfo.connectInfo.macAddr;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_BT_MAC, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger btMac change sync to cloud failed");
}
return SOFTBUS_OK;
}
@ -1396,6 +1507,15 @@ static int32_t UpdateLocalCipherInfoKey(const void *id)
LNN_LOGE(LNN_LEDGER, "memcpy cipherInfo.key fail");
return SOFTBUS_MEM_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = (char *)g_localNetLedger.localInfo.cipherInfo.key;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_BROADCAST_CIPHER_KEY, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger cipher key change sync to cloud failed");
}
return SOFTBUS_OK;
}
@ -1409,6 +1529,15 @@ static int32_t UpdateLocalCipherInfoIv(const void *id)
LNN_LOGE(LNN_LEDGER, "memcpy cipherInfo.iv fail");
return SOFTBUS_MEM_ERR;
}
UpdateStateVersionAndStore();
if (g_localNetLedger.localInfo.accountId == 0) {
LNN_LOGI(LNN_LEDGER, "no account info. no need update to cloud");
return SOFTBUS_OK;
}
char *value = (char *)g_localNetLedger.localInfo.cipherInfo.iv;
if (LnnLedgerDataChangeSyncToDB(DEVICE_INFO_BROADCAST_CIPHER_IV, value, strlen(value)) != SOFTBUS_OK) {
LNN_LOGE(LNN_LEDGER, "ledger cipher iv change sync to cloud failed");
}
return SOFTBUS_OK;
}

9
core/common/dfx/anonymize/src/anonymizer.c
View File

@ -96,8 +96,13 @@ static bool MatchEmpty(const char *str, uint32_t len)
static bool MatchIpAddr(const char *str, uint32_t len)
{
static const uint32_t DOT_NUM_MAX = 3;
static const uint32_t NUM_LEN_MAX = 3;
static const uint32_t NUM_LEN_MIN = 1;
static const int32_t NUM_LEN_MAX = 3;
static const int32_t NUM_LEN_MIN = 1;
static const uint32_t IP_ADDR_MAX_LEN = 15;
if (len > IP_ADDR_MAX_LEN) {
return false;
}
for (uint32_t i = 0; i < len; ++i) {
if (!IsNum(str[i]) && !IsDot(str[i])) {

8
core/common/dfx/event/src/convert/trans_event_converter.h
View File

@ -57,8 +57,11 @@ TRANS_ASSIGNER(AnonymizeString, PeerUdid, peerUdid)
TRANS_ASSIGNER(String, PeerDevVer, peerDevVer)
TRANS_ASSIGNER(String, CallerPkg, callerPkg)
TRANS_ASSIGNER(String, CalleePkg, calleePkg)
TRANS_ASSIGNER(String, FirstTokenName, firstTokenName)
TRANS_ASSIGNER(Uint32, FirstTokenId, firstTokenId)
TRANS_ASSIGNER(Int32, FirstTokenType, firstTokenType)
#define TRANS_ASSIGNER_SIZE 23 // Size of TRANS_ASSIGNERS
#define TRANS_ASSIGNER_SIZE 26 // Size of TRANS_ASSIGNERS
static const HiSysEventParamAssigner TRANS_ASSIGNERS[] = {
{ "STAGE_RES", HISYSEVENT_INT32, TransAssignerResult },
{ "ERROR_CODE", HISYSEVENT_INT32, TransAssignerErrcode },
@ -83,6 +86,9 @@ static const HiSysEventParamAssigner TRANS_ASSIGNERS[] = {
{ "PEER_DEV_VER", HISYSEVENT_STRING, TransAssignerPeerDevVer },
{ "HOST_PKG", HISYSEVENT_STRING, TransAssignerCallerPkg },
{ "TO_CALL_PKG", HISYSEVENT_STRING, TransAssignerCalleePkg },
{ "FIRST_TOKEN_NAME", HISYSEVENT_STRING, TransAssignerFirstTokenName},
{ "FIRST_TOKEN_ID", HISYSEVENT_UINT32, TransAssignerFirstTokenId },
{ "FIRST_TOKEN_TYPE", HISYSEVENT_INT32, TransAssignerFirstTokenType },
// Modification Note: remember updating TRANS_ASSIGNER_SIZE
};

3
core/common/dfx/interface/include/form/trans_event_form.h
View File

@ -80,6 +80,9 @@ typedef struct {
const char *peerDevVer; // PEER_DEV_VER
const char *callerPkg; // HOST_PKG
const char *calleePkg; // TO_CALL_PKG
const char *firstTokenName; // FIRST_TOKEN_NAME
uint32_t firstTokenId; // FIRST_TOKEN_ID
int32_t firstTokenType; // FIRST_TOKEN_TYPE
} TransEventExtra;
typedef enum {

15
core/common/security/permission/include/access_control.h
View File

@ -25,10 +25,19 @@ extern "C" {
// if the upstream module does not set the first caller tokenID, the value is 0
#define TOKENID_NOT_SET 0
enum FirstTokenType {
FOREGROUND_APP_TYPE = 1,
BACKGROUND_APP_TYPE = 2,
TOKEN_HAP_TYPE = 3,
SYSTEM_SA_TYPE = 4,
TOKEN_SHELL_TYPE = 5,
};
int32_t TransCheckClientAccessControl(const char *peerNetworkId);
int32_t TransCheckServerAccessControl(uint32_t firstCallingId);
uint32_t TransACLGetFirstTokenID();
uint32_t TransACLGetCallingTokenID();
int32_t TransCheckServerAccessControl(uint32_t callingTokenId);
uint32_t TransACLGetFirstTokenID(void);
uint32_t TransACLGetCallingTokenID(void);
void TransGetTokenInfo(uint32_t callingId, char *tokenName, int32_t nameLen, int32_t *tokenType);
#ifdef __cplusplus
#if __cplusplus

4
core/common/security/permission/permission.gni
View File

@ -35,6 +35,7 @@ if (defined(ohos_lite)) {
"//foundation/communication/ipc/interfaces/innerkits/c/ipc:ipc_single",
]
}
softbus_permission_src += [ "$dsoftbus_core_path/common/security/permission/standard/access_control_virtual.c" ]
} else {
softbus_permission_inc =
[ "$dsoftbus_core_path/common/security/permission/include" ]
@ -45,6 +46,7 @@ if (defined(ohos_lite)) {
]
softbus_permission_deps = []
softbus_permission_external_deps += [
"ability_runtime:app_manager",
"cJSON:cjson",
"c_utils:utils",
]
@ -56,6 +58,6 @@ if (defined(ohos_lite)) {
]
softbus_permission_src += [ "$dsoftbus_core_path/common/security/permission/standard/access_control.cpp" ]
} else {
softbus_permission_src += [ "$dsoftbus_core_path/common/security/permission/standard/access_control_virtual.cpp" ]
softbus_permission_src += [ "$dsoftbus_core_path/common/security/permission/standard/access_control_virtual.c" ]
}
}

131
core/common/security/permission/standard/access_control.cpp
View File

@ -21,38 +21,43 @@
#include "access_control.h"
#include "access_control_profile.h"
#include "anonymizer.h"
#include "app_mgr_interface.h"
#include "app_mgr_proxy.h"
#include "bus_center_info_key.h"
#include "bus_center_manager.h"
#include "comm_log.h"
#include "distributed_device_profile_client.h"
#include "distributed_device_profile_enums.h"
#include "ipc_skeleton.h"
#include "iservice_registry.h"
#include "softbus_adapter_mem.h"
#include "softbus_def.h"
#include "softbus_errcode.h"
#include "system_ability_definition.h"
namespace {
using namespace OHOS::DistributedDeviceProfile;
using namespace OHOS::Security::AccessToken;
using namespace OHOS;
}
static int32_t TransCheckAccessControl(uint32_t firstCallingId, const char *deviceId)
static int32_t TransCheckAccessControl(uint32_t callingTokenId, const char *deviceId)
{
char *tmpName = nullptr;
Anonymize(deviceId, &tmpName);
COMM_LOGI(COMM_PERM, "firstCaller=%{public}u, deviceId=%{public}s", firstCallingId, tmpName);
COMM_LOGI(COMM_PERM, "tokenId=%{public}u, deviceId=%{public}s", callingTokenId, tmpName);
AnonymizeFree(tmpName);
std::string active = std::to_string(static_cast<int>(Status::ACTIVE));
std::vector<AccessControlProfile> profile;
std::map<std::string, std::string> parms;
std::string firstTokenIdStr = std::to_string(firstCallingId);
parms.insert({{"tokenId", firstTokenIdStr}, {"trustDeviceId", deviceId}, {"status", active}});
std::string tokenIdStr = std::to_string(callingTokenId);
parms.insert({{"tokenId", tokenIdStr}, {"trustDeviceId", deviceId}, {"status", active}});
int32_t ret = DistributedDeviceProfileClient::GetInstance().GetAccessControlProfile(parms, profile);
COMM_LOGI(COMM_PERM, "profile size=%{public}zu, ret=%{public}d", profile.size(), ret);
if (profile.empty()) {
COMM_LOGE(COMM_PERM, "check acl failed:firstCaller=%{public}u", firstCallingId);
COMM_LOGE(COMM_PERM, "check acl failed:tokenId=%{public}u", callingTokenId);
return SOFTBUS_TRANS_CHECK_ACL_FAILED;
}
for (auto &item : profile) {
@ -85,7 +90,7 @@ int32_t TransCheckClientAccessControl(const char *peerNetworkId)
if (ret != SOFTBUS_OK) {
char *tmpName = nullptr;
Anonymize(peerNetworkId, &tmpName);
COMM_LOGE(COMM_PERM, "get remote udid failed, caller=%{public}u, networkId=%{public}s, ret=%{public}d",
COMM_LOGE(COMM_PERM, "get remote udid failed, tokenId=%{public}u, networkId=%{public}s, ret=%{public}d",
callingTokenId, tmpName, ret);
AnonymizeFree(tmpName);
return ret;
@ -93,33 +98,131 @@ int32_t TransCheckClientAccessControl(const char *peerNetworkId)
return TransCheckAccessControl(callingTokenId, deviceId);
}
int32_t TransCheckServerAccessControl(uint32_t firstCallingId)
int32_t TransCheckServerAccessControl(uint32_t callingTokenId)
{
if (firstCallingId == TOKENID_NOT_SET) {
if (callingTokenId == TOKENID_NOT_SET) {
return SOFTBUS_OK;
}
auto tokenType = AccessTokenKit::GetTokenTypeFlag((AccessTokenID)firstCallingId);
auto tokenType = AccessTokenKit::GetTokenTypeFlag((AccessTokenID)callingTokenId);
if (tokenType != ATokenTypeEnum::TOKEN_HAP) {
COMM_LOGI(COMM_PERM, "tokenType=%{public}d, No need for permission verification", tokenType);
COMM_LOGI(COMM_PERM, "tokenType=%{public}d, not hap, no verification required", tokenType);
return SOFTBUS_OK;
}
char deviceId[UDID_BUF_LEN] = {0};
int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, deviceId, sizeof(deviceId));
if (ret != SOFTBUS_OK) {
COMM_LOGE(COMM_PERM, "get local udid failed, firstCaller=%{public}u, ret=%{public}d", firstCallingId, ret);
COMM_LOGE(COMM_PERM, "get local udid failed, tokenId=%{public}u, ret=%{public}d", callingTokenId, ret);
return ret;
}
return TransCheckAccessControl(firstCallingId, deviceId);
return TransCheckAccessControl(callingTokenId, deviceId);
}
uint32_t TransACLGetFirstTokenID()
uint32_t TransACLGetFirstTokenID(void)
{
return OHOS::IPCSkeleton::GetFirstTokenID();
}
uint32_t TransACLGetCallingTokenID()
uint32_t TransACLGetCallingTokenID(void)
{
return OHOS::IPCSkeleton::GetCallingTokenID();
}
static sptr<AppExecFwk::IAppMgr> g_appMgrProxy = nullptr;
namespace OHOS {
class AppMgrDeathRecipient : public IRemoteObject::DeathRecipient {
public:
AppMgrDeathRecipient() = default;
virtual ~AppMgrDeathRecipient() = default;
void OnRemoteDied(const wptr<IRemoteObject> &remote) override
{
g_appMgrProxy = nullptr;
COMM_LOGW(COMM_PERM, "app Manager died");
}
};
} // namespace OHOS
static void GetForegroundApplications(uint32_t firstTokenId, int32_t *tokenType)
{
if (g_appMgrProxy == nullptr) {
sptr<ISystemAbilityManager> abilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
if (abilityMgr == nullptr) {
COMM_LOGW(COMM_PERM, "failed to get SystemAbilityManager");
return;
}
sptr<IRemoteObject> remoteObject = abilityMgr->GetSystemAbility(APP_MGR_SERVICE_ID);
if (remoteObject == nullptr) {
COMM_LOGW(COMM_PERM, "failed to get app Manager service");
return;
}
sptr<IRemoteObject::DeathRecipient> clientDeath =
sptr<IRemoteObject::DeathRecipient>(new (std::nothrow) AppMgrDeathRecipient());
if (clientDeath == nullptr) {
COMM_LOGW(COMM_PERM, "failed to new DeathRecipient");
return;
}
remoteObject->AddDeathRecipient(clientDeath);
g_appMgrProxy = iface_cast<AppExecFwk::IAppMgr>(remoteObject);
if (g_appMgrProxy == nullptr || !g_appMgrProxy->AsObject()) {
COMM_LOGW(COMM_PERM, "failed to get app mgr proxy");
return;
}
COMM_LOGI(COMM_PERM, "get app mgr proxy success");
}
std::vector<AppExecFwk::AppStateData> appList;
int32_t ret = g_appMgrProxy->GetForegroundApplications(appList);
if (ret != ERR_OK) {
COMM_LOGW(COMM_PERM, "GetForegroundApplications return err:%{public}d", ret);
return;
}
for (auto &item : appList) {
COMM_LOGI(COMM_PERM, "appList %{public}s state:%{public}d token:%{public}u",
item.bundleName.c_str(), item.state, item.accessTokenId);
if (firstTokenId == item.accessTokenId) {
*tokenType = FOREGROUND_APP_TYPE;
return;
}
}
*tokenType = BACKGROUND_APP_TYPE;
}
void TransGetTokenInfo(uint32_t callingId, char *tokenName, int32_t nameLen, int32_t *tokenType)
{
if (callingId == TOKENID_NOT_SET || tokenName == nullptr || tokenType == nullptr) {
COMM_LOGE(COMM_PERM, "param is invalid");
return;
}
auto typeFlag = AccessTokenKit::GetTokenTypeFlag((AccessTokenID)callingId);
if (typeFlag == ATokenTypeEnum::TOKEN_NATIVE) {
*tokenType = SYSTEM_SA_TYPE;
NativeTokenInfo tokenInfo;
int32_t ret = AccessTokenKit::GetNativeTokenInfo(callingId, tokenInfo);
if (ret != ERR_OK) {
COMM_LOGW(COMM_PERM, "GetNativeTokenInfo return err:%{public}d", ret);
return;
}
if (strncpy_s(tokenName, nameLen, tokenInfo.processName.c_str(), nameLen - 1) != EOK) {
COMM_LOGW(COMM_PERM, "strncpy_s processName failed");
}
} else if (typeFlag == ATokenTypeEnum::TOKEN_HAP) {
*tokenType = TOKEN_HAP_TYPE;
GetForegroundApplications(callingId, tokenType);
HapTokenInfo hapTokenInfo;
int32_t ret = AccessTokenKit::GetHapTokenInfo(callingId, hapTokenInfo);
if (ret != ERR_OK) {
COMM_LOGW(COMM_PERM, "GetHapTokenInfo return err:%{public}d", ret);
return;
}
if (strncpy_s(tokenName, nameLen, hapTokenInfo.bundleName.c_str(), nameLen - 1) != EOK) {
COMM_LOGW(COMM_PERM, "strncpy_s bundleName failed");
}
} else {
*tokenType = TOKEN_SHELL_TYPE;
}
}

22
core/common/security/permission/standard/access_control_virtual.cpp → core/common/security/permission/standard/access_control_virtual.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Copyright (c) 2023-2024 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
@ -12,7 +12,9 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <cstdint>
#include "stdint.h"
#include "access_control.h"
#include "softbus_error_code.h"
@ -26,12 +28,20 @@ int32_t TransCheckServerAccessControl(uint32_t firstCallingId)
(void)firstCallingId;
return SOFTBUS_OK;
}
uint32_t TransACLGetFirstTokenID()
uint32_t TransACLGetFirstTokenID(void)
{
return SOFTBUS_OK;
return TOKENID_NOT_SET;
}
uint32_t TransACLGetCallingTokenID()
uint32_t TransACLGetCallingTokenID(void)
{
return SOFTBUS_OK;
return TOKENID_NOT_SET;
}
void TransGetTokenInfo(uint32_t callingId, char *tokenName, int32_t nameLen, int32_t *tokenType)
{
(void)callingId;
(void)tokenName;
(void)nameLen;
(void)tokenType;
}

1
core/discovery/ble/softbus_ble/include/disc_ble_utils.h
View File

@ -29,6 +29,7 @@ extern "C" {
#define ADV_DATA_MAX_LEN 24
#define RESP_DATA_MAX_LEN 26
#define REAL_RESP_DATA_MAX_LEN 27
#define BROADCAST_MAX_LEN (ADV_DATA_MAX_LEN + RESP_DATA_MAX_LEN)
typedef struct {

2
core/discovery/ble/softbus_ble/src/disc_ble_utils.c
View File

@ -453,7 +453,7 @@ int32_t GetDeviceInfoFromDisAdvData(DeviceWrapper *device, const uint8_t *data,
reportInfo->packet.bcData.payload != NULL, SOFTBUS_INVALID_PARAM, DISC_BLE, "payload=NULL is invalid");
uint16_t bcLen = reportInfo->packet.bcData.payloadLen;
uint16_t rspLen = reportInfo->packet.rspData.payloadLen;
if (bcLen > ADV_DATA_MAX_LEN || bcLen < POS_TLV || rspLen > RESP_DATA_MAX_LEN) {
if (bcLen > ADV_DATA_MAX_LEN || bcLen < POS_TLV || rspLen > REAL_RESP_DATA_MAX_LEN) {
DISC_LOGE(DISC_BLE, "get discovery adv data fail");
return SOFTBUS_INVALID_PARAM;
}

1
core/frame/BUILD.gn
View File

@ -251,6 +251,7 @@ if (defined(ohos_lite)) {
"device_auth:deviceauth_sdk",
"hilog:libhilog",
"ipc:ipc_core",
"kv_store:distributeddata_inner",
"safwk:system_ability_fwk",
"samgr:samgr_proxy",
]

4
core/frame/small/init/src/trans_server_stub.c
View File

@ -246,8 +246,8 @@ int32_t ServerNotifyAuthSuccess(IpcIo *req, IpcIo *reply)
if (TransAuthGetNameByChanId(channelId, pkgName, sessionName,
PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX) != SOFTBUS_OK) {
TRANS_LOGE(TRANS_CTRL, "get session name fail");
WriteInt32(reply, SOFTBUS_TRANS_UDP_CLOSE_CHANNELID_INVALID);
return SOFTBUS_TRANS_UDP_CLOSE_CHANNELID_INVALID;
WriteInt32(reply, SOFTBUS_TRANS_UDP_INVALID_ID);
return SOFTBUS_TRANS_UDP_INVALID_ID;
}
if (CheckTransPermission(callingUid, callingPid, pkgName, sessionName, ACTION_OPEN) != SOFTBUS_OK) {
TRANS_LOGE(TRANS_CTRL, "ServerCloseChannel no permission");

4
core/frame/standard/init/src/softbus_server.cfg
View File

@ -2,7 +2,9 @@
"jobs" : [{
"name" : "post-fs-data",
"cmds" : [
"mkdir /data/service/el1/public/dsoftbus 0771 dsoftbus dsoftbus"
"mkdir /data/service/el1/public/dsoftbus 0771 dsoftbus dsoftbus",
"mkdir /data/service/el1/public/database 0771 ddms ddms",
"mkdir /data/service/el1/public/database/dsoftbus 02770 dsoftbus ddms"
]
}
],

7
core/frame/standard/init/src/softbus_server_musl.cfg
View File

@ -2,7 +2,9 @@
"jobs" : [{
"name" : "post-fs-data",
"cmds" : [
"mkdir /data/service/el1/public/dsoftbus 0771 dsoftbus dsoftbus"
"mkdir /data/service/el1/public/dsoftbus 0771 dsoftbus dsoftbus",
"mkdir /data/service/el1/public/database 0771 ddms ddms",
"mkdir /data/service/el1/public/database/dsoftbus 02770 dsoftbus ddms"
]
}
],
@ -42,7 +44,8 @@
"ohos.permission.GET_WIFI_PEERS_MAC",
"ohos.permission.MANAGE_WIFI_CONNECTION",
"ohos.permission.ACCESS_IDS",
"ohos.permission.sec.ACCESS_UDID"
"ohos.permission.sec.ACCESS_UDID",
"ohos.permission.GET_RUNNING_INFO"
],
"permission_acls" : [
"ohos.permission.GET_SENSITIVE_PERMISSIONS",

4
core/transmission/common/include/softbus_app_info.h
View File

@ -36,6 +36,7 @@ extern "C" {
#define MAX_FAST_DATA_LEN (4 * 1024)
#define BASE64_FAST_DATA_LEN 5558
#define TOKENID_NOT_SET 0
typedef enum {
API_UNKNOWN = 0,
@ -123,8 +124,9 @@ typedef struct {
int64_t connectedStart;
const uint8_t *fastTransData;
uint16_t fastTransDataSize;
uint32_t firstTokenId;
uint32_t callingTokenId; // for transmission access control
bool isClient;
char tokenName[PKG_NAME_SIZE_MAX];
} AppInfo;
#ifdef __cplusplus

2
core/transmission/common/include/softbus_message_open_channel.h
View File

@ -42,7 +42,7 @@
#define PEER_HANDLE_ID "PEER_HANDLE_ID"
#define FIRST_DATA "FIRST_DATA"
#define FIRST_DATA_SIZE "FIRST_DATA_SIZE"
#define JSON_KEY_FIRST_TOKEN_ID "FIRST_TOKEN_ID"
#define JSON_KEY_CALLING_TOKEN_ID "CALLING_TOKEN_ID"
#ifdef __cplusplus
extern "C" {

6
core/transmission/common/src/softbus_message_open_channel.c
View File

@ -122,7 +122,7 @@ static int32_t JsonObjectPackRequestEx(const AppInfo *appInfo, cJSON *json, unsi
(void)AddNumberToJsonObject(json, TRANS_FLAGS, TRANS_FLAG_HAS_CHANNEL_AUTH);
(void)AddNumberToJsonObject(json, MY_HANDLE_ID, appInfo->myHandleId);
(void)AddNumberToJsonObject(json, PEER_HANDLE_ID, appInfo->peerHandleId);
(void)AddNumberToJsonObject(json, JSON_KEY_FIRST_TOKEN_ID, (int32_t)appInfo->firstTokenId);
(void)AddNumberToJsonObject(json, JSON_KEY_CALLING_TOKEN_ID, (int32_t)appInfo->callingTokenId);
return SOFTBUS_OK;
}
@ -286,8 +286,8 @@ int32_t UnpackRequest(const cJSON *msg, AppInfo *appInfo)
int32_t transFlag = TRANS_FLAG_HAS_CHANNEL_AUTH;
(void)GetJsonObjectNumberItem(msg, AUTO_CLOSE_TIME, (int32_t *)&appInfo->autoCloseTime);
(void)GetJsonObjectNumberItem(msg, TRANS_FLAGS, &transFlag);
if (!GetJsonObjectNumberItem(msg, JSON_KEY_FIRST_TOKEN_ID, (int32_t *)&appInfo->firstTokenId)) {
appInfo->firstTokenId = 0;
if (!GetJsonObjectNumberItem(msg, JSON_KEY_CALLING_TOKEN_ID, (int32_t *)&appInfo->callingTokenId)) {
appInfo->callingTokenId = TOKENID_NOT_SET;
}
return SOFTBUS_OK;
}

2
core/transmission/interface/softbus_transmission_interface.h
View File

@ -80,7 +80,6 @@ int TransOpenNetWorkingChannel(
* @see {@link TransOpenNetWorkingChannel}
* @param[in] channelId indicates the opened ChannelId.
* @return <b>SOFTBUS_MALLOC_ERR</b> Failed to allocate space for global variable of information.
* @return <b>SOFTBUS_TRANS_PROXY_DEL_CHANNELID_INVALID</b> Failed to delete channel info.
* @return <b>SOFTBUS_OK</b> Success to close this proxy channel, returns other internal error codes otherwise.
*/
int TransCloseNetWorkingChannel(int32_t channelId);
@ -94,7 +93,6 @@ int TransCloseNetWorkingChannel(int32_t channelId);
* @param[in] dataLen indicates the message data of len.
* @param[in] priority indicates the message send priority.
* @return <b>SOFTBUS_MALLOC_ERR</b> Failed to allocate space for global variable of information.
* @return <b>SOFTBUS_TRANS_PROXY_SEND_CHANNELID_INVALID</b> Failed to get channel info.
* @return <b>SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID</b> the channel status is abnormal.
* @return <b>SOFTBUS_TRANS_PROXY_PACKMSG_ERR</b> Failed to packaged the message data.
* @return <b>SOFTBUS_OK</b> Success to send message to the channel, returns other internal error codes otherwise.

2
core/transmission/trans_channel/auth/src/trans_auth_manager.c
View File

@ -169,7 +169,7 @@ static int32_t NotifyOpenAuthChannelFailed(const char *pkgName, int32_t pid, int
static int32_t NofifyCloseAuthChannel(const char *pkgName, int32_t pid, int32_t channelId)
{
return g_cb->OnChannelClosed(pkgName, pid, channelId, MESSAGE_TYPE_NOMAL, CHANNEL_TYPE_AUTH);
return g_cb->OnChannelClosed(pkgName, pid, channelId, CHANNEL_TYPE_AUTH, MESSAGE_TYPE_NOMAL);
}
static int32_t AuthGetUidAndPidBySessionName(const char *sessionName, int32_t *uid, int32_t *pid)

2
core/transmission/trans_channel/common/include/trans_lane_pending_ctl.h
View File

@ -34,7 +34,7 @@ void TransAsyncReqLanePendingDeinit(void);
int32_t TransGetConnectOptByConnInfo(const LaneConnInfo *info, ConnectOption *connOpt);
int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint32_t *laneHandle);
int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, uint32_t firstTokenId);
int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, uint32_t callingTokenId);
int32_t TransGetLaneInfoByOption(const LaneRequestOption *requestOption, LaneConnInfo *connInfo, uint32_t *laneHandle);
int32_t TransGetLaneInfoByQos(const LaneAllocInfo *allocInfo, LaneConnInfo *connInfo, uint32_t *laneHandle);
bool TransGetAuthTypeByNetWorkId(const char *peerNetWorkId);

2
core/transmission/trans_channel/common/src/trans_channel_common.c
View File

@ -270,7 +270,7 @@ AppInfo *TransCommonGetAppInfo(const SessionParam *param)
appInfo->myHandleId = -1;
appInfo->peerHandleId = -1;
appInfo->timeStart = GetSoftbusRecordTimeMillis();
appInfo->firstTokenId = TransACLGetCallingTokenID();
appInfo->callingTokenId = TransACLGetCallingTokenID();
appInfo->isClient = true;
TRANS_LOGD(TRANS_CTRL, "GetAppInfo ok");

55
core/transmission/trans_channel/common/src/trans_lane_pending_ctl.c
View File

@ -17,6 +17,7 @@
#include <securec.h>
#include "access_control.h"
#include "auth_interface.h"
#include "bus_center_manager.h"
#include "common_list.h"
@ -56,7 +57,8 @@ typedef struct {
bool isFinished;
LaneConnInfo connInfo;
SessionParam param;
uint32_t firstTokenId;
uint32_t callingTokenId; // used for transmission access control
uint32_t firstTokenId; // used for dfx connection success rate
} TransReqLaneItem;
static SoftBusList *g_reqLanePendingList = NULL;
@ -323,7 +325,7 @@ static int32_t CopyAsyncReqItemSessionParam(const SessionParam *source, SessionP
}
static int32_t TransAddAsyncLaneReqFromPendingList(uint32_t laneHandle, const SessionParam *param,
uint32_t firstTokenId)
uint32_t callingTokenId)
{
if (g_asyncReqLanePendingList == NULL) {
TRANS_LOGE(TRANS_SVC, "lane pending list no init.");
@ -339,7 +341,8 @@ static int32_t TransAddAsyncLaneReqFromPendingList(uint32_t laneHandle, const Se
item->laneHandle = laneHandle;
item->bSucc = false;
item->isFinished = false;
item->firstTokenId = firstTokenId;
item->callingTokenId = callingTokenId;
item->firstTokenId = TransACLGetFirstTokenID();
if (CopyAsyncReqItemSessionParam(param, &(item->param)) != SOFTBUS_OK) {
DestroyAsyncReqItemParam(&(item->param));
SoftBusFree(item);
@ -393,7 +396,8 @@ static int32_t TransGetLaneReqItemByLaneHandle(uint32_t laneHandle, bool *bSucc,
return SOFTBUS_ERR;
}
static int32_t TransGetLaneReqItemParamByLaneHandle(uint32_t laneHandle, SessionParam *param, uint32_t *firstTokenId)
static int32_t TransGetLaneReqItemParamByLaneHandle(
uint32_t laneHandle, SessionParam *param, uint32_t *callingTokenId, uint32_t *firstTokenId)
{
if (param == NULL) {
TRANS_LOGE(TRANS_SVC, "param err.");
@ -411,7 +415,10 @@ static int32_t TransGetLaneReqItemParamByLaneHandle(uint32_t laneHandle, Session
TransReqLaneItem *item = NULL;
LIST_FOR_EACH_ENTRY(item, &(g_asyncReqLanePendingList->list), TransReqLaneItem, node) {
if (item->laneHandle == laneHandle) {
*firstTokenId = item->firstTokenId;
*callingTokenId = item->callingTokenId;
if (firstTokenId != NULL) {
*firstTokenId = item->firstTokenId;
}
if (memcpy_s(param, sizeof(SessionParam), &(item->param), sizeof(SessionParam)) != EOK) {
(void)SoftBusMutexUnlock(&(g_asyncReqLanePendingList->lock));
TRANS_LOGE(TRANS_SVC, "copy session param failed.");
@ -533,6 +540,16 @@ EXIT_ERR:
return;
}
static void TransAsyncSetFirstTokenInfo(uint32_t firstTokenId, AppInfo *appInfo, TransEventExtra *event)
{
event->firstTokenId = firstTokenId;
if (event->firstTokenId == TOKENID_NOT_SET) {
event->firstTokenId = appInfo->callingTokenId;
}
TransGetTokenInfo(event->firstTokenId, appInfo->tokenName, sizeof(appInfo->tokenName), &event->firstTokenType);
event->firstTokenName = appInfo->tokenName;
}
static void TransOnAsyncLaneSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo)
{
TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u, laneId=%{public}" PRIu64 "",
@ -543,8 +560,9 @@ static void TransOnAsyncLaneSuccess(uint32_t laneHandle, const LaneConnInfo *con
return;
}
SessionParam param;
uint32_t firstTokenId = 0;
int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, &param, &firstTokenId);
uint32_t callingTokenId = TOKENID_NOT_SET;
uint32_t firstTokenId = TOKENID_NOT_SET;
int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, &param, &callingTokenId, &firstTokenId);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
(void)TransDelLaneReqFromPendingList(laneHandle, true);
@ -571,11 +589,12 @@ static void TransOnAsyncLaneSuccess(uint32_t laneHandle, const LaneConnInfo *con
TransSetSocketChannelStateBySession(param.sessionName, param.sessionId, CORE_SESSION_STATE_LAN_COMPLETE);
AppInfo *appInfo = TransCommonGetAppInfo(&param);
TRANS_CHECK_AND_RETURN_LOGW(!(appInfo == NULL), TRANS_SVC, "GetAppInfo is null.");
appInfo->firstTokenId = firstTokenId;
appInfo->callingTokenId = callingTokenId;
NodeInfo nodeInfo;
(void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
int32_t peerRet = LnnGetRemoteNodeInfoById(appInfo->peerNetWorkId, CATEGORY_NETWORK_ID, &nodeInfo);
TransBuildTransOpenChannelStartEvent(&extra, appInfo, &nodeInfo, peerRet);
TransAsyncSetFirstTokenInfo(firstTokenId, appInfo, &extra);
TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra);
TransAsyncOpenChannelProc(laneHandle, &param, appInfo, &extra, &tmpConnInfo);
TransFreeAppInfo(appInfo);
@ -586,8 +605,8 @@ static void TransOnAsyncLaneFail(uint32_t laneHandle, int32_t reason)
{
TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason);
SessionParam param;
uint32_t firstTokenId = 0;
int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, &param, &firstTokenId);
uint32_t callingTokenId = TOKENID_NOT_SET;
int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, &param, &callingTokenId, NULL);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret);
(void)TransDelLaneReqFromPendingList(laneHandle, true);
@ -600,7 +619,7 @@ static void TransOnAsyncLaneFail(uint32_t laneHandle, int32_t reason)
TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra);
AppInfo *appInfo = TransCommonGetAppInfo(&param);
TRANS_CHECK_AND_RETURN_LOGW(!(appInfo == NULL), TRANS_SVC, "GetAppInfo is null.");
appInfo->firstTokenId = firstTokenId;
appInfo->callingTokenId = callingTokenId;
CallBackOpenChannelFailed(&param, appInfo, reason);
if (!param.isQosLane) {
TransFreeLane(laneHandle, param.isQosLane);
@ -1094,7 +1113,7 @@ int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint
}
int32_t TransAsyncGetLaneInfoByOption(const SessionParam *param, const LaneRequestOption *requestOption,
uint32_t *laneHandle, uint32_t firstTokenId)
uint32_t *laneHandle, uint32_t callingTokenId)
{
if (param == NULL || requestOption == NULL || laneHandle == NULL) {
TRANS_LOGE(TRANS_SVC, "async get lane info param error.");
@ -1107,7 +1126,7 @@ int32_t TransAsyncGetLaneInfoByOption(const SessionParam *param, const LaneReque
*laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS);
TransUpdateSocketChannelLaneInfoBySession(
param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync);
int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, firstTokenId);
int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, callingTokenId);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(
TRANS_SVC, "add laneHandle=%{public}u to async pending list failed, ret=%{public}d", *laneHandle, ret);
@ -1134,7 +1153,7 @@ int32_t TransAsyncGetLaneInfoByOption(const SessionParam *param, const LaneReque
}
int32_t TransAsyncGetLaneInfoByQos(const SessionParam *param, const LaneAllocInfo *allocInfo,
uint32_t *laneHandle, uint32_t firstTokenId)
uint32_t *laneHandle, uint32_t callingTokenId)
{
if (param == NULL || allocInfo == NULL || laneHandle == NULL) {
TRANS_LOGE(TRANS_SVC, "async get lane info param error.");
@ -1147,7 +1166,7 @@ int32_t TransAsyncGetLaneInfoByQos(const SessionParam *param, const LaneAllocInf
*laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS);
TransUpdateSocketChannelLaneInfoBySession(
param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync);
int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, firstTokenId);
int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, callingTokenId);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(
TRANS_SVC, "add laneHandle=%{public}u to async pending list failed, ret=%{public}d", *laneHandle, ret);
@ -1176,7 +1195,7 @@ int32_t TransAsyncGetLaneInfoByQos(const SessionParam *param, const LaneAllocInf
return SOFTBUS_OK;
}
int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, uint32_t firstTokenId)
int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, uint32_t callingTokenId)
{
if (param == NULL || laneHandle == NULL) {
TRANS_LOGE(TRANS_SVC, "async get lane info param error.");
@ -1191,7 +1210,7 @@ int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, u
TRANS_LOGE(TRANS_SVC, "get request option failed. laneHandle=%{public}u, ret=%{public}d", *laneHandle, ret);
return ret;
}
ret = TransAsyncGetLaneInfoByOption(param, &requestOption, laneHandle, firstTokenId);
ret = TransAsyncGetLaneInfoByOption(param, &requestOption, laneHandle, callingTokenId);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(TRANS_SVC, "get lane info by option failed, ret=%{public}d", ret);
return ret;
@ -1204,7 +1223,7 @@ int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, u
TRANS_LOGE(TRANS_SVC, "get alloc Info failed. laneHandle=%{public}u, ret=%{public}d", *laneHandle, ret);
return ret;
}
ret = TransAsyncGetLaneInfoByQos(param, &allocInfo, laneHandle, firstTokenId);
ret = TransAsyncGetLaneInfoByQos(param, &allocInfo, laneHandle, callingTokenId);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(TRANS_SVC, "get lane info by allocInfo failed, ret=%{public}d", ret);
*laneHandle = INVALID_LANE_REQ_ID; // qos lane failed no need free lane again

15
core/transmission/trans_channel/manager/src/trans_channel_manager.c
View File

@ -206,6 +206,16 @@ void TransChannelDeinit(void)
SoftBusMutexDestroy(&g_myIdLock);
}
static void TransSetFirstTokenInfo(AppInfo *appInfo, TransEventExtra *event)
{
event->firstTokenId = TransACLGetFirstTokenID();
if (event->firstTokenId == TOKENID_NOT_SET) {
event->firstTokenId = appInfo->callingTokenId;
}
TransGetTokenInfo(event->firstTokenId, appInfo->tokenName, sizeof(appInfo->tokenName), &event->firstTokenType);
event->firstTokenName = appInfo->tokenName;
}
int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo)
{
if (param == NULL || transInfo == NULL) {
@ -221,8 +231,8 @@ int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo)
param->sessionName, param->sessionId, INVALID_CHANNEL_ID, CHANNEL_TYPE_UNDEFINED, CORE_SESSION_STATE_INIT);
TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Add socket channel record failed.");
if (param->isAsync) {
uint32_t firstTokenId = TransACLGetCallingTokenID();
ret = TransAsyncGetLaneInfo(param, &laneHandle, firstTokenId);
uint32_t callingTokenId = TransACLGetCallingTokenID();
ret = TransAsyncGetLaneInfo(param, &laneHandle, callingTokenId);
if (ret != SOFTBUS_OK) {
Anonymize(param->sessionName, &tmpName);
TRANS_LOGE(TRANS_CTRL, "Async get Lane failed, sessionName=%{public}s, sessionId=%{public}d",
@ -248,6 +258,7 @@ int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo)
int32_t peerRet = LnnGetRemoteNodeInfoById(appInfo->peerNetWorkId, CATEGORY_NETWORK_ID, &nodeInfo);
TransEventExtra extra;
TransBuildTransOpenChannelStartEvent(&extra, appInfo, &nodeInfo, peerRet);
TransSetFirstTokenInfo(appInfo, &extra);
TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra);
ret = TransGetLaneInfo(param, &connInfo, &laneHandle);
if (ret != SOFTBUS_OK) {

2
core/transmission/trans_channel/proxy/include/softbus_proxychannel_message.h
View File

@ -63,7 +63,7 @@ typedef enum {
#define JSON_KEY_ROUTE_TYPE "ROUTE_TYPE"
#define JSON_KEY_FIRST_DATA "FIRST_DATA"
#define JSON_KEY_FIRST_DATA_SIZE "FIRST_DATA_SIZE"
#define JSON_KEY_FIRST_TOKEN_ID "FIRST_TOKEN_ID"
#define JSON_KEY_CALLING_TOKEN_ID "CALLING_TOKEN_ID"
typedef struct {
uint8_t type; // MsgType

2
core/transmission/trans_channel/proxy/src/softbus_proxychannel_callback.c
View File

@ -37,7 +37,7 @@ int32_t TransProxyOnChannelOpened(const char *pkgName, int32_t pid, const char *
int32_t TransProxyOnChannelClosed(const char *pkgName, int32_t pid, int32_t channelId)
{
return g_channelCb.OnChannelClosed(pkgName, pid, channelId, MESSAGE_TYPE_NOMAL, CHANNEL_TYPE_PROXY);
return g_channelCb.OnChannelClosed(pkgName, pid, channelId, CHANNEL_TYPE_PROXY, MESSAGE_TYPE_NOMAL);
}
int32_t TransProxyOnChannelOpenFailed(const char *pkgName, int32_t pid, int32_t channelId,

2
core/transmission/trans_channel/proxy/src/softbus_proxychannel_listener.c
View File

@ -376,7 +376,7 @@ int32_t TransSendNetworkingMessage(int32_t channelId, const char *data, uint32_t
if (TransProxyGetSendMsgChanInfo(channelId, info) != SOFTBUS_OK) {
TRANS_LOGE(TRANS_MSG, "get proxy channelId failed. channelId=%{public}d", channelId);
SoftBusFree(info);
return SOFTBUS_TRANS_PROXY_SEND_CHANNELID_INVALID;
return SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID;
}
if (info->status != PROXY_CHANNEL_STATUS_COMPLETED && info->status != PROXY_CHANNEL_STATUS_KEEPLIVEING) {

19
core/transmission/trans_channel/proxy/src/softbus_proxychannel_manager.c
View File

@ -1028,8 +1028,8 @@ static int32_t TransProxyFillChannelInfo(const ProxyMessage *msg, ProxyChannelIn
int16_t newChanId = (int16_t)(GenerateChannelId(false));
ConstructProxyChannelInfo(chan, msg, newChanId, &info);
if (chan->appInfo.appType == APP_TYPE_NORMAL && chan->appInfo.firstTokenId != TOKENID_NOT_SET &&
TransCheckServerAccessControl(chan->appInfo.firstTokenId) != SOFTBUS_OK) {
if (chan->appInfo.appType == APP_TYPE_NORMAL && chan->appInfo.callingTokenId != TOKENID_NOT_SET &&
TransCheckServerAccessControl(chan->appInfo.callingTokenId) != SOFTBUS_OK) {
return SOFTBUS_TRANS_CHECK_ACL_FAILED;
}
@ -1457,7 +1457,7 @@ int32_t TransProxyCloseProxyChannel(int32_t channelId)
if (TransProxyDelByChannelId(channelId, info) != SOFTBUS_OK) {
TRANS_LOGE(TRANS_CTRL, "proxy del failed. channelId=%{public}d", channelId);
SoftBusFree(info);
return SOFTBUS_TRANS_PROXY_DEL_CHANNELID_INVALID;
return SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID;
}
TransProxyCloseProxyOtherRes(channelId, info);
@ -1497,13 +1497,16 @@ void TransProxyTimerProc(void)
ProxyChannelInfo *nextNode = NULL;
ListNode proxyProcList;
int32_t ret = SoftBusMutexLock(&g_proxyChannelList->lock);
if (ret != SOFTBUS_OK) {
TRANS_LOGE(TRANS_INIT,"lock mutex fail");
if (g_proxyChannelList == NULL) {
TRANS_LOGE(TRANS_INIT, "g_proxyChannelList is null or empty");
return;
}
if (g_proxyChannelList == NULL || g_proxyChannelList->cnt <= 0) {
TRANS_LOGW(TRANS_INIT,"g_proxyChannelList is null or empty");
if (SoftBusMutexLock(&g_proxyChannelList->lock) != SOFTBUS_OK) {
TRANS_LOGE(TRANS_INIT, "lock mutex fail");
return;
}
if (g_proxyChannelList->cnt <= 0) {
TRANS_LOGW(TRANS_INIT, "g_proxyChannelList count invalid");
(void)SoftBusMutexUnlock(&g_proxyChannelList->lock);
return;
}

6
core/transmission/trans_channel/proxy/src/softbus_proxychannel_message.c
View File

@ -447,7 +447,7 @@ static int32_t PackHandshakeMsgForNormal(SessionKeyBase64 *sessionBase64, AppInf
(void)AddNumberToJsonObject(root, JSON_KEY_TRANS_FLAGS, TRANS_FLAG_HAS_CHANNEL_AUTH);
(void)AddNumberToJsonObject(root, JSON_KEY_MY_HANDLE_ID, appInfo->myHandleId);
(void)AddNumberToJsonObject(root, JSON_KEY_PEER_HANDLE_ID, appInfo->peerHandleId);
(void)AddNumberToJsonObject(root, JSON_KEY_FIRST_TOKEN_ID, (int32_t)appInfo->firstTokenId);
(void)AddNumberToJsonObject(root, JSON_KEY_CALLING_TOKEN_ID, (int32_t)appInfo->callingTokenId);
return SOFTBUS_OK;
}
@ -758,8 +758,8 @@ static int32_t TransProxyUnpackNormalHandshakeMsg(cJSON *root, AppInfo *appInfo,
TRANS_LOGE(TRANS_CTRL, "unpack fast data failed");
return SOFTBUS_TRANS_PROXY_UNPACK_FAST_DATA_FAILED;
}
if (!GetJsonObjectNumberItem(root, JSON_KEY_FIRST_TOKEN_ID, (int32_t *)&appInfo->firstTokenId)) {
appInfo->firstTokenId = 0;
if (!GetJsonObjectNumberItem(root, JSON_KEY_CALLING_TOKEN_ID, (int32_t *)&appInfo->callingTokenId)) {
appInfo->callingTokenId = TOKENID_NOT_SET;
}
return SOFTBUS_OK;
}

2
core/transmission/trans_channel/tcp_direct/src/trans_tcp_direct_callback.c
View File

@ -39,7 +39,7 @@ int32_t TransTdcOnChannelOpened(const char *pkgName, int32_t pid, const char *se
int32_t TransTdcOnChannelClosed(const char *pkgName, int32_t pid, int32_t channelId)
{
return g_channelCb.OnChannelClosed(pkgName, pid, channelId, MESSAGE_TYPE_NOMAL, CHANNEL_TYPE_TCP_DIRECT);
return g_channelCb.OnChannelClosed(pkgName, pid, channelId, CHANNEL_TYPE_TCP_DIRECT, MESSAGE_TYPE_NOMAL);
}
int32_t TransTdcOnChannelOpenFailed(const char *pkgName, int32_t pid, int32_t channelId,

4
core/transmission/trans_channel/tcp_direct/src/trans_tcp_direct_message.c
View File

@ -844,8 +844,8 @@ static int32_t OpenDataBusRequest(int32_t channelId, uint32_t flags, uint64_t se
char *errDesc = NULL;
int32_t errCode;
int myHandleId;
if (conn->appInfo.firstTokenId != TOKENID_NOT_SET &&
TransCheckServerAccessControl(conn->appInfo.firstTokenId) != SOFTBUS_OK) {
if (conn->appInfo.callingTokenId != TOKENID_NOT_SET &&
TransCheckServerAccessControl(conn->appInfo.callingTokenId) != SOFTBUS_OK) {
errCode = SOFTBUS_TRANS_CHECK_ACL_FAILED;
errDesc = (char *)"Server check acl failed";
goto ERR_EXIT;

3
core/transmission/trans_channel/udp_negotiation/src/trans_udp_negotiation.c
View File

@ -448,7 +448,8 @@ static int32_t ParseRequestAppInfo(AuthHandle authHandle, const cJSON *msg, AppI
TRANS_LOGE(TRANS_CTRL, "unpack request udp info failed.");
return SOFTBUS_ERR;
}
if (appInfo->firstTokenId != 0 && TransCheckServerAccessControl(appInfo->firstTokenId) != SOFTBUS_OK) {
if (appInfo->callingTokenId != TOKENID_NOT_SET &&
TransCheckServerAccessControl(appInfo->callingTokenId) != SOFTBUS_OK) {
return SOFTBUS_TRANS_CHECK_ACL_FAILED;
}
appInfo->myHandleId = -1;

6
core/transmission/trans_channel/udp_negotiation/src/trans_udp_negotiation_exchange.c
View File

@ -136,8 +136,8 @@ int32_t TransUnpackRequestUdpInfo(const cJSON *msg, AppInfo *appInfo)
case TYPE_UDP_CHANNEL_OPEN:
(void)GetJsonObjectNumber64Item(msg, "MY_CHANNEL_ID", &(appInfo->peerData.channelId));
(void)GetJsonObjectStringItem(msg, "MY_IP", appInfo->peerData.addr, sizeof(appInfo->peerData.addr));
if (!GetJsonObjectNumberItem(msg, "FIRST_TOKEN_ID", (int32_t *)&appInfo->firstTokenId)) {
appInfo->firstTokenId = 0;
if (!GetJsonObjectNumberItem(msg, "CALLING_TOKEN_ID", (int32_t *)&appInfo->callingTokenId)) {
appInfo->callingTokenId = TOKENID_NOT_SET;
}
break;
case TYPE_UDP_CHANNEL_CLOSE:
@ -162,7 +162,7 @@ int32_t TransPackRequestUdpInfo(cJSON *msg, const AppInfo *appInfo)
case TYPE_UDP_CHANNEL_OPEN:
(void)AddNumber64ToJsonObject(msg, "MY_CHANNEL_ID", appInfo->myData.channelId);
(void)AddStringToJsonObject(msg, "MY_IP", appInfo->myData.addr);
(void)AddNumberToJsonObject(msg, "FIRST_TOKEN_ID", (int32_t)appInfo->firstTokenId);
(void)AddNumberToJsonObject(msg, "CALLING_TOKEN_ID", (int32_t)appInfo->callingTokenId);
break;
case TYPE_UDP_CHANNEL_CLOSE:
(void)AddNumber64ToJsonObject(msg, "PEER_CHANNEL_ID", appInfo->peerData.channelId);

8
dsoftbus.gni
View File

@ -29,6 +29,7 @@ declare_args() {
dsoftbus_get_devicename = true
softbus_communication_wifi_feature = true
softbus_os_account = true
dsoftbus_feature_lnn_cloud_sync = true
}
if (defined(global_parts_info) &&
@ -73,3 +74,10 @@ if (defined(ohos_lite)) {
import(
"$dsoftbus_feature_product_config_path/feature_config/standard/config.gni")
}
if (defined(global_parts_info) &&
!defined(global_parts_info.distributeddatamgr_kv_store)) {
dsoftbus_feature_lnn_cloud_sync = false
} else {
dsoftbus_feature_lnn_cloud_sync = true
}

3
hisysevent.yaml
View File

@ -212,6 +212,9 @@ TRANSPORT_BEHAVIOR:
PEER_NET_ID: { type: STRING, desc: peer device net id }
PEER_UDID: { type: STRING, desc: peer udid }
PEER_DEV_VER: { type: STRING, desc: peer device build version }
FIRST_TOKEN_NAME: { type: STRING, desc: first token name }
FIRST_TOKEN_ID: { type: UINT32, desc: first token id }
FIRST_TOKEN_TYPE: { type: INT32, desc: first token type }
TRANSPORT_AUDIT:
__BASE: {type: SECURITY, level: CRITICAL, desc: transport recurity audit }

21
interfaces/kits/common/softbus_error_code.h
View File

@ -136,7 +136,6 @@ enum SoftBusErrNo {
SOFTBUS_TRANS_INVALID_SESSION_ID,
SOFTBUS_TRANS_INVALID_SESSION_NAME,
SOFTBUS_TRANS_INVALID_CHANNEL_TYPE,
SOFTBUS_TRANS_INVALID_CLOSE_CHANNEL_ID,
SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH,
SOFTBUS_TRANS_SESSION_REPEATED,
SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT,
@ -153,16 +152,13 @@ enum SoftBusErrNo {
SOFTBUS_TRANS_PROXY_PACKMSG_ERR,
SOFTBUS_TRANS_PROXY_SENDMSG_ERR,
SOFTBUS_TRANS_PROXY_SEND_CHANNELID_INVALID,
SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID,
SOFTBUS_TRANS_PROXY_DEL_CHANNELID_INVALID,
SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR,
SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD,
SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_NO_INVALID,
SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_EXCEED_LENGTH,
SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL,
SOFTBUS_TRANS_UDP_CLOSE_CHANNELID_INVALID,
SOFTBUS_TRANS_UDP_SERVER_ADD_CHANNEL_FAILED,
SOFTBUS_TRANS_UDP_CLIENT_ADD_CHANNEL_FAILED,
SOFTBUS_TRANS_UDP_SERVER_NOTIFY_APP_OPEN_FAILED,
@ -260,6 +256,10 @@ enum SoftBusErrNo {
SOFTBUS_TRANS_STOP_BIND_BY_CANCEL,
SOFTBUS_TRANS_INVALID_MESSAGE_TYPE,
SOFTBUS_TRANS_PROXY_GET_AUTH_ID_FAILED,
SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID, // classify invalid channel id by channel type
SOFTBUS_TRANS_TDC_INVALID_CHANNEL_ID,
SOFTBUS_TRANS_UDP_INVALID_ID,
SOFTBUS_TRANS_AUTH_INVALID_CHANNEL_ID,
SOFTBUS_TRANS_MSG_GENERATE_MIC_FAIL, // generate mic fail
SOFTBUS_TRANS_MSG_INVALID_EVENT_TYPE, // invalid event type
SOFTBUS_TRANS_MSG_INVALID_CMD, // invalid cmd
@ -336,6 +336,17 @@ enum SoftBusErrNo {
SOFTBUS_NETWORK_JOIN_LNN_START_ERR,
SOFTBUS_NETWORK_LEAVE_LNN_START_ERR,
SOFTBUS_CENTER_SERVER_INIT_FAILED,
SOFTBUS_KV_DB_PTR_NULL,
SOFTBUS_KV_PUT_DB_FAIL,
SOFTBUS_KV_DB_INIT_FAIL,
SOFTBUS_KV_DEL_DB_FAIL,
SOFTBUS_KV_GET_DB_FAIL,
SOFTBUS_KV_CLOUD_DISABLED,
SOFTBUS_KV_CLOUD_SYNC_FAIL,
SOFTBUS_KV_REGISTER_SYNC_LISTENER_FAILED,
SOFTBUS_KV_UNREGISTER_SYNC_LISTENER_FAILED,
SOFTBUS_KV_REGISTER_DATA_LISTENER_FAILED,
SOFTBUS_KV_UNREGISTER_DATA_LISTENER_FAILED,
/* errno begin: -((203 << 21) | (4 << 16) | (1 << 12) | 0x0FFF) */
SOFTBUS_LANE_ERR_BASE = SOFTBUS_SUB_ERRNO(LNN_SUB_MODULE_CODE, LNN_LANE_MODULE_CODE),
@ -548,7 +559,7 @@ enum SoftBusErrNo {
SOFTBUS_BC_MGR_REG_DUP, // duplicate registration
SOFTBUS_BC_MGR_WAIT_COND_FAIL, // wait signal fail
SOFTBUS_BC_MGR_UNEXPECTED_PACKETS, // parse packets fail
/* softbus ok */
SOFTBUS_OK = 0,
};

2
sdk/libsoftbus_client_map
View File

@ -403,6 +403,8 @@
"ClientSignalSyncBind";
"DelSessionStateClosing";
"SetSessionStateBySessionId";
"ClientWaitSyncBind";
"GetQosValue";
"EvaluateQos";
"GetMtuSize";
"DBinderGrantPermission";

38
sdk/transmission/session/src/client_trans_session_manager.c
View File

@ -1310,13 +1310,6 @@ static int32_t ClientTransGetUdpIp(int32_t channelId, char *myIp, int32_t ipLen)
// determine connection type based on IP
static bool ClientTransCheckHmlIp(const char *ip)
{
char ipSeg[NETWORK_ID_LEN] = {0};
if (strncpy_s(ipSeg, sizeof(ipSeg), ip, sizeof(ipSeg) - 1) == EOK) {
TRANS_LOGI(TRANS_SDK, "ipSeg=%{public}s", ipSeg);
} else {
TRANS_LOGW(TRANS_SDK, "strncpy_s ipSeg failed");
}
if (strncmp(ip, HML_IP_PREFIX, NETWORK_ID_LEN) == 0) {
return true;
}
@ -1771,6 +1764,21 @@ static SessionInfo *GetSocketExistSession(const SessionParam *param, bool isEncy
return NULL;
}
static void ClientInitSession(SessionInfo *session, const SessionParam *param)
{
session->sessionId = INVALID_SESSION_ID;
session->channelId = INVALID_CHANNEL_ID;
session->channelType = CHANNEL_TYPE_BUTT;
session->isServer = false;
session->role = SESSION_ROLE_INIT;
session->isEnable = false;
session->info.flag = param->attr->dataType;
session->info.streamType = param->attr->attr.streamAttr.streamType;
session->isEncrypt = true;
session->isAsync = false;
session->lifecycle.sessionState = SESSION_STATE_INIT;
}
static SessionInfo *CreateNewSocketSession(const SessionParam *param)
{
SessionInfo *session = (SessionInfo *)SoftBusCalloc(sizeof(SessionInfo));
@ -1815,17 +1823,7 @@ static SessionInfo *CreateNewSocketSession(const SessionParam *param)
return NULL;
}
session->sessionId = INVALID_SESSION_ID;
session->channelId = INVALID_CHANNEL_ID;
session->channelType = CHANNEL_TYPE_BUTT;
session->isServer = false;
session->role = SESSION_ROLE_INIT;
session->isEnable = false;
session->info.flag = param->attr->dataType;
session->info.streamType = param->attr->attr.streamAttr.streamType;
session->isEncrypt = true;
session->isAsync = false;
session->lifecycle.sessionState = SESSION_STATE_INIT;
ClientInitSession(session, param);
return session;
}
@ -2660,8 +2658,8 @@ int32_t SetSessionStateBySessionId(int32_t sessionId, SessionState sessionState,
return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND;
}
TRANS_LOGI(TRANS_SDK, "socket state change:%{public}d -> %{public}d. socket=%{public}d", sessionNode->lifecycle.sessionState,
sessionState, sessionId);
TRANS_LOGI(TRANS_SDK, "socket state change:%{public}d -> %{public}d. socket=%{public}d",
sessionNode->lifecycle.sessionState, sessionState, sessionId);
sessionNode->lifecycle.sessionState = sessionState;
if (sessionState == SESSION_STATE_CANCELLING) {
TRANS_LOGW(TRANS_SDK, "set socket to cancelling, socket=%{public}d, errCode=%{public}d", sessionId, optional);

3
sdk/transmission/session/src/client_trans_session_service.c
View File

@ -1045,7 +1045,8 @@ int32_t ClientBind(int32_t socket, const QosTV qos[], uint32_t qosCount, const I
int32_t ret = ClientSetSocketState(socket, 0, SESSION_ROLE_INIT);
TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "init session role failed, ret=%{public}d", ret);
ret = SetSessionStateBySessionId(socket, SESSION_STATE_INIT, 0);
TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_SDK, "init session state failed, ret=%{public}d", ret);
TRANS_CHECK_AND_RETURN_RET_LOGE(
ret == SOFTBUS_OK, ret, TRANS_SDK, "init session state failed, ret=%{public}d", ret);
ret = ClientSetListenerBySessionId(socket, listener, false);
if (ret != SOFTBUS_OK) {

3
sdk/transmission/trans_channel/proxy/src/client_trans_proxy_file_manager.c
View File

@ -438,7 +438,7 @@ static char *GetFullRecvPath(const char *filePath, const char *recvRootDir)
}
int32_t ret;
if (isNeedAddSep) {
ret = sprintf_s(recvFullPath, destFullPathLength + 1, "%s%c%s", recvRootDir, PATH_SEPARATOR, filePath);
ret = sprintf_s(recvFullPath, destFullPathLength + 1, "%s/%s", recvRootDir, filePath);
} else {
ret = sprintf_s(recvFullPath, destFullPathLength + 1, "%s%s", recvRootDir, filePath);
}
@ -2290,6 +2290,7 @@ int32_t ProcessRecvFileFrameData(int32_t sessionId, int32_t channelId, const Fil
int32_t ProcessFileFrameData(int32_t sessionId, int32_t channelId, const char *data, uint32_t len, int32_t type)
{
FileFrame oneFrame;
(void)memset_s(&oneFrame, sizeof(FileFrame), 0, sizeof(FileFrame));
oneFrame.frameType = type;
oneFrame.frameLength = len;
oneFrame.data = (uint8_t *)data;

39
tests/core/adapter/BUILD.gn
View File

@ -17,6 +17,39 @@ import("../../../dsoftbus.gni")
module_output_path = "dsoftbus/core"
dsoftbus_root_path = "../../.."
ohos_unittest("LnnKVAdapterTest") {
module_out_path = module_output_path
sources = [ "unittest/lnn_kv_adapter_test.cpp" ]
include_dirs = [
"$dsoftbus_root_path/core/adapter/kv_store/include",
"$dsoftbus_root_path/core/adapter/bus_center/include",
"$dsoftbus_root_path/core/common/include",
]
deps = [
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/frame:softbus_server",
]
external_deps = [ "kv_store:distributeddata_inner" ]
}
ohos_unittest("LnnKVAdapterWrapperTest") {
module_out_path = module_output_path
sources = [ "unittest/lnn_kv_adapter_wrapper_test.cpp" ]
include_dirs = [
"$dsoftbus_root_path/core/adapter/kv_store/include",
"$dsoftbus_root_path/core/adapter/bus_center/include",
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/common/include",
"$dsoftbus_root_path/core/bus_center/interface",
]
deps = [
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/frame:softbus_server",
]
external_deps = [ "kv_store:distributeddata_inner" ]
}
ohos_unittest("AdapterDsoftbusRsaCryptoTest") {
module_out_path = module_output_path
sources = [ "unittest/dsoftbus_rsa_crypto_test.cpp" ]
@ -56,7 +89,11 @@ ohos_unittest("AdapterDsoftbusRsaCryptoTest") {
group("unittest") {
testonly = true
deps = [ ":AdapterDsoftbusRsaCryptoTest" ]
deps = [
":AdapterDsoftbusRsaCryptoTest",
":LnnKVAdapterTest",
":LnnKVAdapterWrapperTest",
]
}
group("fuzztest") {

277
tests/core/adapter/unittest/lnn_kv_adapter_test.cpp Normal file
View File

@ -0,0 +1,277 @@
/*
* Copyright (c) 2024 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 "lnn_kv_adapter.h"
#include "softbus_errcode.h"
#include "lnn_kv_data_change_listener.h"
#include "gtest/gtest.h"
#include <string>
using namespace std;
using namespace testing::ext;
namespace OHOS {
namespace {
const std::string APP_ID = "dsoftbus";
const std::string STORE_ID = "dsoftbus_kv_db";
shared_ptr<KVAdapter> kvStore = nullptr;
constexpr int32_t MAX_STRING_LEN = 4096;
constexpr int32_t MAX_MAP_SIZE = 10000;
const std::string DATABASE_DIR = "/data/service/el1/public/database/dsoftbus";
}
class KVAdapterTest : public testing::Test {
protected:
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp();
void TearDown();
};
void KVAdapterTest::SetUpTestCase(void)
{
kvStore = make_shared<KVAdapter>(APP_ID, STORE_ID,
make_shared<KvDataChangeListener>());
}
void KVAdapterTest::TearDownTestCase(void)
{
}
void KVAdapterTest::SetUp()
{
kvStore->Init();
}
void KVAdapterTest::TearDown()
{
kvStore->DeInit();
}
/**
* @tc.name: Init001
* @tc.desc: Init succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Init001, TestSize.Level1)
{
kvStore->DeInit();
EXPECT_EQ(SOFTBUS_OK, kvStore->Init());
}
/**
* @tc.name: UnInit001
* @tc.desc: UnInit succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, UnInit001, TestSize.Level1)
{
EXPECT_EQ(SOFTBUS_OK, kvStore->DeInit());
}
/**
* @tc.name: Put001
* @tc.desc: Put succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Put001, TestSize.Level1)
{
EXPECT_EQ(SOFTBUS_OK, kvStore->Put("key1", "value1"));
}
/**
* @tc.name: Put002
* @tc.desc: Put failed, Param is invalid.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Put002, TestSize.Level1)
{
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put("", "value1"));
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put("key1", ""));
}
/**
* @tc.name: Put003
* @tc.desc: Put failed, kvDBPtr is null.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Put003, TestSize.Level1)
{
kvStore->DeInit();
EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->Put("key1", "value1"));
}
/**
* @tc.name: Put004
* @tc.desc: Put first if.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Put004, TestSize.Level1)
{
string key = "key";
string value = "value";
EXPECT_EQ(SOFTBUS_OK, kvStore->Put(key, value));
for (int32_t i = 0; i < MAX_STRING_LEN + 5; i++) {
value += 'a';
}
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
value = "";
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
for (int32_t i = 0; i < MAX_STRING_LEN + 5; i++) {
key += 'a';
}
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
key = "";
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->Put(key, value));
}
/**
* @tc.name: PutBatch001
* @tc.desc: PutBatch succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, PutBatch001, TestSize.Level1)
{
map<string, string> values;
values.insert(pair<string, string>("key2", "value2"));
values.insert(pair<string, string>("key3", "value3"));
EXPECT_EQ(SOFTBUS_OK, kvStore->PutBatch(values));
}
/**
* @tc.name: PutBatch002
* @tc.desc: PutBatch failed, Param is invalid.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, PutBatch002, TestSize.Level1)
{
map<string, string> values;
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->PutBatch(values));
for (int32_t i = 0; i< MAX_MAP_SIZE + 5; i++) {
values[to_string(i)] = "value";
}
EXPECT_EQ(SOFTBUS_INVALID_PARAM, kvStore->PutBatch(values));
}
/**
* @tc.name: PutBatch003
* @tc.desc: PutBatch failed, kvDBPtr is null.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, PutBatch003, TestSize.Level1)
{
map<string, string> values;
values.insert(pair<string, string>("key1", "value1"));
values.insert(pair<string, string>("key2", "value2"));
kvStore->DeInit();
EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->PutBatch(values));
}
/**
* @tc.name: Delete001
* @tc.desc: Delete succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Delete001, TestSize.Level1)
{
kvStore->Put("key4", "value4");
EXPECT_EQ(SOFTBUS_OK, kvStore->Delete("key4"));
}
/**
* @tc.name: Delete002
* @tc.desc: Delete failed, kvDBPtr is null.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Delete002, TestSize.Level1)
{
kvStore->Put("key5", "value5");
kvStore->DeInit();
EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->Delete("key5"));
}
/**
* @tc.name: DeleteByPrefix001
* @tc.desc: DeleteByPrefix succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, DeleteByPrefix001, TestSize.Level1)
{
kvStore->Put("key6", "value6");
kvStore->Put("key7", "value7");
EXPECT_EQ(SOFTBUS_OK, kvStore->DeleteByPrefix("key"));
}
/**
* @tc.name: DeleteByPrefix002
* @tc.desc: DeleteByPrefix failed, kvDBPtr is null.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, DeleteByPrefix002, TestSize.Level1)
{
kvStore->Put("key8", "value8");
kvStore->Put("key9", "value9");
kvStore->DeInit();
EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->DeleteByPrefix("key"));
}
/**
* @tc.name: Get001
* @tc.desc: Get succeed.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Get001, TestSize.Level1)
{
kvStore->Put("key10", "value10");
string value;
EXPECT_EQ(SOFTBUS_OK, kvStore->Get("key10", value));
EXPECT_EQ("value10", value);
}
/**
* @tc.name: Get002
* @tc.desc: Get failed, kvDBPtr is null.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterTest, Get002, TestSize.Level1)
{
kvStore->Put("key11", "value11");
kvStore->DeInit();
string value;
EXPECT_EQ(SOFTBUS_KV_DB_PTR_NULL, kvStore->Get("key11", value));
}
}

159
tests/core/adapter/unittest/lnn_kv_adapter_wrapper_test.cpp Normal file
View File

@ -0,0 +1,159 @@
/*
* Copyright (c) 2024 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 "gtest/gtest.h"
#include "lnn_kv_adapter_wrapper.h"
#include "softbus_errcode.h"
#include <cstdint>
#include <string>
using namespace std;
using namespace testing::ext;
namespace OHOS {
namespace {
constexpr int32_t MAX_STRING_LEN = 4096;
constexpr int32_t MIN_STRING_LEN = 1;
constexpr int32_t APP_ID_LEN = 8;
constexpr int32_t STORE_ID_LEN = 14;
const std::string APP_ID = "dsoftbus";
const std::string STORE_ID = "dsoftbus_kv_db";
}
static int32_t g_dbId = 1;
class KVAdapterWrapperTest : public testing::Test {
protected:
static void SetUpTestCase(void);
static void TearDownTestCase(void);
void SetUp();
void TearDown();
};
void KVAdapterWrapperTest::SetUpTestCase(void)
{
int32_t dbID;
LnnCreateKvAdapter(&dbID, APP_ID.c_str(), APP_ID_LEN, STORE_ID.c_str(), STORE_ID_LEN);
g_dbId = dbID;
}
void KVAdapterWrapperTest::TearDownTestCase(void)
{
LnnDestroyKvAdapter(g_dbId);
}
void KVAdapterWrapperTest::SetUp()
{
}
void KVAdapterWrapperTest::TearDown()
{
}
/**
* @tc.name: LnnPutDBData
* @tc.desc: LnnPutDBData
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterWrapperTest, LnnPutDBData001, TestSize.Level1)
{
int32_t dbId = g_dbId;
string keyStr = "aaa";
string valueStr = "aaa";
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), 3, valueStr.c_str(), 3), SOFTBUS_OK);
dbId++;
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, valueStr.c_str(), MAX_STRING_LEN),
SOFTBUS_INVALID_PARAM);
dbId = 0;
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, valueStr.c_str(), MAX_STRING_LEN),
SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, valueStr.c_str(), MAX_STRING_LEN + 1),
SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, valueStr.c_str(), MIN_STRING_LEN - 1),
SOFTBUS_INVALID_PARAM);
char *valuePtr = nullptr;
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, valuePtr, MIN_STRING_LEN - 1),
SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MAX_STRING_LEN + 1, valuePtr, MIN_STRING_LEN - 1),
SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), MIN_STRING_LEN - 1, valuePtr, MIN_STRING_LEN - 1),
SOFTBUS_INVALID_PARAM);
char *keyPtr = nullptr;
EXPECT_EQ(LnnPutDBData(dbId, keyPtr, MIN_STRING_LEN - 1, valuePtr, MIN_STRING_LEN - 1), SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: LnnDeleteDBData
* @tc.desc: LnnDeleteDBData
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterWrapperTest, LnnDelete001, TestSize.Level1)
{
int32_t dbId = g_dbId;
string keyStr = "aaa";
dbId++;
EXPECT_EQ(LnnDeleteDBData(dbId, keyStr.c_str(), MAX_STRING_LEN), SOFTBUS_INVALID_PARAM);
dbId = 0;
EXPECT_EQ(LnnDeleteDBData(dbId, keyStr.c_str(), MAX_STRING_LEN), SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnDeleteDBData(dbId, keyStr.c_str(), MAX_STRING_LEN + 1), SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnDeleteDBData(dbId, keyStr.c_str(), MIN_STRING_LEN - 1), SOFTBUS_INVALID_PARAM);
char *keyPtr = nullptr;
EXPECT_EQ(LnnDeleteDBData(dbId, keyPtr, MIN_STRING_LEN - 1), SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: LnnDeleteDBDataByPrefix
* @tc.desc: LnnDeleteDBDataByPrefix
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterWrapperTest, LnnDeleteByPrefix001, TestSize.Level1)
{
int32_t dbId = g_dbId;
string keyStr = "aaa";
dbId++;
EXPECT_EQ(LnnDeleteDBDataByPrefix(dbId, keyStr.c_str(), MAX_STRING_LEN), SOFTBUS_INVALID_PARAM);
dbId = 0;
EXPECT_EQ(LnnDeleteDBDataByPrefix(dbId, keyStr.c_str(), MAX_STRING_LEN), SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnDeleteDBDataByPrefix(dbId, keyStr.c_str(), MAX_STRING_LEN + 1), SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnDeleteDBDataByPrefix(dbId, keyStr.c_str(), MIN_STRING_LEN - 1), SOFTBUS_INVALID_PARAM);
char *keyPtr = nullptr;
EXPECT_EQ(LnnDeleteDBDataByPrefix(dbId, keyPtr, MIN_STRING_LEN - 1), SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: LnnGetDBData
* @tc.desc: LnnGetDBData
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(KVAdapterWrapperTest, LnnGet001, TestSize.Level1)
{
int32_t dbId = g_dbId;
string keyStr = "aaa";
string valueStr = "aaa";
char *value = nullptr;
EXPECT_EQ(LnnPutDBData(dbId, keyStr.c_str(), 3, valueStr.c_str(), 3), SOFTBUS_OK);
EXPECT_EQ(LnnGetDBData(dbId, keyStr.c_str(), 3, &value), SOFTBUS_OK);
dbId++;
EXPECT_EQ(LnnGetDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, &value), SOFTBUS_INVALID_PARAM);
dbId = 0;
EXPECT_EQ(LnnGetDBData(dbId, keyStr.c_str(), MAX_STRING_LEN, &value), SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnGetDBData(dbId, keyStr.c_str(), MAX_STRING_LEN + 1, &value), SOFTBUS_INVALID_PARAM);
EXPECT_EQ(LnnGetDBData(dbId, keyStr.c_str(), MIN_STRING_LEN - 1, &value), SOFTBUS_INVALID_PARAM);
char *keyPtr = nullptr;
EXPECT_EQ(LnnGetDBData(dbId, keyPtr, MIN_STRING_LEN - 1, &value), SOFTBUS_INVALID_PARAM);
}
} // namespace OHOS

1
tests/core/authentication/BUILD.gn
View File

@ -775,6 +775,7 @@ ohos_unittest("AuthNormalizeRequestTest") {
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/common/include",
"$dsoftbus_root_path/core/bus_center/interface",
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/bus_center/utils/include",
]
deps = [

1
tests/core/authentication/fuzztest/unpackauthdata_fuzzer/BUILD.gn
View File

@ -34,6 +34,7 @@ ohos_fuzztest("UnpackAuthDataFuzzTest") {
"$dsoftbus_root_path/interfaces/kits/common",
"$dsoftbus_root_path/tests/sdk/common/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/bus_center/utils/include",
]
cflags = [

6
tests/core/authentication/unittest/auth_normalize_request_test.cpp
View File

@ -66,6 +66,9 @@ HWTEST_F(AuthNormalizeRequestTest, NOTIFY_NORMALIZE_REQUEST_SUCCESS_TEST_001, Te
request.authSeq = 2;
ret = AddNormalizeRequest(&request);
EXPECT_TRUE(ret != 0);
request.authSeq = 3;
ret = AddNormalizeRequest(&request);
EXPECT_TRUE(ret != 0);
NotifyNormalizeRequestSuccess(authSeq);
authSeq = 1;
NotifyNormalizeRequestSuccess(authSeq);
@ -93,6 +96,9 @@ HWTEST_F(AuthNormalizeRequestTest, NOTIFY_NORMALIZE_REQUEST_FAIL_TEST_001, TestS
request.authSeq = 2;
ret = AddNormalizeRequest(&request);
EXPECT_TRUE(ret != 0);
request.authSeq = 3;
ret = AddNormalizeRequest(&request);
EXPECT_TRUE(ret != 0);
NotifyNormalizeRequestFail(authSeq, -1);
authSeq = 1;
NotifyNormalizeRequestFail(authSeq, -1);

60
tests/core/bus_center/lnn/BUILD.gn
View File

@ -1068,6 +1068,7 @@ ohos_unittest("LNNLedgerMockTest") {
"$dsoftbus_root_path/adapter:softbus_adapter",
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/common/dfx/log:softbus_dfx_log",
"$dsoftbus_root_path/core/frame:softbus_server",
"//third_party/googletest:gmock",
"//third_party/googletest:gtest_main",
]
@ -1780,6 +1781,64 @@ if (!defined(ohos_lite) && enhanced_test) {
}
}
ohos_unittest("LNNDataCloudSyncTest") {
module_out_path = module_output_path
sources = [ "net_builder/src/lnn_data_cloud_sync_test.cpp" ]
include_dirs = [
"$dsoftbus_root_path/core/bus_center/lnn/lane_hub/lane_manager/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/distributed_ledger/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/local_ledger/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/common/include",
"$dsoftbus_root_path/core/bus_center/monitor/include",
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/core/common/dfx/interface/include",
"$dsoftbus_root_path/adapter/common/include",
"$dsoftbus_root_path/core/connection/interface",
"$dsoftbus_root_path/core/authentication/interface",
"$dsoftbus_root_path/core/bus_center/interface",
"$dsoftbus_root_path/core/bus_center/utils/include",
"$dsoftbus_root_path/interfaces/kits/bus_center",
"$dsoftbus_root_path/interfaces/kits/common",
"$dsoftbus_root_path/interfaces/kits/discovery",
"$dsoftbus_root_path/core/adapter/bus_center/include",
"//commonlibrary/c_utils/base/include",
"//third_party/cJSON",
"unittest/common/",
"$dsoftbus_root_path/core/connection/manager",
"$dsoftbus_root_path/adapter/common/bus_center/include/",
"$dsoftbus_root_path/core/discovery/manager/include",
"$dsoftbus_root_path/core/discovery/interface",
"$dsoftbus_root_path/interfaces/kits/discovery",
"$dsoftbus_root_path/core/bus_center/service/include",
"$dsoftbus_root_path/tests/core/bus_center/lnn/net_builder/include",
]
deps = [
"$dsoftbus_root_path/adapter:softbus_adapter",
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/common/dfx/log:softbus_dfx_log",
"$dsoftbus_root_path/core/frame:softbus_server",
"//third_party/googletest:gmock",
"//third_party/googletest:gtest_main",
]
if (is_standard_system) {
external_deps = [
"c_utils:utils",
"device_auth:deviceauth_sdk",
"hilog:libhilog",
]
} else {
external_deps = [
"c_utils:utils",
"hilog:libhilog",
]
}
}
group("unittest") {
testonly = true
deps = [
@ -1787,6 +1846,7 @@ group("unittest") {
":LNNBtNetworkImplMockTest",
":LNNConnectionFsmMockTest",
":LNNConnectionFsmTest",
":LNNDataCloudSyncTest",
":LNNDeviceNameInfoTest",
":LNNDiscoveryInterfaceTest",
":LNNDisctributedLedgerTest",

4
tests/core/bus_center/lnn/lane/include/lnn_lane_deps_mock.h
View File

@ -149,10 +149,6 @@ public:
const AuthConnCallback *callback, bool isMeta);
static int32_t ActionOfConnOpened(const AuthConnInfo *info, uint32_t requestId, const AuthConnCallback *callback,
bool isMeta);
static int32_t ActionOfAllocConnOpenFailed(const char *networkId, uint32_t authRequestId,
AuthConnCallback *callback);
static int32_t ActionOfAllocConnOpened(const char *networkId, uint32_t authRequestId,
AuthConnCallback *callback);
};
} // namespace OHOS
#endif // LNN_LANE_DEPS_MOCK_H

18
tests/core/bus_center/lnn/lane/src/lnn_lane_deps_mock.cpp
View File

@ -156,24 +156,6 @@ int32_t LaneDepsInterfaceMock::ActionOfConnOpened(const AuthConnInfo *info, uint
return SOFTBUS_OK;
}
int32_t LaneDepsInterfaceMock::ActionOfAllocConnOpenFailed(const char *networkId, uint32_t authRequestId,
AuthConnCallback *callback)
{
callback->onConnOpenFailed(authRequestId, SOFTBUS_ERR);
return SOFTBUS_OK;
}
int32_t LaneDepsInterfaceMock::ActionOfAllocConnOpened(const char *networkId, uint32_t authRequestId,
AuthConnCallback *callback)
{
AuthHandle authHandle = {
.authId = 0,
.type = AUTH_LINK_TYPE_P2P,
};
callback->onConnOpened(authRequestId, authHandle);
return SOFTBUS_OK;
}
extern "C" {
int32_t GetAuthLinkTypeList(const char *networkId, AuthLinkTypeList *linkTypeList)
{

44
tests/core/bus_center/lnn/lane/src/lnn_lane_test.cpp
View File

@ -253,9 +253,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_001, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(16), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(16), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -285,9 +285,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_002, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(16), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(16), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -317,9 +317,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_003, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(16), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(16), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -349,9 +349,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_004, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -381,9 +381,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_005, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -413,9 +413,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_006, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -445,9 +445,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_007, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -477,9 +477,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_008, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -509,9 +509,9 @@ HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_009, TestSize.Level1)
EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
EXPECT_CALL(mock, LnnGetLocalNumInfo)
EXPECT_CALL(mock, LnnGetLocalNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
EXPECT_CALL(mock, LnnGetRemoteNumInfo)
EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
.WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
wifiMock.SetDefaultResult();
@ -1251,8 +1251,8 @@ HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_004, TestSize.Level1)
NiceMock<LaneDepsInterfaceMock> linkMock;
EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
EXPECT_CALL(linkMock, LnnGetLocalNumInfo).WillRepeatedly(DoAll(SetArgPointee<1>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetRemoteNumInfo).WillRepeatedly(DoAll(SetArgPointee<2>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetLocalNumU32Info).WillRepeatedly(DoAll(SetArgPointee<1>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info).WillRepeatedly(DoAll(SetArgPointee<2>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetLocalNumU64Info).WillRepeatedly(DoAll(SetArgPointee<1>(8), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info).WillRepeatedly(DoAll(SetArgPointee<2>(8), Return(SOFTBUS_OK)));
@ -1282,8 +1282,8 @@ HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_005, TestSize.Level1)
NiceMock<LaneDepsInterfaceMock> linkMock;
EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
EXPECT_CALL(linkMock, LnnGetLocalNumInfo).WillRepeatedly(DoAll(SetArgPointee<1>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetRemoteNumInfo).WillRepeatedly(DoAll(SetArgPointee<2>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetLocalNumU32Info).WillRepeatedly(DoAll(SetArgPointee<1>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info).WillRepeatedly(DoAll(SetArgPointee<2>(11), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetLocalNumU64Info).WillRepeatedly(DoAll(SetArgPointee<1>(8), Return(SOFTBUS_OK)));
EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info).WillRepeatedly(DoAll(SetArgPointee<2>(8), Return(SOFTBUS_OK)));

21
tests/core/bus_center/lnn/lane_link/lnn_lane_link_test.cpp
View File

@ -543,7 +543,7 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_006, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn).WillRepeatedly(Return(SOFTBUS_ERR));
EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_ERR));
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
ret = LnnConnectP2p(&request, laneReqId, &cb);
@ -591,7 +591,7 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_007, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthOpenConn).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
ret = LnnConnectP2p(&request, laneReqId, &cb);
@ -640,7 +640,7 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_008, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthOpenConn).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
ret = LnnConnectP2p(&request, laneReqId, &cb);
@ -686,7 +686,7 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_009, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn).WillRepeatedly(Return(SOFTBUS_ERR));
EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_ERR));
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
ret = LnnConnectP2p(&request, laneReqId, &cb);
@ -992,7 +992,7 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_005, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn(_, requestId, NotNull())).WillRepeatedly(linkMock.ActionOfAllocConnOpenFailed);
EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpenFailed);
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
ret = LnnConnectP2p(&request, laneReqId, &cb);
@ -1042,8 +1042,8 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_006, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn(_, requestId, NotNull())).WillOnce(linkMock.ActionOfAllocConnOpenFailed)
.WillRepeatedly(linkMock.ActionOfAllocConnOpened);
EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpenFailed)
.WillRepeatedly(linkMock.ActionOfConnOpened);
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
@ -1094,8 +1094,8 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_007, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn(_, requestId, NotNull())).WillOnce(linkMock.ActionOfAllocConnOpenFailed)
.WillRepeatedly(linkMock.ActionOfAllocConnOpened);
EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpenFailed)
.WillRepeatedly(linkMock.ActionOfConnOpened);
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
@ -1143,7 +1143,8 @@ HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_008, TestSize.Level1)
EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
EXPECT_CALL(linkMock, AuthAllocConn(_, requestId, NotNull())).WillRepeatedly(linkMock.ActionOfAllocConnOpenFailed);
EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpenFailed)
.WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_OK));

160
tests/core/bus_center/lnn/net_builder/src/lnn_data_cloud_sync_test.cpp Normal file
View File

@ -0,0 +1,160 @@
/*
* Copyright (c) 2023 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 <gtest/gtest.h>
#include <securec.h>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include "bus_center_info_key.h"
#include "bus_center_manager.h"
#include "lnn_data_cloud_sync.h"
#include "lnn_log.h"
#include "lnn_node_info.h"
#include "lnn_parameter_utils.h"
#include "softbus_adapter_mem.h"
#include "softbus_error_code.h"
#include "softbus_common.h"
namespace OHOS {
using namespace testing::ext;
using namespace testing;
constexpr char VALUE[] = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000#1";
constexpr char RIGHT_KEY[] = "123456789#1111111111111111111111111111111111111111111111111111111111111111#DEVICE_NAME";
class LNNDataCloudSyncTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
void LNNDataCloudSyncTest::SetUpTestCase() {}
void LNNDataCloudSyncTest::TearDownTestCase() {}
void LNNDataCloudSyncTest::SetUp()
{
LNN_LOGI(LNN_TEST, "LNNDataCloudSyncTest start");
}
void LNNDataCloudSyncTest::TearDown() {}
/*
* @tc.name: LnnLedgerAllDataSyncToDB_Test_001
* @tc.desc: LnnLedgerAllDataSyncToDB
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDataCloudSyncTest, LnnLedgerAllDataSyncToDB_Test_001, TestSize.Level1)
{
LnnInitCloudSyncModule();
NodeInfo *info = nullptr;
int32_t ret = LnnLedgerAllDataSyncToDB(info);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
info = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
memset_s(info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
info->accountId = 0;
ret = LnnLedgerAllDataSyncToDB(info);
EXPECT_EQ(ret, SOFTBUS_ERR);
info->accountId = 18390933952;
ret = LnnLedgerAllDataSyncToDB(info);
EXPECT_EQ(ret, SOFTBUS_OK);
SoftBusFree(info);
LnnDeInitCloudSyncModule();
}
/*
* @tc.name: LnnLedgerDataChangeSyncToDB_Test_001
* @tc.desc: LnnLedgerDataChangeSyncToDB
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDataCloudSyncTest, LnnLedgerDataChangeSyncToDB_Test_001, TestSize.Level1)
{
LnnInitCloudSyncModule();
char *key = nullptr;
char *value = nullptr;
int32_t ret = LnnLedgerDataChangeSyncToDB(key, value, strlen(value));
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
LnnDeleteSyncToDB();
LnnDeInitCloudSyncModule();
}
/*
* @tc.name: LnnDBDataChangeSyncToCache_Test_001
* @tc.desc: LnnDBDataChangeSyncToCache
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDataCloudSyncTest, LnnDBDataChangeSyncToCache_Test_001, TestSize.Level1)
{
LnnInitCloudSyncModule();
char *key = nullptr;
char *value = nullptr;
ChangeType type = DB_UPDATE;
int32_t ret = LnnDBDataChangeSyncToCache(key, value, type);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, value, type);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, VALUE, type);
EXPECT_EQ(ret, SOFTBUS_ERR);
type = DB_DELETE;
ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, VALUE, type);
EXPECT_EQ(ret, SOFTBUS_OK);
type = DB_CHANGE_TYPE_MAX;
ret = LnnDBDataChangeSyncToCache(RIGHT_KEY, VALUE, type);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
LnnDeInitCloudSyncModule();
}
/*
* @tc.name: LnnDBDataAddChangeSyncToCache_Test_001
* @tc.desc: LnnDBDataAddChangeSyncToCache
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDataCloudSyncTest, LnnDBDataAddChangeSyncToCache_Test_001, TestSize.Level1)
{
LnnInitCloudSyncModule();
const char **key = nullptr;
const char **value = nullptr;
int32_t keySize = 0;
int32_t ret = LnnDBDataAddChangeSyncToCache(key, value, keySize);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
LnnDeInitCloudSyncModule();
}
/*
* @tc.name: LnnGetAccountIdfromLocalCache_Test_001
* @tc.desc: LnnGetAccountIdfromLocalCache
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDataCloudSyncTest, LnnGetAccountIdfromLocalCache_Test_001, TestSize.Level1)
{
LnnInitCloudSyncModule();
int64_t *buf = nullptr;
int32_t ret = LnnGetAccountIdfromLocalCache(buf);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
int64_t buffer = 0;
ret = LnnGetAccountIdfromLocalCache(&buffer);
EXPECT_EQ(ret, SOFTBUS_OK);
LnnDeInitCloudSyncModule();
}
} // namespace OHOS

2
tests/core/bus_center/lnn/net_builder/src/lnn_network_info_test.cpp
View File

@ -128,7 +128,6 @@ HWTEST_F(LNNNetworkInfoTest, LNN_BT_STATE_EVENT_HANDLER_TEST_001, TestSize.Level
WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_ERR);
EXPECT_CALL(netLedgerMock, LnnGetLocalNumInfo).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_ERR);
handler((LnnEventBasicInfo *)&btEvent1);
@ -182,7 +181,6 @@ HWTEST_F(LNNNetworkInfoTest, WIFI_STATE_EVENT_HANDLER_TEST_001, TestSize.Level1)
};
handler((LnnEventBasicInfo *)&wifiEvent4);
EXPECT_CALL(netLedgerMock, LnnGetLocalNumInfo).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_EQ(LnnInitNetworkInfo(), SOFTBUS_ERR);
handler((LnnEventBasicInfo *)&wifiEvent1);
SoftBusSleepMs(200);

124
tests/core/bus_center/lnn/net_ledger/lnn_disctributed_net_ledger_test.cpp
View File

@ -946,4 +946,128 @@ HWTEST_F(LNNDisctributedLedgerTest, DLGET_REMOTE_PTK_Test_001, TestSize.Level1)
ret = DlGetRemotePtk(networkId, nullptr, STATIC_CAP_LEN + 1);
EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
}
/*
* @tc.name: LnnSetDLUnifiedDeviceName_Test_001
* @tc.desc: LnnSetDLUnifiedDeviceName
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnSetDLUnifiedDeviceName_Test_001, TestSize.Level1)
{
char *udid = nullptr;
char *name = nullptr;
bool ret = LnnSetDLUnifiedDeviceName(udid, name);
EXPECT_TRUE(ret == false);
const char *devUdid = "123456789";
const char *devName = "devicename";
ret = LnnSetDLUnifiedDeviceName(devUdid, devName);
EXPECT_TRUE(ret == false);
}
/*
* @tc.name: LnnSetDLUnifiedDefaultDeviceName_Test_001
* @tc.desc: LnnSetDLUnifiedDefaultDeviceName
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnSetDLUnifiedDefaultDeviceName_Test_001, TestSize.Level1)
{
char *udid = nullptr;
char *name = nullptr;
bool ret = LnnSetDLUnifiedDefaultDeviceName(udid, name);
EXPECT_TRUE(ret == false);
const char *devUdid = "111111111";
const char *devName = "devdefaultdevicename";
ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, devName);
EXPECT_TRUE(ret == false);
}
/*
* @tc.name: LnnSetDLDeviceNickNameByUdid_Test_001
* @tc.desc: LnnSetDLDeviceNickNameByUdid
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnSetDLDeviceNickNameByUdid_Test_001, TestSize.Level1)
{
char *udid = nullptr;
char *name = nullptr;
bool ret = LnnSetDLDeviceNickNameByUdid(udid, name);
EXPECT_TRUE(ret == false);
const char *devUdid = "2222222222";
const char *devName = "deviceNickname";
ret = LnnSetDLDeviceNickNameByUdid(devUdid, devName);
EXPECT_TRUE(ret == false);
}
/*
* @tc.name: LnnSetDLDeviceStateVersion_Test_001
* @tc.desc: LnnSetDLDeviceStateVersion
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnSetDLDeviceStateVersion_Test_001, TestSize.Level1)
{
char *udid = nullptr;
int32_t stateVersion = 0;
bool ret = LnnSetDLDeviceStateVersion(udid, stateVersion);
EXPECT_TRUE(ret == false);
const char *devUdid = "3333333333";
ret = LnnSetDLDeviceStateVersion(devUdid, stateVersion);
EXPECT_TRUE(ret == false);
}
/*
* @tc.name: LnnSetDLDeviceBroadcastCipherKey_Test_001
* @tc.desc: LnnSetDLDeviceBroadcastCipherKey
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnSetDLDeviceBroadcastCipherKey_Test_001, TestSize.Level1)
{
char *udid = nullptr;
const char *cipherKey = "qqqqqqqqqqqq";
bool ret = LnnSetDLDeviceBroadcastCipherKey(udid, cipherKey);
EXPECT_TRUE(ret == false);
const char *devUdid = "123456789";
ret = LnnSetDLDeviceBroadcastCipherKey(devUdid, cipherKey);
EXPECT_TRUE(ret == false);
}
/*
* @tc.name: LnnSetDLDeviceBroadcastCipherIv_Test_001
* @tc.desc: LnnSetDLDeviceBroadcastCipherIv
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnSetDLDeviceBroadcastCipherIv_Test_001, TestSize.Level1)
{
char *udid = nullptr;
const char *cipherIv = "qqqqqqqqqqqq";
bool ret = LnnSetDLDeviceBroadcastCipherIv(udid, cipherIv);
EXPECT_TRUE(ret == false);
const char *devUdid = "123456789";
ret = LnnSetDLDeviceBroadcastCipherIv(devUdid, cipherIv);
EXPECT_TRUE(ret == false);
}
/*
* @tc.name: LnnUpdateDistributedNodeInfo_Test_001
* @tc.desc: LnnUpdateDistributedNodeInfo
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(LNNDisctributedLedgerTest, LnnUpdateDistributedNodeInfo_Test_001, TestSize.Level1)
{
NodeInfo newInfo;
memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
const char *udid = nullptr;
newInfo.accountId = 18390933952;
int32_t ret = LnnUpdateDistributedNodeInfo(&newInfo, udid);
EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
const char *devUdid = "123456789";
ret = LnnUpdateDistributedNodeInfo(&newInfo, devUdid);
EXPECT_TRUE(ret == true);
}
} // namespace OHOS

1
tests/core/bus_center/test/BUILD.gn
View File

@ -346,6 +346,7 @@ ohos_unittest("HeartBeatCtrlTest") {
"$dsoftbus_root_path/adapter:softbus_adapter",
"$dsoftbus_root_path/core/common:softbus_utils",
"$dsoftbus_root_path/core/common/dfx/log:softbus_dfx_log",
"$dsoftbus_root_path/core/frame:softbus_server",
"//third_party/googletest:gmock",
"//third_party/googletest:gtest_main",
]

6
tests/core/common/dfx/event/unittest/src/trans_event_test.cpp
View File

@ -82,6 +82,9 @@ HWTEST_F(TransEventTest, TransEventTest002, TestSize.Level0)
.peerDevVer = "NOH-AN00 peer_device_version",
.callerPkg = "testCallerPkg",
.calleePkg = "testCalleePkg",
.firstTokenName = "testfirstToken",
.firstTokenId = 0,
.firstTokenType = 0,
};
constexpr int32_t VALID_EXTRA_SIZE = TRANS_ASSIGNER_SIZE;
@ -125,6 +128,9 @@ HWTEST_F(TransEventTest, TransEventTest003, TestSize.Level0)
.peerDevVer = "",
.callerPkg = "\0",
.calleePkg = nullptr,
.firstTokenName = "",
.firstTokenId = 0,
.firstTokenType = 0,
};
constexpr int32_t VALID_EXTRA_SIZE = 2; // result, errcode is valid

4
tests/core/common/security/permission/standard/BUILD.gn
View File

@ -70,11 +70,13 @@ ohos_unittest("SoftbusPermissionACLTest") {
]
if (is_standard_system) {
external_deps = [
"ability_runtime:app_manager",
"access_token:libaccesstoken_sdk",
"access_token:libtoken_setproc",
"c_utils:utils",
"hilog:libhilog",
"ipc:ipc_single",
"samgr:samgr_proxy",
]
} else {
external_deps = [
@ -90,7 +92,7 @@ ohos_unittest("SoftbusPermissionACLTest") {
]
sources += [ "$dsoftbus_core_path/common/security/permission/standard/access_control.cpp" ]
} else {
sources += [ "$dsoftbus_core_path/common/security/permission/standard/access_control_virtual.cpp" ]
sources += [ "$dsoftbus_core_path/common/security/permission/standard/access_control_virtual.c" ]
}
}

10
tests/core/discovery/ble/bluetooth_mock/bluetooth_mock.cpp
View File

@ -40,7 +40,7 @@ namespace {
using OHOS::BluetoothMock;
using BtState = OHOS::BluetoothMock::BtState;
constexpr int64_t SLEEP_TIME = 50;
constexpr int64_t SLEEP_TIME = 200;
const std::function<void(void)> BT_STATE_FSM[BtState::BT_STATE_BUTT][BtState::BT_STATE_BUTT] = {
// BT_STATE_OFF
@ -49,8 +49,8 @@ const std::function<void(void)> BT_STATE_FSM[BtState::BT_STATE_BUTT][BtState::BT
nullptr,
// BT_STATE_OFF -> BT_STATE_ON
[]() {
EnableBr();
EnableBle();
std::thread(EnableBle).detach();
std::thread(EnableBr).detach();
},
// BT_STATE_OFF -> BT_STATE_RESTRICT
nullptr,
@ -59,8 +59,8 @@ const std::function<void(void)> BT_STATE_FSM[BtState::BT_STATE_BUTT][BtState::BT
{
// BT_STATE_ON -> BT_STATE_OFF
[]() {
DisableBr();
DisableBle();
std::thread(DisableBr).detach();
std::thread(DisableBle).detach();
},
// BT_STATE_ON -> BT_STATE_ON
nullptr,

1
tests/core/discovery/ble/bluetooth_mock/bluetooth_mock.h
View File

@ -26,6 +26,7 @@
namespace OHOS {
using testing::NiceMock;
using testing::AtMost;
class BluetoothInterface {
public:

8
tests/core/discovery/ble/bt_state/disc_bt_state_mock_test.cpp
View File

@ -33,7 +33,7 @@
#include "softbus_error_code.h"
namespace {
constexpr int64_t SLEEP_TIME = 50;
constexpr int64_t SLEEP_TIME = 200;
const std::string PACKET_CON = "0201021B16EEFD0405900000020018DD61155F421C49DA210E3C4F70656E480AFF7D0261726D6F6E7900";
const std::string PACKET_NON = "0201021B16EEFD0405100000020018DD61155F421C49DA210E3C4F70656E480AFF7D0261726D6F6E7900";
const std::string PACKET_NON_WITH_BR_ADDR =
@ -576,6 +576,7 @@ HWTEST_F(DiscBtStateTest, PublishPassive005, TestSize.Level1)
}
{
wrapper.Call(CMD::BLE_STOP_ADV, 1).Call(CMD::BLE_STOP_SCAN, 1).Build();
EXPECT_CALL(mock, BleSetAdvData).Times(AtMost(1));
mock.ConvertBtState(BluetoothMock::BtState::BT_STATE_OFF);
}
{
@ -625,11 +626,13 @@ HWTEST_F(DiscBtStateTest, PublishPassive006, TestSize.Level1)
}
{
wrapper.Call(CMD::BLE_START_ADV_EX, 1).Call(CMD::GET_LOCAL_ADDR, 1).Call(CMD::BLE_START_SCAN_EX, 1).Build();
EXPECT_CALL(mock, BleSetAdvData).Times(AtMost(1));
mock.ConvertBtState(BluetoothMock::BtState::BT_STATE_ON);
mock.CallbackAdvEnable();
}
{
wrapper.Call(CMD::BLE_STOP_ADV, 1).Call(CMD::BLE_STOP_SCAN, 1).Build();
EXPECT_CALL(mock, BleSetAdvData).Times(AtMost(1));
mock.ConvertBtState(BluetoothMock::BtState::BT_STATE_OFF);
}
{
@ -664,6 +667,7 @@ HWTEST_F(DiscBtStateTest, PublishPassive007, TestSize.Level1)
}
{
wrapper.Call(CMD::BLE_START_ADV_EX, 1).Call(CMD::GET_LOCAL_ADDR, 1).Build();
EXPECT_CALL(mock, BleSetAdvData).Times(AtMost(1));
g_isDeviceFound = false;
mock.CallbackScanResult(PACKET_CON);
EXPECT_FALSE(g_isDeviceFound);
@ -671,6 +675,7 @@ HWTEST_F(DiscBtStateTest, PublishPassive007, TestSize.Level1)
}
{
wrapper.Call(CMD::BLE_STOP_ADV, 1).Call(CMD::BLE_STOP_SCAN, 1).Build();
EXPECT_CALL(mock, BleSetAdvData).Times(AtMost(1));
mock.ConvertBtState(BluetoothMock::BtState::BT_STATE_OFF);
}
{
@ -684,6 +689,7 @@ HWTEST_F(DiscBtStateTest, PublishPassive007, TestSize.Level1)
}
{
wrapper.Call(CMD::BLE_STOP_ADV, 1).Call(CMD::BLE_STOP_SCAN, 1).Build();
EXPECT_CALL(mock, BleSetAdvData).Times(AtMost(1));
mock.ConvertBtState(BluetoothMock::BtState::BT_STATE_OFF);
}
{

5
tests/core/discovery/ble/softbus_ble_mock/ble_mock.cpp
View File

@ -239,6 +239,7 @@ int32_t BleMock::ActionOfStopBroadcasting(int32_t bcId)
advCallback->OnStopBroadcastingCallback(bcId, SOFTBUS_BT_STATUS_SUCCESS);
}
isAdvertising = !isAdvertising;
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_LOCK_LOCKED_MS));
GetMock()->AsyncAdvertiseDone();
return SOFTBUS_OK;
}
@ -279,6 +280,7 @@ int32_t BleMock::ActionOfSetAdvDataForActiveDiscovery(int32_t bcId, const Broadc
advCallback->OnSetBroadcastingCallback(bcId, SOFTBUS_BT_STATUS_SUCCESS);
}
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_LOCK_LOCKED_MS));
GetMock()->AsyncAdvertiseDone();
return SOFTBUS_OK;
}
@ -299,6 +301,7 @@ int32_t BleMock::ActionOfSetAdvDataForActivePublish(int32_t bcId, const Broadcas
advCallback->OnSetBroadcastingCallback(bcId, SOFTBUS_BT_STATUS_SUCCESS);
}
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_LOCK_LOCKED_MS));
GetMock()->AsyncAdvertiseDone();
return SOFTBUS_OK;
}
@ -320,6 +323,7 @@ int32_t BleMock::ActionOfSetAdvDataForPassivePublish(int32_t bcId, const Broadca
advCallback->OnSetBroadcastingCallback(bcId, SOFTBUS_BT_STATUS_SUCCESS);
}
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_LOCK_LOCKED_MS));
GetMock()->AsyncAdvertiseDone();
return SOFTBUS_OK;
}
@ -342,6 +346,7 @@ int32_t BleMock::ActionOfUpdateAdvForPassivePublish(
advCallback->OnUpdateBroadcastingCallback(bcId, SOFTBUS_BT_STATUS_SUCCESS);
}
std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_LOCK_LOCKED_MS));
GetMock()->AsyncAdvertiseDone();
return SOFTBUS_OK;
}

2
tests/core/transmission/trans_channel/proxy_channel/softbus_proxychannel_listener_test.cpp
View File

@ -366,6 +366,6 @@ HWTEST_F(SoftbusProxyChannelListenerTest, TransSendNetworkingMessageTest001, Tes
strcpy_s(sendData, SESSIONKEYSIZE, VALID_SESSIONNAME);
int32_t ret = TransSendNetworkingMessage(TEST_NUMBER_25, sendData, PROXY_CHANNEL_BT_IDLE_TIMEOUT, CONN_HIGH);
EXPECT_EQ(SOFTBUS_TRANS_PROXY_SEND_CHANNELID_INVALID, ret);
EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID, ret);
}
} // namespace OHOS

2
tests/core/transmission/trans_channel/proxy_channel/softbus_proxychannel_manager_test.cpp
View File

@ -759,7 +759,7 @@ HWTEST_F(SoftbusProxyChannelManagerTest, TransProxyCloseProxyChannelTest002, Tes
TransProxyProcessResetMsg(msg);
ret = TransProxyCloseProxyChannel(channelId);
EXPECT_EQ(SOFTBUS_TRANS_PROXY_DEL_CHANNELID_INVALID, ret);
EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID, ret);
channelId = TEST_MESSAGE_CHANNEL_ID;
ret = TransProxyCloseProxyChannel(channelId);

2
tests/core/transmission/trans_channel/udp_negotiation/BUILD.gn
View File

@ -26,6 +26,7 @@ ohos_unittest("TransUdpNegoTest") {
include_dirs = [
"$softbus_adapter_common/include",
"dsoftbus_dfx_path/interface/include",
"$dsoftbus_root_path/core/bus_center/utils/include",
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/core/common/security/permission/include",
"$dsoftbus_root_path/interfaces/kits/common",
@ -186,6 +187,7 @@ ohos_unittest("TransUdpManagerTest") {
include_dirs = [
"$softbus_adapter_common/include",
"dsoftbus_dfx_path/interface/include",
"$dsoftbus_root_path/core/bus_center/utils/include",
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/interfaces/kits/common",

33
tests/sdk/transmission/session/client_trans_session_callback_test.cpp
View File

@ -676,4 +676,37 @@ HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest13, TestS
EXPECT_EQ(ret, SOFTBUS_OK);
SoftBusFree(sessionParam);
}
/**
* @tc.name: TransClientSessionCallbackTest14
* @tc.desc: HandleAsyncBindSuccess not found session.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest14, TestSize.Level1)
{
SocketLifecycleData lifecycle;
lifecycle.bindErrCode = 0;
int32_t ret = HandleAsyncBindSuccess(1, NULL, &lifecycle);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
}
/**
* @tc.name: TransClientSessionCallbackTest15
* @tc.desc: HandleSyncBindSuccess not found session.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest15, TestSize.Level1)
{
SocketLifecycleData lifecycle;
lifecycle.sessionState = SESSION_STATE_CANCELLING;
lifecycle.bindErrCode = SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT;
int32_t ret = HandleSyncBindSuccess(1, &lifecycle);
EXPECT_EQ(ret, SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT);
lifecycle.sessionState = SESSION_STATE_INIT;
ret = HandleSyncBindSuccess(1, &lifecycle);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
}
}

103
tests/sdk/transmission/session/client_trans_session_manager_test.cpp
View File

@ -42,6 +42,8 @@
#define TRANS_TEST_ALGORITHM 1
#define TRANS_TEST_CRC 1
#define TRANS_TEST_STATE 1
#define TRANS_TEST_MAX_WAIT_TIMEOUT 9000
#define TRANS_TEST_DEF_WAIT_TIMEOUT 30000
#define MAX_SESSION_SERVER_NUM 32
@ -1401,4 +1403,105 @@ HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest45, TestSiz
ret = ClientGetSessionIsAsyncBySessionId(-1, &isAsync);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: TransClientSessionManagerTest46
* @tc.desc: Call ClientHandleBindWaitTimer for invalid param.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest46, TestSize.Level1)
{
int32_t ret = ClientHandleBindWaitTimer(-1, 0, TIMER_ACTION_STOP);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
ret = ClientHandleBindWaitTimer(1, 0, TIMER_ACTION_STOP);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
}
/**
* @tc.name: TransClientSessionManagerTest47
* @tc.desc: Call GetQosValue SUCCESS.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest47, TestSize.Level1)
{
QosTV qos[] = {
{.qos = QOS_TYPE_MAX_WAIT_TIMEOUT, .value = TRANS_TEST_MAX_WAIT_TIMEOUT},
{.qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0},
};
int32_t maxWaitTimeout = 0;
int32_t ret = GetQosValue(
qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
EXPECT_EQ(ret, SOFTBUS_OK);
EXPECT_EQ(maxWaitTimeout, TRANS_TEST_MAX_WAIT_TIMEOUT);
}
/**
* @tc.name: TransClientSessionManagerTest48
* @tc.desc: Call GetQosValue default value.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest48, TestSize.Level1)
{
QosTV qos[] = {
{ .qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0 },
};
int32_t maxWaitTimeout = 0;
int32_t ret = GetQosValue(
qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
EXPECT_EQ(ret, SOFTBUS_OK);
EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
ret = GetQosValue(
NULL, 0, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
EXPECT_EQ(ret, SOFTBUS_OK);
EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
}
/**
* @tc.name: TransClientSessionManagerTest49
* @tc.desc: Call GetQosValue FAIL.
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest49, TestSize.Level1)
{
int32_t maxWaitTimeout = 0;
int32_t ret = GetQosValue(
NULL, 1, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
}
/**
* @tc.name: TransClientSessionManagerTest50
* @tc.desc: Call ClientWaitSyncBind for invalid param..
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest50, TestSize.Level1)
{
int32_t ret = ClientWaitSyncBind(-1);
EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
ret = ClientWaitSyncBind(1);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
}
/**
* @tc.name: TransClientSessionManagerTest51
* @tc.desc: Call ClientWaitSyncBind for invalid param..
* @tc.type: FUNC
* @tc.require:
*/
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest51, TestSize.Level1)
{
int32_t ret = ClientSignalSyncBind(-1, 0);
EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
ret = ClientSignalSyncBind(1, 0);
EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
}
}

42
tools/device_info/get_device_info.c
View File

@ -21,6 +21,28 @@
static char const *g_pkgName = "ohos.dsoftbus.tool";
static void PrintNodePropertyNum(const NodeBasicInfo *nodeInfo)
{
NodeDeviceInfoKey key;
key = NODE_KEY_NETWORK_CAPABILITY;
int32_t netCapacity = 0;
if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key,
(uint8_t *)&netCapacity, LNN_COMMON_LEN) != 0) {
printf("GetNodeKeyInfo Fail!\n");
} else {
printf("netCapacity = %d\n", netCapacity);
}
key = NODE_KEY_NETWORK_TYPE;
int32_t netType = 0;
if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key,
(uint8_t *)&netType, LNN_COMMON_LEN) != 0) {
printf("GetNodeKeyInfo Fail!\n");
} else {
printf("netType = %d\n", netType);
}
}
static void PrintNodeProperty(const NodeBasicInfo *nodeInfo)
{
printf("DeviceName = %s\n", nodeInfo->deviceName);
@ -68,26 +90,6 @@ static void PrintNodeProperty(const NodeBasicInfo *nodeInfo)
}
}
static void PrintNodePropertyNum(const NodeBasicInfo *nodeInfo)
{
NodeDeviceInfoKey key;
key = NODE_KEY_NETWORK_CAPABILITY;
int32_t netCapacity = 0;
if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key,
(uint8_t *)&netCapacity, LNN_COMMON_LEN) != 0) {
printf("GetNodeKeyInfo Fail!\n");
} else {
printf("netCapacity = %d\n", netCapacity);
}
key = NODE_KEY_NETWORK_TYPE;
int32_t netType = 0;
if (GetNodeKeyInfo(g_pkgName, nodeInfo->networkId, key,
(uint8_t *)&netType, LNN_COMMON_LEN) != 0) {
printf("GetNodeKeyInfo Fail!\n");
} else {
printf("netType = %d\n", netType);
}
}
int main(int argc __attribute__((unused)), char **argv __attribute__((unused)))
{