From 8fde414159525815585af4b45e67f4d14b17b14a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Sat, 11 May 2024 09:28:09 +0800 Subject: [PATCH 1/8] =?UTF-8?q?L0=E5=8F=91=E7=8E=B0=E7=AD=96=E7=95=A5?= =?UTF-8?q?=E5=8A=9F=E8=83=BD=E6=B7=BB=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- interfaces/inner_kits/native_cpp/BUILD.gn | 2 + .../include/mini/device_manager_common.h | 1 + .../include/mini/device_manager_impl_lite_m.h | 3 + .../native_cpp/include/mini/hichain_adapter.h | 1 + .../include/mini/mine_softbus_adapter.h | 34 + .../src/mini/device_manager_impl_lite_m.c | 32 +- .../native_cpp/src/mini/hichain_adapter.c | 1 - .../src/mini/mine_softbus_adapter.c | 1284 +++++++++++++++++ .../native_cpp/src/mini/softbus_adapter.c | 7 +- 9 files changed, 1362 insertions(+), 3 deletions(-) create mode 100644 interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h create mode 100644 interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn index 5097fa9c..f06e7f92 100644 --- a/interfaces/inner_kits/native_cpp/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/BUILD.gn @@ -27,6 +27,7 @@ if (defined(ohos_lite)) { "//kernel/liteos_m/kal/cmsis", "//utils/native/lite/include", "//kernel/liteos_m/kal/posix/include", + "//third_party/mbedtls/include", "//third_party/musl/porting/liteos_m/kernel/include", "//device/bestechnic/bes2600w/sdk_liteos/bsp/platform/hal", "//foundation/communication/wifi_lite/interfaces/wifiservice", @@ -44,6 +45,7 @@ if (defined(ohos_lite)) { "${innerkits_path}/native_cpp/src/mini/device_manager_impl_lite_m.c", "${innerkits_path}/native_cpp/src/mini/hichain_adapter.c", "${innerkits_path}/native_cpp/src/mini/softbus_adapter.c", + "${innerkits_path}/native_cpp/src/mini/mine_softbus_adapter.c", ] deps = [ diff --git a/interfaces/inner_kits/native_cpp/include/mini/device_manager_common.h b/interfaces/inner_kits/native_cpp/include/mini/device_manager_common.h index e17cae79..0c70263e 100644 --- a/interfaces/inner_kits/native_cpp/include/mini/device_manager_common.h +++ b/interfaces/inner_kits/native_cpp/include/mini/device_manager_common.h @@ -29,6 +29,7 @@ extern "C" { #define DM_MAX_PKG_NAME_LEN 65 #define DM_MAX_DEVICE_ID_LEN 8 #define DM_MAX_USER_ID_LEN 128 +#define DM_DEVICE_NUMBER_LEN 11 #define DMLOGI(fmt, ...) printf("[devicemanager][I][%s] " fmt "\r\n", __func__, ##__VA_ARGS__) #define DMLOGE(fmt, ...) printf("[devicemanager][E][%s] " fmt "\r\n", __func__, ##__VA_ARGS__) diff --git a/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h b/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h index 5a58becd..bedde731 100644 --- a/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h +++ b/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h @@ -105,6 +105,8 @@ typedef struct { #endif int range; int credible; + bool isTrust; + bool isPeerExistCredential; bool isLocalExistCredential; int authForm; } DmDeviceInfo; @@ -123,6 +125,7 @@ typedef struct { typedef struct { void (*onTargetFound)(const DmDeviceBasicInfo *deviceInfo); + void (*onDeviceFound)(const DmDeviceInfo *deviceInfo); } OnTargetFound; typedef struct { diff --git a/interfaces/inner_kits/native_cpp/include/mini/hichain_adapter.h b/interfaces/inner_kits/native_cpp/include/mini/hichain_adapter.h index 220ba99c..8f0b71f1 100644 --- a/interfaces/inner_kits/native_cpp/include/mini/hichain_adapter.h +++ b/interfaces/inner_kits/native_cpp/include/mini/hichain_adapter.h @@ -25,6 +25,7 @@ extern "C" { int InitHichainModle(void); int UnInitHichainModle(void); int GetAuthFormByDeviceId(const char *deviceId, int authForm); +bool IsHichainCredentialExist(void); int RequestHichainCredential(const char *reqJsonStr, char **returnJsonStr); void FreeHichainJsonStringMemory(char **jsonStr); int CheckHichainCredential(const char *reqJsonStr, char **returnJsonStr); diff --git a/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h b/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h new file mode 100644 index 00000000..e819afcf --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h @@ -0,0 +1,34 @@ +/* + * 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 OHOS_DEVICE_MANAGER_MINE_SOFTBUS_ADAPTE_H +#define OHOS_DEVICE_MANAGER_MINE_SOFTBUS_ADAPTE_H + +#include "device_manager_impl_lite_m.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +int StartMineSoftbusQuickDiscovery(const char *pkgName, const int subscribeId, + const char *searchJson, OnTargetFound callback); +int PublishDeviceDiscovery(bool enable); + +#ifdef __cplusplus +} +#endif + +#endif // OHOS_DEVICE_MANAGER_MINE_SOFTBUS_ADAPTE_H diff --git a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c index b5876f93..9fa64025 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c +++ b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c @@ -24,10 +24,12 @@ #include "device_manager_common.h" #include "hichain_adapter.h" #include "softbus_adapter.h" +#include "mine_softbus_adapter.h" static const char * const FILED_PKG_NAME = "pkgName"; static const char * const FILED_BIND_TYPE = "bindType"; static const char * const FILED_SUBSCRIBE_ID = "subscribeId"; +static const char * const FIELD_DEVICE_MODE = "findDeviceMode"; static volatile bool g_deviceManagerInitFlag = false; @@ -46,6 +48,11 @@ int InitDeviceManager(void) return retValue; } #endif + retValue = PublishDeviceDiscovery(true); + if (retValue != DM_OK) { + DMLOGE("failed to en with ret: %d.", retValue); + return retValue; + } retValue = InitHichainModle(); if (retValue != DM_OK) { DMLOGE("failed to init hichain with ret: %d.", retValue); @@ -67,6 +74,7 @@ int UnInitDeviceManager(void) DMLOGI("device manager module not initialized."); return DM_OK; } + PublishDeviceDiscovery(false); #ifdef MINE_HARMONY_SOFTBUS UnInitSoftbusModle(); #endif @@ -146,6 +154,23 @@ int StopAdvertising(const char *pkgName) return StopSoftbusPublish(pkgName); } +static bool IsQuickStartDiscovery(const char *filterOption) +{ + cJSON *root = cJSON_Parse(filterOption); + if (root == NULL) { + DMLOGE("failed to parse filter option string."); + return false; + } + cJSON *object = cJSON_GetObjectItem(root, FIELD_DEVICE_MODE); + if (object == NULL || !cJSON_IsNumber(object)) { + cJSON_Delete(root); + return false; + } + cJSON_Delete(root); + DMLOGI("start quick start discovery."); + return true; +} + int StartDiscovering(const char *discoverParam, const char *filterOption, OnTargetFound callback) { DMLOGI("device manager start discovering start."); @@ -176,7 +201,12 @@ int StartDiscovering(const char *discoverParam, const char *filterOption, OnTarg return ERR_DM_INPUT_INVALID_VALUE; } int subscribeId = subscribeIdObj->valueint; - int ret = StartSoftbusDiscovery(pkgName, subscribeId, filterOption, callback); + int ret = ERR_DM_FAILED; + if (IsQuickStartDiscovery(filterOption)) { + ret = StartMineSoftbusQuickDiscovery(pkgName, subscribeId, filterOption, callback); + } else { + ret = StartSoftbusDiscovery(pkgName, subscribeId, filterOption, callback); + } cJSON_Delete(obj); return ret; } diff --git a/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c index d57e61f6..f9b17766 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c @@ -63,7 +63,6 @@ static int GetIdenticalAccountGroupInfo(char **groupVec); static char *GetIdeAccountQueryJson(void); static char *GetCredentialReqJsonString(const char *reqJsonStr); static char *GetGroupIdReqJsonString(const char *groupId); -static bool IsHichainCredentialExist(void); static char *GetIdentialAccountGroupIdJsonStr(void); static int ParseReturnJson(const char *returnJsonStr, int authForm); diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c new file mode 100644 index 00000000..af44f994 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -0,0 +1,1284 @@ +/* + * 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 "mine_softbus_adapter.h" + +#include +#include + +#include "cJSON.h" +#include "cmsis_os2.h" +#include "discovery_service.h" +#include "hichain_adapter.h" +#include "mbedtls/base64.h" +#include "mbedtls/md.h" +#include "mbedtls/sha256.h" +#include "los_config.h" +#include "los_mux.h" +#include "los_sem.h" +#include "los_swtmr.h" +#include "ohos_init.h" +#include "parameter.h" +#include "securec.h" +#include "softbus_bus_center.h" +#include "softbus_common.h" +#include "softbus_errcode.h" + +static const char * const DM_CAPABILITY_OSD = "osdCapability"; +static const char * const DM_PKG_NAME = "com.ohos.devicemanager"; +static const char * const FIELD_DEVICE_MODE = "findDeviceMode"; +static const char * const FIELD_TRUST_OPTIONS = "trustOptions"; +static const char * const FIELD_FILTER_OPTIONS = "filterOptions"; +static const char * const DEVICE_ALIAS = "persist.devicealias"; +static const char * const DEVICE_NUMBER = "persist.devicenumber"; +static const char * const DEVICE_DM_KEY = "DM"; + +static const char BROADCAST_VERSION = 1; // version for policy discovery. +static const char FIND_ALL_DEVICE = 1; // find all device +static const char FIND_SCOPE_DEVICE = 2; // find scope device +static const char FIND_VERTEX_DEVICE = 3; // find vertex device +static const char FIND_TRUST_DEVICE = 1; // find trust device +static const char FIND_NOTRUST_DEVICE = 2; // find not trust device +static const char DEVICE_TYPE_TYPE = 1; // device type matching type +static const char DEVICE_SN_TYPE = 2; // device sn matching type +static const char DEVICE_UDID_TYPE = 3; // device udid matching type +static const char DEVICE_ALIAS_NUMBER = 1; // device alias matching type + +#define DM_TLV_SCOPE_DATA_OFFSET 4 // offset from the TLV header to the hash truncated part +#define DM_TLV_VERTEX_DATA_OFFSET 2 // offset from the TLV header to the hash truncated part +#define DM_SEARCH_BROADCAST_MIN_LEN 18 // Minimum broadcast length +#define DM_FULL_QUEUE_USELESS_LEN 1 // Indicates the idle flag length of the full cyclic queue +#define DM_MAX_DEVICE_ALIAS_LEN 65 // maximum length of the device alias hat can be imported. +#define DM_INVALID_DEVICE_NUMBER (-1) // invaild number of device +#define DM_MAX_SCOPE_TLV_NUM 2 // maximum Types of input options for scope search. +#define DM_MAX_VERTEX_TLV_NUM 6 // maximum Types of input options for vertex search. +#define DM_MAX_MATCH_WAIT_NUMBER 256 // maximum number of devices waiting for match +#define DM_MAX_DEVICE_NUMBER 100000000 // maxinum number of device +#define SOFTBUS_DELAY_TICK_COUNT (10 * LOSCFG_BASE_CORE_TICK_PER_SECOND) // 10s + +static const UINT16 DEAL_TASK_PRIOR = 13; // priority of a timer task +static const UINT32 TASK_STACK_SIZE = 10240; // stack size of the networking task + +static const int DM_MAX_SEARCH_JSON_LEN = 3072; + +typedef struct { + char version; + char headDataLen; + char tlvDataLen; + char pkgNameHash[DM_HASH_DATA_LEN]; + char findMode; + char trustFilter; +} BroadcastHead; + +typedef struct { + char version; + char dataLen; + bool isExistCredential; + char pkgNameHash[DM_HASH_DATA_LEN]; +} ReturnwaveHead; + + +typedef enum { + DISCOVERY_POLICY_ALLOW_REPLY, + DISCOVERY_POLICY_REJECT_REPLY, +} Action; + +typedef struct { + bool snHashValid; + bool typeHashValid; + bool udidHashValid; + bool aliasHashValid; + bool numberValid; + char snHash[DM_HASH_DATA_LEN]; + char typeHash[DM_HASH_DATA_LEN]; + char udidHash[DM_HASH_DATA_LEN]; + char aliasHash[DM_HASH_DATA_LEN]; + char number[DM_DEVICE_NUMBER_LEN]; +} DevicePolicyInfo; + +static void AddHeadToBroadcast(const BroadcastHead *broadcastHead, char *output); + +static bool CheckDeviceSnMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data); +static bool CheckDeviceAliasMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data); +static bool CheckDeviceTypeMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data); +static bool CheckDeviceUdidMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data); +static bool CheckDeviceNumberMatch(const DevicePolicyInfo *devicePolicyInfo, int startNumber, int endNumber); + +static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInfo *deviceInfo, bool isExistCredential); + +static bool GetDeviceSnHash(char *output); +static bool GetDeviceUdidHash(char *output); +static bool GetDeviceTypeHash(char *output); +static bool GetDeviceAliasHash(char *output); +static bool GetDeviceNumber(char *output); +static void GetScopeDevicePolicyInfo(DevicePolicyInfo *devicePolicyInfo); +static void GetVertexDevicePolicyInfo(DevicePolicyInfo *devicePolicyInfo); +static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLen); +static Action GetMatchResult(const int *matchItemNum, const int *matchItemResult, const int bufLen); +static int GetSha256Hash(const char *data, size_t len, char *output); + +static int SetBroadcastHead(const cJSON *root, const char *pkgName, BroadcastHead* broadcastHead); +static int SetBroadcastTrustOptions(const cJSON *root, BroadcastHead *broadcastHead); +static int SetBroadcastPkgname(const char *pkgName, BroadcastHead *broadcastHead); +static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *data, size_t dataLen); +static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead, Action matchResult); + +static int ParseSearchJson(const char *pkgName, const char *searchJsonStr, char *output, size_t *outLen); +static int ParseSearchJsonAndSendBroadcast(const char *pkgName, const int subscribeId, + const char *searchJson, OnTargetFound callback); +static int ParseSearchAllDevice(const cJSON *root, const char *pkgName, char *output, size_t *outLen); +static int ParseSearchScopeDevice(const cJSON *root, const char *pkgName, char *output, size_t *outLen); +static int ParseScopeDeviceJsonArray(const cJSON *object, const int arraySize, char *output, size_t *outLen); +static int ParseSearchVertexDevice(const cJSON *root, const char *pkgName, char *output, size_t *outLen); +static int ParseVertexDeviceJsonArray(const cJSON *object, const int arraySize, char *output, size_t *outLen); + +static bool ImportPkgNameToDiscoveryMap(const char *pkgName, const int subscribeId, OnTargetFound callback); +static bool IsValidMineStartDiscoveryInput(const char *pkgName, const char *searchJson, + OnTargetFound callback); + +static int ParseBroadcastInfo(DeviceInfo *deviceInfo); + +static Action MatchSearchAllDevice(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead); +static Action MatchSearchScopeDevice(DeviceInfo *deviceInfo, const char *inData, + const DevicePolicyInfo *devicePolicyInfo, const BroadcastHead *broadcastHead); +static Action MatchSearchVertexDevice(DeviceInfo *deviceInfo, const char *inData, + const DevicePolicyInfo *devicePolicyInfo, const BroadcastHead *broadcastHead); +static void MatchSearchDealTask(void); + +static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo); +static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason); +static void OnPublishDeviceFound(const DeviceInfo *deviceInfo); + +static UINT32 g_refreshDiscoverySem = 0; +static UINT32 g_discoveryMapMutex = 0; +static bool g_startQuickDiscoveryFlag = false; +static UINT32 g_matchDealTaskId = 0; +static UINT32 g_matchQueueMutex = 0; +static UINT32 g_matchWaitSem = 0; +static UINT32 g_publishServiceSem = 0; +static DeviceInfo g_matchDeviceInfo = {0}; + +static struct { + int subscribeId; + char pkgName[DM_MAX_PKG_NAME_LEN + 1]; + char pkgNameHash[DM_HASH_DATA_LEN]; + OnTargetFound discoveryCallback; + bool valid; +} g_discoveryCallbackMap; + +static struct { + int rear; + int front; + DeviceInfo deviceWaitInfo[DM_MAX_MATCH_WAIT_NUMBER]; +} g_matchQueue; + +#ifdef MINE_HARMONY_SOFTBUS +IRefreshCallback g_refreshMineDiscoveryCallback = { + .OnDeviceFound = OnDiscoveryDeviceFound, + .OnDiscoverResult = OnRefreshDiscoveryResult +}; +#endif + +#ifdef MINE_HARMONY_SOFTBUS +static IDiscoveryPolicyCallback publishLNNCallback_ = { + .PolicyReport = OnPublishDeviceFound +}; +#endif + +int PublishDeviceDiscovery(bool enable) +{ +#ifdef MINE_HARMONY_SOFTBUS + int retValue = EnableDiscoveryPolicy(DM_PKG_NAME, DM_CAPABILITY_OSD, enable, &publishLNNCallback_); + if (retValue != SOFTBUS_OK) { + DMLOGE("[softbus]failed to call softbus EnableDiscoveryPolicy function with ret: %d.", retValue); + return ERR_DM_SOFTBUS_PUBLISH_SERVICE; + } +#endif + return DM_OK; +} + +int StartMineSoftbusQuickDiscovery(const char *pkgName, const int subscribeId, + const char *searchJson, OnTargetFound callback) +{ + if (!IsValidMineStartDiscoveryInput(pkgName, searchJson, callback)) { + DMLOGE("input parameter is invalid."); + return ERR_DM_INPUT_INVALID_VALUE; + } + + int returnResult = DM_OK; + UINT32 osRet = LOS_MuxPend(g_discoveryMapMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to start discovery device mutex with ret: %u.", osRet); + return ERR_DM_LITEOS_PEND_MUTEX; + } + returnResult = ParseSearchJsonAndSendBroadcast(pkgName, subscribeId, searchJson, callback); + if (returnResult != DM_OK) { + DMLOGE("fail to ParseSearchJson and send with pkgName: %s.", pkgName); + } + osRet = LOS_MuxPost(g_discoveryMapMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post start discovery device mutex with ret: %u.", osRet); + returnResult = ERR_DM_LITEOS_POST_MUTEX; + } + if (returnResult != DM_OK) { + DMLOGE("fail to start quick discovery with pkgName: %s.", pkgName); + return returnResult; + } + DMLOGI("start quick discovery successfully with pkgName: %s.", pkgName); + return returnResult; +} + +static bool IsValidMineStartDiscoveryInput(const char *pkgName, const char *searchJson, + OnTargetFound callback) +{ + if (pkgName == NULL || searchJson == NULL || callback.onDeviceFound == NULL) { + DMLOGE("input point is NULL or searchJsonStr is NULL or callback is NULL."); + return false; + } + size_t pkgNameLen = strlen(pkgName); + size_t jsonLen = strlen(searchJson); + if (pkgNameLen == 0 || pkgNameLen >= DM_MAX_PKG_NAME_LEN || + jsonLen == 0 || jsonLen >= DM_MAX_SEARCH_JSON_LEN) { + DMLOGE("not meet the condition with pkgNameLen: %u, jsonLen: %u.", pkgNameLen, jsonLen); + return false; + } + return true; +} + +static int ParseSearchJsonAndSendBroadcast(const char *pkgName, const int subscribeId, + const char *searchJson, OnTargetFound callback) +{ + size_t outLen = 0; + char output[DISC_MAX_CUST_DATA_LEN] = {0}; + + if (g_discoveryCallbackMap.valid) { + DMLOGE("failed to start quick discovery because discovery behavior already exists."); + return ERR_DM_SOFTBUS_REPEAT_DISCOVERY_DEVICE; + } + if (ParseSearchJson(pkgName, searchJson, output, &outLen) != DM_OK) { + DMLOGE("failed to parse searchJsonStr with pkgName: %s.", pkgName); + return ERR_DM_CJSON_PARSE_STRING; + } + if (SendBroadcastInfo(pkgName, subscribeId, output, outLen) != DM_OK) { + DMLOGE("failed to start quick discovery beause sending broadcast info."); + return ERR_DM_SOFTBUS_SEND_BROADCAST; + } + if (!ImportPkgNameToDiscoveryMap(pkgName, subscribeId, callback)) { + DMLOGE("failed to import pkgName to discovery map."); + return ERR_DM_IMPORT_PKGNAME; + } + return DM_OK; +} + +static int ParseSearchJson(const char *pkgName, const char *searchJsonStr, char *output, size_t *outLen) +{ + int retValue = ERR_DM_FAILED; + cJSON *root = cJSON_Parse(searchJsonStr); + if (root == NULL) { + DMLOGE("failed to parse search cjson string."); + return ERR_DM_CJSON_CREATE_OBJECT; + } + cJSON *object = cJSON_GetObjectItem(root, FIELD_DEVICE_MODE); + if (object == NULL || !cJSON_IsNumber(object)) { + DMLOGE("key is not exist or is not string with key: %s.", FIELD_DEVICE_MODE); + cJSON_Delete(root); + return ERR_DM_CJSON_GET_OBJECT; + } + int findMode = object->valueint; + DMLOGI("quick search device mode is: %d.", findMode); + switch (object->valueint) { + case FIND_ALL_DEVICE: + retValue = ParseSearchAllDevice(root, pkgName, output, outLen); + break; + case FIND_SCOPE_DEVICE: + retValue = ParseSearchScopeDevice(root, pkgName, output, outLen); + break; + case FIND_VERTEX_DEVICE: + retValue = ParseSearchVertexDevice(root, pkgName, output, outLen); + break; + default: + DMLOGE("key type is not match key: %s.", FIELD_DEVICE_MODE); + } + cJSON_Delete(root); + if (retValue != DM_OK) { + DMLOGE("fail to parse search find device with ret: %d.", retValue); + return retValue; + } + DMLOGI("parse search json successfully with pkgName: %s, outLen: %u.", pkgName, *outLen); + return DM_OK; +} + +static void AddHeadToBroadcast(const BroadcastHead *broadcastHead, char *output) +{ + size_t startPos = 0; + output[startPos++] = broadcastHead->version; + output[startPos++] = broadcastHead->headDataLen; + output[startPos++] = broadcastHead->tlvDataLen; + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + output[startPos++] = broadcastHead->pkgNameHash[i]; + } + output[startPos++] = broadcastHead->findMode; + output[startPos++] = broadcastHead->trustFilter; + DMLOGI("find device info with version: %d, findMode: %d, HeadLen: %d, tlvDataLen: %d, trustFilter: %d.", + (int)(broadcastHead->version), (int)(broadcastHead->findMode), (int)(broadcastHead->headDataLen), + (int)(broadcastHead->tlvDataLen), (int)(broadcastHead->trustFilter)); +} + +static int SetBroadcastHead(const cJSON *root, const char *pkgName, BroadcastHead* broadcastHead) +{ + broadcastHead->version = BROADCAST_VERSION; + broadcastHead->headDataLen = sizeof(BroadcastHead); + broadcastHead->tlvDataLen = 0; + broadcastHead->findMode = 0; + if (SetBroadcastTrustOptions(root, broadcastHead) != DM_OK) { + DMLOGE("fail to set trust options to search broadcast."); + return ERR_DM_FAILED; + } + if (SetBroadcastPkgname(pkgName, broadcastHead) != DM_OK) { + DMLOGE("fail to set pkgName to search broadcast."); + return ERR_DM_FAILED; + } + return DM_OK; +} + +static int SetBroadcastTrustOptions(const cJSON *root, BroadcastHead* broadcastHead) +{ + cJSON *object = cJSON_GetObjectItem(root, FIELD_TRUST_OPTIONS); + if (object == NULL) { + broadcastHead->trustFilter = 0; + return DM_OK; + } else if (cJSON_IsBool(object) && object->type == cJSON_True) { + broadcastHead->trustFilter = FIND_TRUST_DEVICE; + return DM_OK; + } else if (cJSON_IsBool(object) && object->type == cJSON_False) { + broadcastHead->trustFilter = FIND_NOTRUST_DEVICE; + return DM_OK; + } + DMLOGE("key type is error with key: %s.", FIELD_TRUST_OPTIONS); + return ERR_DM_FAILED; +} + +static int SetBroadcastPkgname(const char *pkgName, BroadcastHead *broadcastHead) +{ + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash((const char*)pkgName, strlen(pkgName), sha256Out) != DM_OK) { + DMLOGE("failed to get search pkgName sha256 hash while search all device."); + return ERR_DM_FAILED; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + broadcastHead->pkgNameHash[i] = sha256Out[i]; + } + return DM_OK; +} + +static int ParseSearchAllDevice(const cJSON *root, const char *pkgName, char *output, size_t *outLen) +{ + BroadcastHead broadcastHead; + if (SetBroadcastHead(root, pkgName, &broadcastHead) != DM_OK) { + DMLOGE("fail to set broadcast head."); + return ERR_DM_FAILED; + } + broadcastHead.tlvDataLen = 0; + broadcastHead.findMode = FIND_ALL_DEVICE; + AddHeadToBroadcast(&broadcastHead, output); + *outLen = sizeof(BroadcastHead); + return DM_OK; +} + +static int ParseSearchScopeDevice(const cJSON *root, const char *pkgName, char *output, size_t *outLen) +{ + BroadcastHead broadcastHead; + if (SetBroadcastHead(root, pkgName, &broadcastHead) != DM_OK) { + DMLOGE("fail to set broadcast head."); + return ERR_DM_FAILED; + } + + cJSON *object = cJSON_GetObjectItem(root, FIELD_FILTER_OPTIONS); + if (object == NULL || !cJSON_IsArray(object)) { + DMLOGE("failed to get %s scope cjson object or is not array.", FIELD_FILTER_OPTIONS); + return ERR_DM_FAILED; + } + int arraySize = cJSON_GetArraySize(object); + if (arraySize <= 0 || arraySize > DM_MAX_SCOPE_TLV_NUM) { + DMLOGE("failed to get scope array cjson size or too lenght with len: %d.", arraySize); + return ERR_DM_FAILED; + } + + DMLOGI("start to parse scope search array json with size: %d.", arraySize); + if (ParseScopeDeviceJsonArray(object, arraySize, output + sizeof(BroadcastHead), outLen) != DM_OK) { + DMLOGE("failed to parse scope json array."); + return ERR_DM_FAILED; + } + broadcastHead.findMode = FIND_SCOPE_DEVICE; + broadcastHead.tlvDataLen = *outLen; + AddHeadToBroadcast(&broadcastHead, output); + *outLen = *outLen + sizeof(BroadcastHead); + return DM_OK; +} + +static int ParseSearchVertexDevice(const cJSON *root, const char *pkgName, char *output, size_t *outLen) +{ + BroadcastHead broadcastHead; + if (SetBroadcastHead(root, pkgName, &broadcastHead) != DM_OK) { + DMLOGE("fail to set broadcast head."); + return ERR_DM_FAILED; + } + + cJSON *object = cJSON_GetObjectItem(root, FIELD_FILTER_OPTIONS); + if (object == NULL || !cJSON_IsArray(object)) { + DMLOGE("failed to get %s vertex cjson object or is not array.", FIELD_FILTER_OPTIONS); + return ERR_DM_FAILED; + } + int arraySize = cJSON_GetArraySize(object); + if (arraySize <= 0 || arraySize > DM_MAX_VERTEX_TLV_NUM) { + DMLOGE("failed to get vertex array cjson size or too lenght with len: %d.", arraySize); + return ERR_DM_FAILED; + } + + DMLOGI("start to parse vertex search array json with size: %d.", arraySize); + if (ParseVertexDeviceJsonArray(object, arraySize, output + sizeof(BroadcastHead), outLen) != DM_OK) { + DMLOGE("failed to parse vertex json array."); + return ERR_DM_FAILED; + } + broadcastHead.findMode = FIND_VERTEX_DEVICE; + broadcastHead.tlvDataLen = *outLen; + AddHeadToBroadcast(&broadcastHead, output); + *outLen = *outLen + sizeof(BroadcastHead); + return DM_OK; +} + +static int ParseScopeDeviceJsonArray(const cJSON *object, const int arraySize, char *output, size_t *outLen) +{ + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + + for (int i = 0; i < arraySize; i++) { + cJSON *item = cJSON_GetArrayItem(object, i); + cJSON *deviceAlias = cJSON_GetObjectItem(item, "deviceAlias"); + cJSON *startNumber = cJSON_GetObjectItem(item, "startNumber"); + cJSON *endNumber = cJSON_GetObjectItem(item, "endNumber"); + if (item == NULL || deviceAlias == NULL || startNumber == NULL || endNumber == NULL || + !cJSON_IsString(deviceAlias) || !cJSON_IsNumber(startNumber) || !cJSON_IsNumber(endNumber)) { + DMLOGE("failed to get key or value with index: %d.", i); + return ERR_DM_FAILED; + } + if (startNumber->valueint >= DM_MAX_DEVICE_NUMBER || endNumber->valueint >= DM_MAX_DEVICE_NUMBER || + startNumber->valueint > endNumber->valueint) { + DMLOGE("device number is out of the proper range with index: %d, startNumber: %d, endNumber: %d.", + i, startNumber->valueint, endNumber->valueint); + return ERR_DM_FAILED; + } + if (GetSha256Hash((const char*)deviceAlias->valuestring, + strlen(deviceAlias->valuestring), sha256Out) != DM_OK) { + DMLOGE("failed to get sha256 hash with index: %d, value: %s.", i, deviceAlias->valuestring); + return ERR_DM_FAILED; + } + output[(*outLen)++] = DEVICE_ALIAS_NUMBER; + output[(*outLen)++] = DM_HASH_DATA_LEN; + output[(*outLen)++] = DM_DEVICE_NUMBER_LEN; + output[(*outLen)++] = DM_DEVICE_NUMBER_LEN; + for (int j = 0; j < DM_HASH_DATA_LEN; j++) { + output[(*outLen)++] = sha256Out[j]; + } + errno_t retValue = sprintf_s(&output[*outLen], DM_DEVICE_NUMBER_LEN, "%010d", startNumber->valueint); + if (retValue == EOK) { + DMLOGE("fail to add device number to data buffer"); + return ERR_DM_FAILED; + } + *outLen = *outLen + DM_DEVICE_NUMBER_LEN; + retValue = sprintf_s(&output[*outLen], DM_DEVICE_NUMBER_LEN, "%010d", endNumber->valueint); + if (retValue == EOK) { + DMLOGE("fail to add device number to data buffer."); + return ERR_DM_FAILED; + } + *outLen = *outLen + DM_DEVICE_NUMBER_LEN; + } + return DM_OK; +} + +static int ParseVertexDeviceJsonArray(const cJSON *object, const int arraySize, char *output, size_t *outLen) +{ + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + + for (int i = 0; i < arraySize; i++) { + cJSON *item = cJSON_GetArrayItem(object, i); + cJSON *type = cJSON_GetObjectItem(item, "type"); + cJSON *value = cJSON_GetObjectItem(item, "value"); + if (item == NULL || type == NULL || value == NULL || !cJSON_IsString(type) || !cJSON_IsString(value)) { + DMLOGE("failed to get type or value cjson object with index: %d.", i); + return ERR_DM_POINT_NULL; + } + if (GetSha256Hash((const char*)value->valuestring, strlen(value->valuestring), sha256Out) != DM_OK) { + DMLOGE("failed to get sha256 hash with index: %d, value: %s.", i, value->valuestring); + return ERR_DM_GET_SHA256_HASH; + } + if (strcmp(type->valuestring, "deviceType") == 0) { + output[(*outLen)++] = DEVICE_TYPE_TYPE; + } else if (strcmp(type->valuestring, "deviceSn") == 0) { + output[(*outLen)++] = DEVICE_SN_TYPE; + } else if (strcmp(type->valuestring, "deviceUdid") == 0) { + output[(*outLen)++] = DEVICE_UDID_TYPE; + } else { + DMLOGE("the value of type is not allowed with index: %d, value: %s.", i, value->valuestring); + continue; + } + output[(*outLen)++] = DM_HASH_DATA_LEN; + for (int j = 0; j < DM_HASH_DATA_LEN; j++) { + output[(*outLen)++] = sha256Out[j]; + } + } + return DM_OK; +} + +// returned string, which needs to be manually release by the invoker. +char *EncodeDMBroadcastData(const char *srcData) +{ + cJSON *root = cJSON_CreateObject(); + if (root == NULL) { + DMLOGE("failed to create cjson object."); + return ""; + } + if (cJSON_AddStringToObject(root, DEVICE_DM_KEY, srcData) == NULL) { + DMLOGE("failed to add true to object."); + cJSON_Delete(root); + return ""; + } + char *rootJsonStr = cJSON_PrintUnformatted(root); + if (rootJsonStr == NULL) { + DMLOGE("cJSON_PrintUnformatted failed, rootJsonStr is null."); + cJSON_Delete(root); + return ""; + } + cJSON_Delete(root); + return rootJsonStr; +} + +static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *data, size_t dataLen) +{ + size_t base64OutLen = 0; + char base64Out[DISC_MAX_CUST_DATA_LEN] = {0}; + int retValue = mbedtls_base64_encode((unsigned char *)base64Out, DISC_MAX_CUST_DATA_LEN, &base64OutLen, + (const unsigned char *)data, dataLen); + if (retValue != 0) { + DMLOGE("failed to get search data base64 encode type data with ret: %d.", retValue); + return ERR_DM_FAILED; + } + char *custData = EncodeDMBroadcastData(base64Out); + if (custData == NULL) { + DMLOGE("failed to get dm encode type data."); + return ERR_DM_FAILED; + } + +#ifdef MINE_HARMONY_SOFTBUS + SubscribeInfo subscribeInfo; + subscribeInfo.mode = DISCOVER_MODE_ACTIVE, + subscribeInfo.medium = AUTO, + subscribeInfo.freq = HIGH, + subscribeInfo.isSameAccount = false, + subscribeInfo.isWakeRemote = false, + subscribeInfo.capability = DM_CAPABILITY_OSD, + subscribeInfo.capabilityData = (const char*)custData; + subscribeInfo.dataLen = strlen(custData) + 1, + subscribeInfo.subscribeId = subscribeId, + retValue = RefreshLNN(DM_PKG_NAME, &subscribeInfo, &g_refreshMineDiscoveryCallback); + cJSON_free(custData); + if (retValue != SOFTBUS_OK) { + DMLOGE("[softbus]failed to start to refresh quick discovery with ret: %d.", retValue); + return ERR_DM_FAILED; + } + UINT32 osRet = LOS_SemPend(g_refreshDiscoverySem, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK || (osRet != LOS_OK && !g_startQuickDiscoveryFlag)) { + StopRefreshLNN(DM_PKG_NAME, subscribeId); + DMLOGE("failed to refresh quick discovery with ret: %u.", osRet); + return ERR_DM_FAILED; + } +#endif + DMLOGI("send search broadcast info by softbus successfully with dataLen: %u, pkgName: %s.", base64OutLen, + pkgName); + return DM_OK; +} + +static int GetSha256Hash(const char *data, size_t len, char *output) +{ + int mbedtlsHmacType = 0; + mbedtls_md_context_t mdContext; + const mbedtls_md_info_t* mdInfo = NULL; + + mbedtls_md_init(&mdContext); + mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); + int retValue = mbedtls_md_setup(&mdContext, mdInfo, mbedtlsHmacType); + if (retValue != 0) { + DMLOGE("failed to setup mbedtls md with ret: %d.", retValue); + return ERR_DM_FAILED; + } + retValue = mbedtls_md_starts(&mdContext); + if (retValue != 0) { + DMLOGE("failed to start mbedtls md with ret: %d.", retValue); + mbedtls_md_free(&mdContext); + return ERR_DM_FAILED; + } + retValue = mbedtls_md_update(&mdContext, (const unsigned char*)data, len); + if (retValue != 0) { + DMLOGE("failed to update mbedtls md with ret: %d.", retValue); + mbedtls_md_free(&mdContext); + return ERR_DM_FAILED; + } + retValue = mbedtls_md_finish(&mdContext, output); + if (retValue != 0) { + DMLOGE("failed to finish mbedtls md with ret: %d.", retValue); + mbedtls_md_free(&mdContext); + return ERR_DM_FAILED; + } + mbedtls_md_free(&mdContext); + return DM_OK; +} + +static bool ImportPkgNameToDiscoveryMap(const char *pkgName, const int subscribeId, OnTargetFound callback) +{ + errno_t retValue = strcpy_s(g_discoveryCallbackMap.pkgName, DM_MAX_PKG_NAME_LEN, pkgName); + if (retValue != EOK) { + DMLOGE("failed to copy pkgName: %s to discovery map.", pkgName); + return false; + } + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash(pkgName, strlen(pkgName), sha256Out) != DM_OK) { + DMLOGE("failed to get send search pkgName sha256 hash."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + g_discoveryCallbackMap.pkgNameHash[i] = sha256Out[i]; + } + g_discoveryCallbackMap.subscribeId = subscribeId; + g_discoveryCallbackMap.discoveryCallback = callback; + g_discoveryCallbackMap.valid = true; + return true; +} + +static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo) +{ + if (deviceInfo == NULL) { + DMLOGE("deviceInfo is NULL."); + return; + } + size_t dataLen = strlen(deviceInfo->custData) + 1; + if (dataLen < sizeof(ReturnwaveHead)) { + DMLOGE("deviceInfo is business data lenght: %u is error.", dataLen); + return; + } + DMLOGI("softbus notify that a device was found with dataLen: %u.", dataLen); + + size_t base64OutLen = 0; + char base64Out[DISC_MAX_CUST_DATA_LEN] = {0}; + char *data = (unsigned char*)deviceInfo->custData; + int retValue = mbedtls_base64_decode((unsigned char *)base64Out, DISC_MAX_CUST_DATA_LEN, &base64OutLen, + (const unsigned char *)data, dataLen); + if (retValue != 0) { + DMLOGE("failed to get search data base64 decode data with ret: %d.", retValue); + return; + } + UINT32 osRet = LOS_MuxPend(g_discoveryMapMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to pend discovery device mutex with ret: %u.", osRet); + return; + } + ReturnwaveHead *returnwaveHead = (ReturnwaveHead *)base64Out; + if (memcmp(g_discoveryCallbackMap.pkgNameHash, returnwaveHead->pkgNameHash, DM_HASH_DATA_LEN) == EOK) { + DMLOGI("will notify the user that a new device has been discovered."); + DmDeviceInfo dmDeviceInfo; + DeviceInfoCopyToDmDevice(&dmDeviceInfo, deviceInfo, returnwaveHead->isExistCredential); + g_discoveryCallbackMap.discoveryCallback.onDeviceFound(&dmDeviceInfo); + } + osRet = LOS_MuxPost(g_discoveryMapMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post discovery device mutex with ret: %u.", osRet); + return; + } + DMLOGI("OnDiscoveryDeviceFound callback complete."); +} + +static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason) +{ + if (reason == REFRESH_LNN_SUCCESS) { + DMLOGI("refresh discovery result successfully with refreshId: %d.", refreshId); + g_startQuickDiscoveryFlag = true; + } else { + DMLOGI("failed to refresh discovery result with refreshId: %d, reason: %d.", refreshId, (int)reason); + g_startQuickDiscoveryFlag = false; + } + UINT32 osRet = LOS_SemPost(g_refreshDiscoverySem); + if (osRet != LOS_OK) { + DMLOGE("failed to post refresh discovery device semaphore with ret: %u.", osRet); + return; + } +} + +static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInfo *deviceInfo, bool isExistCredential) +{ + (void)memset_s(dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); + errno_t retValue = strcpy_s(dmDeviceInfo->deviceId, sizeof(dmDeviceInfo->deviceId), deviceInfo->devId); + if (retValue != EOK) { + DMLOGE("failed to copy device id with ret: %d.", retValue); + } + retValue = strcpy_s(dmDeviceInfo->deviceName, sizeof(dmDeviceInfo->deviceName), deviceInfo->devName); + if (retValue != EOK) { + DMLOGE("failed to copy device name with ret: %d.", retValue); + } + dmDeviceInfo->isTrust = deviceInfo->isOnline; + dmDeviceInfo->deviceTypeId = deviceInfo->devType; +#ifdef MINE_HARMONY_SOFTBUS + const size_t arrayStartPosition = 0; + dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; +#endif + dmDeviceInfo->isLocalExistCredential = IsHichainCredentialExist(); + dmDeviceInfo->isPeerExistCredential = isExistCredential; +} + +static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) +{ + if (deviceInfo == NULL) { + DMLOGE("deviceInfo is NULL."); + return; + } + size_t custDataLen = strlen(deviceInfo->custData) + 1; + if (custDataLen >= DISC_MAX_CUST_DATA_LEN || + custDataLen < DM_SEARCH_BROADCAST_MIN_LEN) { + DMLOGE("deviceInfo data is too short with dataLen: %u", custDataLen); + return; + } + + DMLOGI("broadcast data is received with DataLen: %u", custDataLen); + UINT32 osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); + return; + } + int tempValue = g_matchQueue.rear + DM_FULL_QUEUE_USELESS_LEN; + if (g_matchQueue.front != tempValue % DM_MAX_MATCH_WAIT_NUMBER) { + g_matchQueue.deviceWaitInfo[g_matchQueue.rear] = *deviceInfo; + g_matchQueue.rear = tempValue % DM_MAX_MATCH_WAIT_NUMBER; + osRet = LOS_SemPost(g_matchWaitSem); + if (osRet != LOS_OK) { + DMLOGE("failed to post match wait semaphore with ret: %u.", osRet); + } + } else { + DMLOGE("circular queue has no space to store the user match data."); + } + osRet = LOS_MuxPost(g_matchQueueMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post match queue mutex with ret: %u.", osRet); + } +} + +int CreateDealTask(void) +{ + g_matchQueue.front = 0; + g_matchQueue.rear = 0; + TSK_INIT_PARAM_S initParam; + initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)MatchSearchDealTask; + initParam.usTaskPrio = DEAL_TASK_PRIOR; + initParam.pcName = "matchDealTask"; + initParam.uwStackSize = TASK_STACK_SIZE; + UINT32 osRet = LOS_TaskCreate(&g_matchDealTaskId, &initParam); + if (osRet != LOS_OK) { + DMLOGE("failed to create match deal task with ret: %u.", osRet); + return ERR_DM_LITEOS_CREATE_TASK; + } + DMLOGI("create match deal task successfully with taskId: %u.", g_matchDealTaskId); + return DM_OK; +} + +int DeleteDealTask(void) +{ + UINT32 osRet = LOS_TaskDelete(g_matchDealTaskId); + if (osRet != LOS_OK && osRet != LOS_ERRNO_TSK_ID_INVALID) { + DMLOGE("failed to delete match deal task."); + return ERR_DM_LITEOS_DELETE_TASK; + } + g_matchDealTaskId = LOSCFG_BASE_CORE_TSK_LIMIT; + DMLOGI("delete match deal task successfully with taskId: %u.", g_matchDealTaskId); + return DM_OK; +} + +static void MatchSearchDealTask(void) +{ + DMLOGI("The match deal task has started to run."); + + while (true) { + bool matchWaitQueueFlag = false; + UINT32 osRet = LOS_SemPend(g_matchWaitSem, LOS_WAIT_FOREVER); + if (osRet != LOS_OK) { + DMLOGE("failed to block the task permanently with ret: %u.", osRet); + continue; + } + osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); + continue; + } + int tempValue = g_matchQueue.front + DM_FULL_QUEUE_USELESS_LEN; + if (g_matchQueue.front != g_matchQueue.rear) { + g_matchDeviceInfo = g_matchQueue.deviceWaitInfo[g_matchQueue.front]; + g_matchQueue.front = (tempValue) % DM_MAX_MATCH_WAIT_NUMBER; + matchWaitQueueFlag = true; + } else { + DMLOGE("no device information is found in the circular queue."); + } + osRet = LOS_MuxPost(g_matchQueueMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post match wait mutex with ret: %u.", osRet); + } + if (matchWaitQueueFlag && ParseBroadcastInfo(&g_matchDeviceInfo) != DM_OK) { + DMLOGE("failed to parse broadcast info."); + } + } +} + +static int ParseBroadcastInfo(DeviceInfo *deviceInfo) +{ + char outData[DISC_MAX_CUST_DATA_LEN] = {0}; + if (!GetBroadcastData(deviceInfo, outData, DISC_MAX_CUST_DATA_LEN)) { + DMLOGE("fail to get broadcast data."); + return ERR_DM_FAILED; + } + + DevicePolicyInfo devicePolicyInfo; + Action matchResult = DISCOVERY_POLICY_REJECT_REPLY; + BroadcastHead *broadcastHead = (BroadcastHead*)outData; + DMLOGI("parse device info with version: %d, findMode: %d, HeadLen: %d, tlvDataLen: %d, trustFilter: %d.", + (int)(broadcastHead->version), (int)(broadcastHead->findMode), (int)(broadcastHead->headDataLen), + (int)(broadcastHead->tlvDataLen), (int)(broadcastHead->trustFilter)); + + char findMode = broadcastHead->findMode; + switch (findMode) { + case FIND_ALL_DEVICE: + matchResult = MatchSearchAllDevice(deviceInfo, broadcastHead); + break; + case FIND_SCOPE_DEVICE: + GetScopeDevicePolicyInfo(&devicePolicyInfo); + matchResult = MatchSearchScopeDevice(deviceInfo, outData, &devicePolicyInfo, broadcastHead); + break; + case FIND_VERTEX_DEVICE: + GetVertexDevicePolicyInfo(&devicePolicyInfo); + matchResult = MatchSearchVertexDevice(deviceInfo, outData, &devicePolicyInfo, broadcastHead); + break; + default: + DMLOGE("key type is not match key: %s.", FIELD_DEVICE_MODE); + return ERR_DM_FAILED; + } + DMLOGI("parse broadcast info matchResult: %d.", (int)matchResult); + if (matchResult == DISCOVERY_POLICY_ALLOW_REPLY) { + return SendReturnwave(deviceInfo, broadcastHead, matchResult); + } + return DM_OK; +} + +static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLen) +{ + size_t base64OutLen = 0; + size_t dataLen = strlen(deviceInfo->custData) + 1; + char *data = (char*)deviceInfo->custData; + int retValue = mbedtls_base64_decode((unsigned char *)outData, outLen, &base64OutLen, + (const unsigned char *)data, dataLen); + if (retValue != 0) { + DMLOGE("failed to with ret: %d.", retValue); + return false; + } + if (base64OutLen < DM_SEARCH_BROADCAST_MIN_LEN) { + DMLOGE("data lenght too short with outLen: %u.", base64OutLen); + return false; + } + BroadcastHead *broadcastHead = (BroadcastHead*)outData; + size_t hDataLen = broadcastHead->headDataLen; + size_t tlvDataLen = broadcastHead->tlvDataLen; + if (hDataLen >= DISC_MAX_CUST_DATA_LEN || tlvDataLen >= DISC_MAX_CUST_DATA_LEN || + (hDataLen + tlvDataLen) != base64OutLen) { + DMLOGE("data lenght is not valid with: headDataLen: %u, tlvDataLen: %u, base64OutLen: %u.", + hDataLen, tlvDataLen, base64OutLen); + return false; + } + return true; +} + +static Action MatchSearchAllDevice(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead) +{ + if (broadcastHead->trustFilter == 0) { + return DISCOVERY_POLICY_ALLOW_REPLY; + } + if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DISCOVERY_POLICY_ALLOW_REPLY; + } else if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_NOTRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } else { + return DISCOVERY_POLICY_ALLOW_REPLY; + } +} + +static Action MatchSearchScopeDevice(DeviceInfo *deviceInfo, const char *inData, + const DevicePolicyInfo *devicePolicyInfo, const BroadcastHead *broadcastHead) +{ + int matchItemNum[DM_MAX_SCOPE_TLV_NUM] = {0}; + int matchItemResult[DM_MAX_SCOPE_TLV_NUM] = {0}; + + if (deviceInfo->isOnline && (broadcastHead->trustFilter == FIND_NOTRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } + + size_t tlvLen = broadcastHead->tlvDataLen; + const char *data = inData + broadcastHead->headDataLen; + const size_t oneTlvDataLen = DM_TLV_SCOPE_DATA_OFFSET + DM_HASH_DATA_LEN + + DM_DEVICE_NUMBER_LEN + DM_DEVICE_NUMBER_LEN; + const size_t numberAliasPos = 1; + for (size_t i = 0; (i + oneTlvDataLen) <= tlvLen; i += oneTlvDataLen) { + if (data[i] == DEVICE_ALIAS_NUMBER) { + size_t dataPosition = i + DM_TLV_SCOPE_DATA_OFFSET; + size_t startNumberPosition = dataPosition + DM_HASH_DATA_LEN; + int startNumber = atoi(&data[startNumberPosition]); + if (startNumber == 0) { + DMLOGE("the value of start device number is not allowed."); + continue; + } + size_t endNumberPosition = startNumberPosition + DM_DEVICE_NUMBER_LEN; + int endNumber = atoi(&data[endNumberPosition]); + if (endNumber == 0) { + DMLOGE("the value of end device number is not allowed."); + continue; + } + matchItemNum[numberAliasPos] = 1; + if (CheckDeviceAliasMatch(devicePolicyInfo, &data[dataPosition]) && + CheckDeviceNumberMatch(devicePolicyInfo, startNumber, endNumber)) { + matchItemResult[numberAliasPos] = 1; + } + } else { + DMLOGE("the value of type is not allowed with type: %u.", (size_t)data[i]); + continue; + } + } + return GetMatchResult(matchItemNum, matchItemResult, DM_MAX_SCOPE_TLV_NUM); +} + +static Action MatchSearchVertexDevice(DeviceInfo *deviceInfo, const char *inData, + const DevicePolicyInfo *devicePolicyInfo, const BroadcastHead *broadcastHead) +{ + int matchItemNum[DM_MAX_VERTEX_TLV_NUM] = {0}; + int matchItemResult[DM_MAX_VERTEX_TLV_NUM] = {0}; + + if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_NOTRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } + + size_t tlvLen = broadcastHead->tlvDataLen; + const char *data = inData + broadcastHead->headDataLen; + const size_t oneTlvDataLen = DM_TLV_VERTEX_DATA_OFFSET + DM_HASH_DATA_LEN; + const size_t typeTypePos = 1; + const size_t typeSnPos = 2; + const size_t typeUdidPos = 3; + for (size_t i = 0; (i + oneTlvDataLen) <= tlvLen; i += oneTlvDataLen) { + size_t dataPosition = 0; + if (data[i] == DEVICE_TYPE_TYPE) { + dataPosition = i + DM_TLV_VERTEX_DATA_OFFSET; + matchItemNum[typeTypePos] = 1; + if (CheckDeviceTypeMatch(devicePolicyInfo, &data[dataPosition])) { + matchItemResult[typeTypePos] = 1; + } + } else if (data[i] == DEVICE_SN_TYPE) { + dataPosition = i + DM_TLV_VERTEX_DATA_OFFSET; + matchItemNum[typeSnPos] = 1; + if (CheckDeviceSnMatch(devicePolicyInfo, &data[dataPosition])) { + matchItemResult[typeSnPos] = 1; + } + } else if (data[i] == DEVICE_UDID_TYPE) { + dataPosition = i + DM_TLV_VERTEX_DATA_OFFSET; + matchItemNum[typeUdidPos] = 1; + if (CheckDeviceUdidMatch(devicePolicyInfo, &data[dataPosition])) { + matchItemResult[typeUdidPos] = 1; + } + } else { + DMLOGE("the value of type is not allowed with type: %u.", (size_t)data[i]); + } + } + return GetMatchResult(matchItemNum, matchItemResult, DM_MAX_VERTEX_TLV_NUM); +} + +static Action GetMatchResult(const int *matchItemNum, const int *matchItemResult, const int bufLen) +{ + int matchItemSum = 0; + int matchResultSum = 0; + for (int i = 0; i < bufLen; i++) { + matchResultSum += matchItemResult[i]; + matchItemSum += matchItemNum[i]; + } + if (matchResultSum != 0 && matchItemSum == matchResultSum) { + return DISCOVERY_POLICY_ALLOW_REPLY; + } else { + return DISCOVERY_POLICY_REJECT_REPLY; + } +} + +// note: Internal interfaces ensure the validity of input parameters. +static bool CheckDeviceAliasMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data) +{ + if (!devicePolicyInfo->aliasHashValid) { + DMLOGE("device alias is not valid."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + if (data[i] != devicePolicyInfo->aliasHash[i]) { + DMLOGI("device alias is not match."); + return false; + } + } + DMLOGI("device alias is match."); + return true; +} + +// note: Internal interfaces ensure the validity of input parameters. +static bool CheckDeviceNumberMatch(const DevicePolicyInfo *devicePolicyInfo, int startNumber, int endNumber) +{ + if (!devicePolicyInfo->numberValid) { + DMLOGE("device number is not valid."); + return false; + } + if (startNumber <= DM_INVALID_DEVICE_NUMBER || endNumber <= DM_INVALID_DEVICE_NUMBER) { + DMLOGI("device number is match."); + return true; + } + int deviceNumber = atoi(devicePolicyInfo->number); + if (deviceNumber == 0) { + DMLOGI("device number is zero."); + return false; + } + if (deviceNumber < startNumber || deviceNumber > endNumber) { + DMLOGI("device number is not match."); + return false; + } + DMLOGI("device number is match."); + return true; +} + +// note: Internal interfaces ensure the validity of input parameters. +static bool CheckDeviceTypeMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data) +{ + if (!devicePolicyInfo->typeHashValid) { + DMLOGE("device type is not valid."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + if (data[i] != devicePolicyInfo->typeHash[i]) { + DMLOGI("device type is not match."); + return false; + } + } + DMLOGI("device type is match."); + return true; +} + +// note: Internal interfaces ensure the validity of input parameters. +static bool CheckDeviceUdidMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data) +{ + if (!devicePolicyInfo->udidHashValid) { + DMLOGE("device udid is not valid."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + if (data[i] != devicePolicyInfo->udidHash[i]) { + DMLOGI("device udid is not match."); + return false; + } + } + DMLOGI("device udid is match."); + return true; +} + +// note: Internal interfaces ensure the validity of input parameters. +static bool CheckDeviceSnMatch(const DevicePolicyInfo *devicePolicyInfo, const char *data) +{ + if (!devicePolicyInfo->snHashValid) { + DMLOGE("device sn is not valid."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + if (data[i] != devicePolicyInfo->snHash[i]) { + DMLOGI("device sn is not match."); + return false; + } + } + DMLOGI("device sn is match."); + return true; +} + +static void GetScopeDevicePolicyInfo(DevicePolicyInfo *devicePolicyInfo) +{ + devicePolicyInfo->numberValid = false; + devicePolicyInfo->aliasHashValid = false; + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + devicePolicyInfo->aliasHash[i] = 0; + } + for (int i = 0; i < DM_DEVICE_NUMBER_LEN; i++) { + devicePolicyInfo->number[i] = 0; + } + + if (GetDeviceAliasHash(devicePolicyInfo->aliasHash)) { + devicePolicyInfo->aliasHashValid = true; + } + if (GetDeviceNumber(devicePolicyInfo->number)) { + devicePolicyInfo->numberValid = true; + } +} + +static void GetVertexDevicePolicyInfo(DevicePolicyInfo *devicePolicyInfo) +{ + devicePolicyInfo->snHashValid = false; + devicePolicyInfo->typeHashValid = false; + devicePolicyInfo->udidHashValid = false; + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + devicePolicyInfo->snHash[i] = 0; + devicePolicyInfo->udidHash[i] = 0; + devicePolicyInfo->typeHash[i] = 0; + } + if (GetDeviceSnHash(devicePolicyInfo->snHash)) { + devicePolicyInfo->snHashValid = true; + } + if (GetDeviceUdidHash(devicePolicyInfo->udidHash)) { + devicePolicyInfo->udidHashValid = true; + } + if (GetDeviceTypeHash(devicePolicyInfo->typeHash)) { + devicePolicyInfo->typeHashValid = true; + } +} + +static bool GetDeviceSnHash(char* output) +{ + const char* deviceSn = GetSerial(); + if (deviceSn == NULL) { + DMLOGE("failed to get device sn from system parameter."); + return false; + } + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash(deviceSn, strlen(deviceSn), sha256Out) != DM_OK) { + DMLOGE("failed to generated device sn sha256 hash."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + output[i] = sha256Out[i]; + } + return true; +} + +static bool GetDeviceUdidHash(char* output) +{ + char deviceUdid[DM_MAX_DEVICE_UDID_LEN + 1] = {0}; + int32_t retValue = GetDevUdid(deviceUdid, DM_MAX_DEVICE_UDID_LEN); + if (retValue != 0) { + DMLOGE("failed to get local device udid with ret: %d.", retValue); + return false; + } + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash(deviceUdid, strlen(deviceUdid), sha256Out) != DM_OK) { + DMLOGE("failed to generated device udid sha256 hash."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + output[i] = sha256Out[i]; + } + return true; +} + +static bool GetDeviceTypeHash(char* output) +{ + const char* deviceType = GetDeviceType(); + if (deviceType == NULL) { + DMLOGE("failed to get device type from system parameter."); + return false; + } + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash(deviceType, strlen(deviceType), sha256Out) != DM_OK) { + DMLOGE("failed to generated device type sha256 hash."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + output[i] = sha256Out[i]; + } + return true; +} + +static bool GetDeviceAliasHash(char* output) +{ + char deviceAlias[DM_MAX_DEVICE_ALIAS_LEN + 1] = {0}; + int32_t retValue = GetParameter(DEVICE_ALIAS, "not exist", deviceAlias, DM_MAX_DEVICE_ALIAS_LEN); + if (retValue < 0 || strcmp((const char*)deviceAlias, "not exist") == 0) { + DMLOGE("failed to get device alias from system parameter with ret: %d.", retValue); + return false; + } + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash(deviceAlias, strlen(deviceAlias), sha256Out) != DM_OK) { + DMLOGE("failed to generated device alias sha256 hash."); + return false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + output[i] = sha256Out[i]; + } + return true; +} + +static bool GetDeviceNumber(char* output) +{ + char deviceNumber[DM_DEVICE_NUMBER_LEN + 1] = {0}; + int32_t retValue = GetParameter(DEVICE_NUMBER, "not exist", deviceNumber, DM_DEVICE_NUMBER_LEN); + if (retValue < 0 || strcmp(deviceNumber, "not exist") == 0) { + DMLOGE("failed to get device number from system parameter with ret: %d.", retValue); + return false; + } + for (int i = 0; i < DM_DEVICE_NUMBER_LEN; i++) { + output[i] = deviceNumber[i]; + } + return true; +} + +static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead, Action matchResult) +{ + size_t outLen = 0; + char outData[DISC_MAX_CUST_DATA_LEN] = {0}; + outData[outLen++] = BROADCAST_VERSION; + outData[outLen++] = sizeof(ReturnwaveHead); + if (IsHichainCredentialExist()) { + outData[outLen++] = true; + } else { + outData[outLen++] = false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + outData[outLen++] = broadcastHead->pkgNameHash[i]; + } + + size_t base64OutLen = 0; + int retValue = mbedtls_base64_encode((unsigned char *)(deviceInfo->custData), DISC_MAX_CUST_DATA_LEN, + &base64OutLen, (const unsigned char *)outData, outLen); + if (retValue != 0) { + DMLOGE("failed to get search data base64 encode type data with ret: %d.", retValue); + return ERR_DM_FAILED; + } +#ifdef MINE_HARMONY_SOFTBUS + retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, &deviceInfo); + if (retValue != SOFTBUS_OK) { + DMLOGE("failed to set discovery policy with ret: %d.", retValue); + } +#endif + DMLOGI("set discovery policy successfully with dataLen: %u.", base64OutLen); + return DM_OK; +} diff --git a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c index 82b470b7..df34f181 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c @@ -563,6 +563,11 @@ static int StopSoftbusRefreshLNN(const char *pkgName, const int subscribeId) DMLOGE("pkgName: %s and subscribeId: %d do not match.", pkgName, subscribeId); return ERR_DM_SOFTBUS_STOP_DISCOVERY_DEVICE; } + int retVaule = StopRefreshLNN(DM_PKG_NAME, subscribeId); + if (retVaule != DM_OK) { + DMLOGE("[softbus]fail to stop refreshLNN with ret: %d", retVaule); + return ERR_DM_SOFTBUS_STOP_DISCOVERY_DEVICE; + } g_discoveryCallbackMap.valid = false; DMLOGI("stop refreshLNN successfully."); return DM_OK; @@ -629,7 +634,7 @@ static int SoftbusRefreshLNN(const char *pkgName, const int subscribeId) subscribeInfo.capabilityData = NULL; subscribeInfo.dataLen = 0; subscribeInfo.subscribeId = subscribeId; - int retValue = RefreshLNN(pkgName, &subscribeInfo, &g_refreshDiscoveryCallback); + int retValue = RefreshLNN(DM_PKG_NAME, &subscribeInfo, &g_refreshDiscoveryCallback); if (retValue != SOFTBUS_OK) { DMLOGE("failed to start to refresh discovery with ret: %d.", retValue); return ERR_DM_FAILED; -- Gitee From d1f43166e8fd382534128f2a2e29c54648d33435 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Sat, 11 May 2024 14:04:55 +0800 Subject: [PATCH 2/8] =?UTF-8?q?L0=E7=BC=96=E8=AF=91=E9=97=AE=E9=A2=98?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../src/mini/mine_softbus_adapter.c | 612 ++++++++++-------- 1 file changed, 337 insertions(+), 275 deletions(-) diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c index af44f994..d78f729a 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -161,6 +161,9 @@ static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo); static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason); static void OnPublishDeviceFound(const DeviceInfo *deviceInfo); +static char *EncodeDMBroadcastData(const char *srcData); +static char *DecodeDMBroadcastData(cJSON *root, const char *srcData); + static UINT32 g_refreshDiscoverySem = 0; static UINT32 g_discoveryMapMutex = 0; static bool g_startQuickDiscoveryFlag = false; @@ -296,8 +299,7 @@ static int ParseSearchJson(const char *pkgName, const char *searchJsonStr, char cJSON_Delete(root); return ERR_DM_CJSON_GET_OBJECT; } - int findMode = object->valueint; - DMLOGI("quick search device mode is: %d.", findMode); + DMLOGI("quick search device mode is: %d.", object->valueint); switch (object->valueint) { case FIND_ALL_DEVICE: retValue = ParseSearchAllDevice(root, pkgName, output, outLen); @@ -541,29 +543,52 @@ static int ParseVertexDeviceJsonArray(const cJSON *object, const int arraySize, return DM_OK; } -// returned string, which needs to be manually release by the invoker. +// returned string, which needs to be manually cJSON_free by the invoker. char *EncodeDMBroadcastData(const char *srcData) { cJSON *root = cJSON_CreateObject(); if (root == NULL) { DMLOGE("failed to create cjson object."); - return ""; + return NULL; } if (cJSON_AddStringToObject(root, DEVICE_DM_KEY, srcData) == NULL) { DMLOGE("failed to add true to object."); cJSON_Delete(root); - return ""; + return NULL; } char *rootJsonStr = cJSON_PrintUnformatted(root); if (rootJsonStr == NULL) { DMLOGE("cJSON_PrintUnformatted failed, rootJsonStr is null."); cJSON_Delete(root); - return ""; + return NULL; } cJSON_Delete(root); return rootJsonStr; } +// returned root, which needs to be manually cJSON_Delete by the invoker. +char *DecodeDMBroadcastData(cJSON *root, const char *srcData) +{ + root = cJSON_Parse(srcData); + if (root == NULL) { + DMLOGE("root is nullptr."); + return NULL; + } + cJSON *object = cJSON_GetObjectItem(root, DEVICE_DM_KEY); + if (!cJSON_IsString(object)) { + DMLOGE("object is not string."); + cJSON_Delete(root); + return NULL; + } + char *value = cJSON_GetStringValue(object); + if (value == NULL) { + DMLOGE("get policy data is nullptr."); + cJSON_Delete(root); + return NULL; + } + return value; +} + static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *data, size_t dataLen) { size_t base64OutLen = 0; @@ -579,6 +604,8 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d DMLOGE("failed to get dm encode type data."); return ERR_DM_FAILED; } + size_t custDataLen = strlen(custData); + DMLOGI("send search broadcast info %s, dataLen: %d.", custData, custDataLen); #ifdef MINE_HARMONY_SOFTBUS SubscribeInfo subscribeInfo; @@ -589,7 +616,7 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d subscribeInfo.isWakeRemote = false, subscribeInfo.capability = DM_CAPABILITY_OSD, subscribeInfo.capabilityData = (const char*)custData; - subscribeInfo.dataLen = strlen(custData) + 1, + subscribeInfo.dataLen = custDataLen, subscribeInfo.subscribeId = subscribeId, retValue = RefreshLNN(DM_PKG_NAME, &subscribeInfo, &g_refreshMineDiscoveryCallback); cJSON_free(custData); @@ -604,246 +631,11 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d return ERR_DM_FAILED; } #endif - DMLOGI("send search broadcast info by softbus successfully with dataLen: %u, pkgName: %s.", base64OutLen, + DMLOGI("send search broadcast info by softbus successfully with dataLen: %u, pkgName: %s.", custDataLen, pkgName); return DM_OK; } -static int GetSha256Hash(const char *data, size_t len, char *output) -{ - int mbedtlsHmacType = 0; - mbedtls_md_context_t mdContext; - const mbedtls_md_info_t* mdInfo = NULL; - - mbedtls_md_init(&mdContext); - mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); - int retValue = mbedtls_md_setup(&mdContext, mdInfo, mbedtlsHmacType); - if (retValue != 0) { - DMLOGE("failed to setup mbedtls md with ret: %d.", retValue); - return ERR_DM_FAILED; - } - retValue = mbedtls_md_starts(&mdContext); - if (retValue != 0) { - DMLOGE("failed to start mbedtls md with ret: %d.", retValue); - mbedtls_md_free(&mdContext); - return ERR_DM_FAILED; - } - retValue = mbedtls_md_update(&mdContext, (const unsigned char*)data, len); - if (retValue != 0) { - DMLOGE("failed to update mbedtls md with ret: %d.", retValue); - mbedtls_md_free(&mdContext); - return ERR_DM_FAILED; - } - retValue = mbedtls_md_finish(&mdContext, output); - if (retValue != 0) { - DMLOGE("failed to finish mbedtls md with ret: %d.", retValue); - mbedtls_md_free(&mdContext); - return ERR_DM_FAILED; - } - mbedtls_md_free(&mdContext); - return DM_OK; -} - -static bool ImportPkgNameToDiscoveryMap(const char *pkgName, const int subscribeId, OnTargetFound callback) -{ - errno_t retValue = strcpy_s(g_discoveryCallbackMap.pkgName, DM_MAX_PKG_NAME_LEN, pkgName); - if (retValue != EOK) { - DMLOGE("failed to copy pkgName: %s to discovery map.", pkgName); - return false; - } - char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; - if (GetSha256Hash(pkgName, strlen(pkgName), sha256Out) != DM_OK) { - DMLOGE("failed to get send search pkgName sha256 hash."); - return false; - } - for (int i = 0; i < DM_HASH_DATA_LEN; i++) { - g_discoveryCallbackMap.pkgNameHash[i] = sha256Out[i]; - } - g_discoveryCallbackMap.subscribeId = subscribeId; - g_discoveryCallbackMap.discoveryCallback = callback; - g_discoveryCallbackMap.valid = true; - return true; -} - -static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo) -{ - if (deviceInfo == NULL) { - DMLOGE("deviceInfo is NULL."); - return; - } - size_t dataLen = strlen(deviceInfo->custData) + 1; - if (dataLen < sizeof(ReturnwaveHead)) { - DMLOGE("deviceInfo is business data lenght: %u is error.", dataLen); - return; - } - DMLOGI("softbus notify that a device was found with dataLen: %u.", dataLen); - - size_t base64OutLen = 0; - char base64Out[DISC_MAX_CUST_DATA_LEN] = {0}; - char *data = (unsigned char*)deviceInfo->custData; - int retValue = mbedtls_base64_decode((unsigned char *)base64Out, DISC_MAX_CUST_DATA_LEN, &base64OutLen, - (const unsigned char *)data, dataLen); - if (retValue != 0) { - DMLOGE("failed to get search data base64 decode data with ret: %d.", retValue); - return; - } - UINT32 osRet = LOS_MuxPend(g_discoveryMapMutex, SOFTBUS_DELAY_TICK_COUNT); - if (osRet != LOS_OK) { - DMLOGE("failed to pend discovery device mutex with ret: %u.", osRet); - return; - } - ReturnwaveHead *returnwaveHead = (ReturnwaveHead *)base64Out; - if (memcmp(g_discoveryCallbackMap.pkgNameHash, returnwaveHead->pkgNameHash, DM_HASH_DATA_LEN) == EOK) { - DMLOGI("will notify the user that a new device has been discovered."); - DmDeviceInfo dmDeviceInfo; - DeviceInfoCopyToDmDevice(&dmDeviceInfo, deviceInfo, returnwaveHead->isExistCredential); - g_discoveryCallbackMap.discoveryCallback.onDeviceFound(&dmDeviceInfo); - } - osRet = LOS_MuxPost(g_discoveryMapMutex); - if (osRet != LOS_OK) { - DMLOGE("failed to post discovery device mutex with ret: %u.", osRet); - return; - } - DMLOGI("OnDiscoveryDeviceFound callback complete."); -} - -static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason) -{ - if (reason == REFRESH_LNN_SUCCESS) { - DMLOGI("refresh discovery result successfully with refreshId: %d.", refreshId); - g_startQuickDiscoveryFlag = true; - } else { - DMLOGI("failed to refresh discovery result with refreshId: %d, reason: %d.", refreshId, (int)reason); - g_startQuickDiscoveryFlag = false; - } - UINT32 osRet = LOS_SemPost(g_refreshDiscoverySem); - if (osRet != LOS_OK) { - DMLOGE("failed to post refresh discovery device semaphore with ret: %u.", osRet); - return; - } -} - -static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInfo *deviceInfo, bool isExistCredential) -{ - (void)memset_s(dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); - errno_t retValue = strcpy_s(dmDeviceInfo->deviceId, sizeof(dmDeviceInfo->deviceId), deviceInfo->devId); - if (retValue != EOK) { - DMLOGE("failed to copy device id with ret: %d.", retValue); - } - retValue = strcpy_s(dmDeviceInfo->deviceName, sizeof(dmDeviceInfo->deviceName), deviceInfo->devName); - if (retValue != EOK) { - DMLOGE("failed to copy device name with ret: %d.", retValue); - } - dmDeviceInfo->isTrust = deviceInfo->isOnline; - dmDeviceInfo->deviceTypeId = deviceInfo->devType; -#ifdef MINE_HARMONY_SOFTBUS - const size_t arrayStartPosition = 0; - dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; -#endif - dmDeviceInfo->isLocalExistCredential = IsHichainCredentialExist(); - dmDeviceInfo->isPeerExistCredential = isExistCredential; -} - -static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) -{ - if (deviceInfo == NULL) { - DMLOGE("deviceInfo is NULL."); - return; - } - size_t custDataLen = strlen(deviceInfo->custData) + 1; - if (custDataLen >= DISC_MAX_CUST_DATA_LEN || - custDataLen < DM_SEARCH_BROADCAST_MIN_LEN) { - DMLOGE("deviceInfo data is too short with dataLen: %u", custDataLen); - return; - } - - DMLOGI("broadcast data is received with DataLen: %u", custDataLen); - UINT32 osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); - if (osRet != LOS_OK) { - DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); - return; - } - int tempValue = g_matchQueue.rear + DM_FULL_QUEUE_USELESS_LEN; - if (g_matchQueue.front != tempValue % DM_MAX_MATCH_WAIT_NUMBER) { - g_matchQueue.deviceWaitInfo[g_matchQueue.rear] = *deviceInfo; - g_matchQueue.rear = tempValue % DM_MAX_MATCH_WAIT_NUMBER; - osRet = LOS_SemPost(g_matchWaitSem); - if (osRet != LOS_OK) { - DMLOGE("failed to post match wait semaphore with ret: %u.", osRet); - } - } else { - DMLOGE("circular queue has no space to store the user match data."); - } - osRet = LOS_MuxPost(g_matchQueueMutex); - if (osRet != LOS_OK) { - DMLOGE("failed to post match queue mutex with ret: %u.", osRet); - } -} - -int CreateDealTask(void) -{ - g_matchQueue.front = 0; - g_matchQueue.rear = 0; - TSK_INIT_PARAM_S initParam; - initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)MatchSearchDealTask; - initParam.usTaskPrio = DEAL_TASK_PRIOR; - initParam.pcName = "matchDealTask"; - initParam.uwStackSize = TASK_STACK_SIZE; - UINT32 osRet = LOS_TaskCreate(&g_matchDealTaskId, &initParam); - if (osRet != LOS_OK) { - DMLOGE("failed to create match deal task with ret: %u.", osRet); - return ERR_DM_LITEOS_CREATE_TASK; - } - DMLOGI("create match deal task successfully with taskId: %u.", g_matchDealTaskId); - return DM_OK; -} - -int DeleteDealTask(void) -{ - UINT32 osRet = LOS_TaskDelete(g_matchDealTaskId); - if (osRet != LOS_OK && osRet != LOS_ERRNO_TSK_ID_INVALID) { - DMLOGE("failed to delete match deal task."); - return ERR_DM_LITEOS_DELETE_TASK; - } - g_matchDealTaskId = LOSCFG_BASE_CORE_TSK_LIMIT; - DMLOGI("delete match deal task successfully with taskId: %u.", g_matchDealTaskId); - return DM_OK; -} - -static void MatchSearchDealTask(void) -{ - DMLOGI("The match deal task has started to run."); - - while (true) { - bool matchWaitQueueFlag = false; - UINT32 osRet = LOS_SemPend(g_matchWaitSem, LOS_WAIT_FOREVER); - if (osRet != LOS_OK) { - DMLOGE("failed to block the task permanently with ret: %u.", osRet); - continue; - } - osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); - if (osRet != LOS_OK) { - DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); - continue; - } - int tempValue = g_matchQueue.front + DM_FULL_QUEUE_USELESS_LEN; - if (g_matchQueue.front != g_matchQueue.rear) { - g_matchDeviceInfo = g_matchQueue.deviceWaitInfo[g_matchQueue.front]; - g_matchQueue.front = (tempValue) % DM_MAX_MATCH_WAIT_NUMBER; - matchWaitQueueFlag = true; - } else { - DMLOGE("no device information is found in the circular queue."); - } - osRet = LOS_MuxPost(g_matchQueueMutex); - if (osRet != LOS_OK) { - DMLOGE("failed to post match wait mutex with ret: %u.", osRet); - } - if (matchWaitQueueFlag && ParseBroadcastInfo(&g_matchDeviceInfo) != DM_OK) { - DMLOGE("failed to parse broadcast info."); - } - } -} - static int ParseBroadcastInfo(DeviceInfo *deviceInfo) { char outData[DISC_MAX_CUST_DATA_LEN] = {0}; @@ -885,11 +677,18 @@ static int ParseBroadcastInfo(DeviceInfo *deviceInfo) static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLen) { + cJSON *root = NULL; + char *base64Data = DecodeDMBroadcastData(root, deviceInfo->custData); + if (root == NULL || base64Data == NULL) { + DMLOGE("get base64 data failed."); + return false; + } size_t base64OutLen = 0; - size_t dataLen = strlen(deviceInfo->custData) + 1; - char *data = (char*)deviceInfo->custData; + size_t dataLen = strlen(base64Data); + char *data = (char*)base64Data; int retValue = mbedtls_base64_decode((unsigned char *)outData, outLen, &base64OutLen, (const unsigned char *)data, dataLen); + cJSON_Delete(root); if (retValue != 0) { DMLOGE("failed to with ret: %d.", retValue); return false; @@ -910,17 +709,62 @@ static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLe return true; } -static Action MatchSearchAllDevice(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead) +static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead, Action matchResult) { - if (broadcastHead->trustFilter == 0) { - return DISCOVERY_POLICY_ALLOW_REPLY; - } - if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { - return DISCOVERY_POLICY_ALLOW_REPLY; - } else if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_NOTRUST_DEVICE)) { - return DISCOVERY_POLICY_REJECT_REPLY; - } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { - return DISCOVERY_POLICY_REJECT_REPLY; + size_t outLen = 0; + char outData[DISC_MAX_CUST_DATA_LEN] = {0}; + outData[outLen++] = BROADCAST_VERSION; + outData[outLen++] = sizeof(ReturnwaveHead); + if (IsHichainCredentialExist()) { + outData[outLen++] = true; + } else { + outData[outLen++] = false; + } + for (int i = 0; i < DM_HASH_DATA_LEN; i++) { + outData[outLen++] = broadcastHead->pkgNameHash[i]; + } + + char base64Out[DISC_MAX_CUST_DATA_LEN] = {0}; + size_t base64OutLen = 0; + int retValue = mbedtls_base64_encode((unsigned char *)base64Out, DISC_MAX_CUST_DATA_LEN, + &base64OutLen, (const unsigned char *)outData, outLen); + if (retValue != 0) { + DMLOGE("failed to get search data base64 encode type data with ret: %d.", retValue); + return ERR_DM_FAILED; + } + char *custData = EncodeDMBroadcastData(base64Out); + if (custData == NULL) { + DMLOGE("failed to get dm encode type data."); + return ERR_DM_FAILED; + } + int ret = strcpy_s(deviceInfo->custData, DISC_MAX_CUST_DATA_LEN, custData); + cJSON_free(custData); + if (ret != 0) { + DMLOGE("failed to strcpy_s with ret: %d.", retValue); + return ERR_DM_FAILED; + } +#ifdef MINE_HARMONY_SOFTBUS + retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, &deviceInfo); + if (retValue != SOFTBUS_OK) { + DMLOGE("failed to set discovery policy with ret: %d.", retValue); + return ERR_DM_FAILED; + } +#endif + DMLOGI("set discovery policy successfully with dataLen: %u.", strlen(deviceInfo->custData)); + return DM_OK; +} + +static Action MatchSearchAllDevice(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead) +{ + if (broadcastHead->trustFilter == 0) { + return DISCOVERY_POLICY_ALLOW_REPLY; + } + if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DISCOVERY_POLICY_ALLOW_REPLY; + } else if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_NOTRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DISCOVERY_POLICY_REJECT_REPLY; } else { return DISCOVERY_POLICY_ALLOW_REPLY; } @@ -1251,34 +1095,252 @@ static bool GetDeviceNumber(char* output) return true; } -static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead, Action matchResult) +static int GetSha256Hash(const char *data, size_t len, char *output) { - size_t outLen = 0; - char outData[DISC_MAX_CUST_DATA_LEN] = {0}; - outData[outLen++] = BROADCAST_VERSION; - outData[outLen++] = sizeof(ReturnwaveHead); - if (IsHichainCredentialExist()) { - outData[outLen++] = true; - } else { - outData[outLen++] = false; + int mbedtlsHmacType = 0; + mbedtls_md_context_t mdContext; + const mbedtls_md_info_t* mdInfo = NULL; + + mbedtls_md_init(&mdContext); + mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); + int retValue = mbedtls_md_setup(&mdContext, mdInfo, mbedtlsHmacType); + if (retValue != 0) { + DMLOGE("failed to setup mbedtls md with ret: %d.", retValue); + return ERR_DM_FAILED; + } + retValue = mbedtls_md_starts(&mdContext); + if (retValue != 0) { + DMLOGE("failed to start mbedtls md with ret: %d.", retValue); + mbedtls_md_free(&mdContext); + return ERR_DM_FAILED; + } + retValue = mbedtls_md_update(&mdContext, (const unsigned char*)data, len); + if (retValue != 0) { + DMLOGE("failed to update mbedtls md with ret: %d.", retValue); + mbedtls_md_free(&mdContext); + return ERR_DM_FAILED; + } + retValue = mbedtls_md_finish(&mdContext, output); + if (retValue != 0) { + DMLOGE("failed to finish mbedtls md with ret: %d.", retValue); + mbedtls_md_free(&mdContext); + return ERR_DM_FAILED; + } + mbedtls_md_free(&mdContext); + return DM_OK; +} + +static bool ImportPkgNameToDiscoveryMap(const char *pkgName, const int subscribeId, OnTargetFound callback) +{ + errno_t retValue = strcpy_s(g_discoveryCallbackMap.pkgName, DM_MAX_PKG_NAME_LEN, pkgName); + if (retValue != EOK) { + DMLOGE("failed to copy pkgName: %s to discovery map.", pkgName); + return false; + } + char sha256Out[DM_SHA256_OUT_DATA_LEN] = {0}; + if (GetSha256Hash(pkgName, strlen(pkgName), sha256Out) != DM_OK) { + DMLOGE("failed to get send search pkgName sha256 hash."); + return false; } for (int i = 0; i < DM_HASH_DATA_LEN; i++) { - outData[outLen++] = broadcastHead->pkgNameHash[i]; + g_discoveryCallbackMap.pkgNameHash[i] = sha256Out[i]; + } + g_discoveryCallbackMap.subscribeId = subscribeId; + g_discoveryCallbackMap.discoveryCallback = callback; + g_discoveryCallbackMap.valid = true; + return true; +} + +int CreateDealTask(void) +{ + g_matchQueue.front = 0; + g_matchQueue.rear = 0; + TSK_INIT_PARAM_S initParam; + initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)MatchSearchDealTask; + initParam.usTaskPrio = DEAL_TASK_PRIOR; + initParam.pcName = "matchDealTask"; + initParam.uwStackSize = TASK_STACK_SIZE; + UINT32 osRet = LOS_TaskCreate(&g_matchDealTaskId, &initParam); + if (osRet != LOS_OK) { + DMLOGE("failed to create match deal task with ret: %u.", osRet); + return ERR_DM_LITEOS_CREATE_TASK; + } + DMLOGI("create match deal task successfully with taskId: %u.", g_matchDealTaskId); + return DM_OK; +} + +int DeleteDealTask(void) +{ + UINT32 osRet = LOS_TaskDelete(g_matchDealTaskId); + if (osRet != LOS_OK && osRet != LOS_ERRNO_TSK_ID_INVALID) { + DMLOGE("failed to delete match deal task."); + return ERR_DM_LITEOS_DELETE_TASK; + } + g_matchDealTaskId = LOSCFG_BASE_CORE_TSK_LIMIT; + DMLOGI("delete match deal task successfully with taskId: %u.", g_matchDealTaskId); + return DM_OK; +} + +static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo) +{ + if (deviceInfo == NULL) { + DMLOGE("deviceInfo is NULL."); + return; } + cJSON *root = NULL; + char *base64Data = DecodeDMBroadcastData(root, deviceInfo->custData); + if (root == NULL || base64Data == NULL) { + DMLOGE("get base64 data failed."); + return; + } + size_t dataLen = strlen(base64Data); + if (dataLen < sizeof(ReturnwaveHead)) { + DMLOGE("deviceInfo is business data lenght: %u is error.", dataLen); + cJSON_Delete(root); + return; + } + DMLOGI("softbus notify that a device was found with dataLen: %u.", dataLen); size_t base64OutLen = 0; - int retValue = mbedtls_base64_encode((unsigned char *)(deviceInfo->custData), DISC_MAX_CUST_DATA_LEN, - &base64OutLen, (const unsigned char *)outData, outLen); + char base64Out[DISC_MAX_CUST_DATA_LEN] = {0}; + char *data = (unsigned char*)base64Data; + int retValue = mbedtls_base64_decode((unsigned char *)base64Out, DISC_MAX_CUST_DATA_LEN, &base64OutLen, + (const unsigned char *)data, dataLen); + cJSON_Delete(root); if (retValue != 0) { - DMLOGE("failed to get search data base64 encode type data with ret: %d.", retValue); - return ERR_DM_FAILED; + DMLOGE("failed to get search data base64 decode data with ret: %d.", retValue); + return; } -#ifdef MINE_HARMONY_SOFTBUS - retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, &deviceInfo); - if (retValue != SOFTBUS_OK) { - DMLOGE("failed to set discovery policy with ret: %d.", retValue); + UINT32 osRet = LOS_MuxPend(g_discoveryMapMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to pend discovery device mutex with ret: %u.", osRet); + return; + } + ReturnwaveHead *returnwaveHead = (ReturnwaveHead *)base64Out; + if (memcmp(g_discoveryCallbackMap.pkgNameHash, returnwaveHead->pkgNameHash, DM_HASH_DATA_LEN) == EOK) { + DMLOGI("will notify the user that a new device has been discovered."); + DmDeviceInfo dmDeviceInfo; + DeviceInfoCopyToDmDevice(&dmDeviceInfo, deviceInfo, returnwaveHead->isExistCredential); + g_discoveryCallbackMap.discoveryCallback.onDeviceFound(&dmDeviceInfo); + } + osRet = LOS_MuxPost(g_discoveryMapMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post discovery device mutex with ret: %u.", osRet); + return; } + DMLOGI("OnDiscoveryDeviceFound callback complete."); +} + +static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason) +{ + if (reason == REFRESH_LNN_SUCCESS) { + DMLOGI("refresh discovery result successfully with refreshId: %d.", refreshId); + g_startQuickDiscoveryFlag = true; + } else { + DMLOGI("failed to refresh discovery result with refreshId: %d, reason: %d.", refreshId, (int)reason); + g_startQuickDiscoveryFlag = false; + } + UINT32 osRet = LOS_SemPost(g_refreshDiscoverySem); + if (osRet != LOS_OK) { + DMLOGE("failed to post refresh discovery device semaphore with ret: %u.", osRet); + return; + } +} + +static void MatchSearchDealTask(void) +{ + DMLOGI("The match deal task has started to run."); + + while (true) { + bool matchWaitQueueFlag = false; + UINT32 osRet = LOS_SemPend(g_matchWaitSem, LOS_WAIT_FOREVER); + if (osRet != LOS_OK) { + DMLOGE("failed to block the task permanently with ret: %u.", osRet); + continue; + } + osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); + continue; + } + int tempValue = g_matchQueue.front + DM_FULL_QUEUE_USELESS_LEN; + if (g_matchQueue.front != g_matchQueue.rear) { + g_matchDeviceInfo = g_matchQueue.deviceWaitInfo[g_matchQueue.front]; + g_matchQueue.front = (tempValue) % DM_MAX_MATCH_WAIT_NUMBER; + matchWaitQueueFlag = true; + } else { + DMLOGE("no device information is found in the circular queue."); + } + osRet = LOS_MuxPost(g_matchQueueMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post match wait mutex with ret: %u.", osRet); + } + if (matchWaitQueueFlag && ParseBroadcastInfo(&g_matchDeviceInfo) != DM_OK) { + DMLOGE("failed to parse broadcast info."); + } + } +} + +static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) +{ + if (deviceInfo == NULL) { + DMLOGE("deviceInfo is NULL."); + return; + } + cJSON *root = NULL; + char *base64Data = DecodeDMBroadcastData(root, deviceInfo->custData); + if (root == NULL || base64Data == NULL) { + DMLOGE("get base64 data failed."); + return; + } + size_t custDataLen = strlen(base64Data); + cJSON_Delete(root); + if (custDataLen >= DISC_MAX_CUST_DATA_LEN || + custDataLen < DM_SEARCH_BROADCAST_MIN_LEN) { + DMLOGE("deviceInfo data is too short with dataLen: %u", custDataLen); + return; + } + + DMLOGI("broadcast data is received with DataLen: %u", custDataLen); + UINT32 osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); + if (osRet != LOS_OK) { + DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); + return; + } + int tempValue = g_matchQueue.rear + DM_FULL_QUEUE_USELESS_LEN; + if (g_matchQueue.front != tempValue % DM_MAX_MATCH_WAIT_NUMBER) { + g_matchQueue.deviceWaitInfo[g_matchQueue.rear] = *deviceInfo; + g_matchQueue.rear = tempValue % DM_MAX_MATCH_WAIT_NUMBER; + osRet = LOS_SemPost(g_matchWaitSem); + if (osRet != LOS_OK) { + DMLOGE("failed to post match wait semaphore with ret: %u.", osRet); + } + } else { + DMLOGE("circular queue has no space to store the user match data."); + } + osRet = LOS_MuxPost(g_matchQueueMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post match queue mutex with ret: %u.", osRet); + } +} + +static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInfo *deviceInfo, bool isExistCredential) +{ + (void)memset_s(dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); + errno_t retValue = strcpy_s(dmDeviceInfo->deviceId, sizeof(dmDeviceInfo->deviceId), deviceInfo->devId); + if (retValue != EOK) { + DMLOGE("failed to copy device id with ret: %d.", retValue); + } + retValue = strcpy_s(dmDeviceInfo->deviceName, sizeof(dmDeviceInfo->deviceName), deviceInfo->devName); + if (retValue != EOK) { + DMLOGE("failed to copy device name with ret: %d.", retValue); + } + dmDeviceInfo->isTrust = deviceInfo->isOnline; + dmDeviceInfo->deviceTypeId = deviceInfo->devType; +#ifdef MINE_HARMONY_SOFTBUS + const size_t arrayStartPosition = 0; + dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; #endif - DMLOGI("set discovery policy successfully with dataLen: %u.", base64OutLen); - return DM_OK; + dmDeviceInfo->isLocalExistCredential = IsHichainCredentialExist(); + dmDeviceInfo->isPeerExistCredential = isExistCredential; } -- Gitee From a464d323b613eaf3df2da137378d170bf45d9c95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Sat, 11 May 2024 17:18:05 +0800 Subject: [PATCH 3/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=95=B0=E6=8D=AE?= =?UTF-8?q?=E5=A4=84=E7=90=86=E6=96=B9=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../src/mini/mine_softbus_adapter.c | 155 +++++------------- 1 file changed, 44 insertions(+), 111 deletions(-) diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c index d78f729a..a03d0151 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -70,6 +70,7 @@ static const char DEVICE_ALIAS_NUMBER = 1; // device alias matching type static const UINT16 DEAL_TASK_PRIOR = 13; // priority of a timer task static const UINT32 TASK_STACK_SIZE = 10240; // stack size of the networking task +static const UINT32 LIC_LITEOS_M_STACK_SIZE = 8192; static const int DM_MAX_SEARCH_JSON_LEN = 3072; @@ -155,23 +156,20 @@ static Action MatchSearchScopeDevice(DeviceInfo *deviceInfo, const char *inData, const DevicePolicyInfo *devicePolicyInfo, const BroadcastHead *broadcastHead); static Action MatchSearchVertexDevice(DeviceInfo *deviceInfo, const char *inData, const DevicePolicyInfo *devicePolicyInfo, const BroadcastHead *broadcastHead); -static void MatchSearchDealTask(void); static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo); static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason); -static void OnPublishDeviceFound(const DeviceInfo *deviceInfo); static char *EncodeDMBroadcastData(const char *srcData); -static char *DecodeDMBroadcastData(cJSON *root, const char *srcData); +static bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t destLen); + +static void MatchDealTask(void *param); +static void OnPublishDeviceFound(const DeviceInfo *deviceInfo); static UINT32 g_refreshDiscoverySem = 0; static UINT32 g_discoveryMapMutex = 0; static bool g_startQuickDiscoveryFlag = false; -static UINT32 g_matchDealTaskId = 0; static UINT32 g_matchQueueMutex = 0; -static UINT32 g_matchWaitSem = 0; -static UINT32 g_publishServiceSem = 0; -static DeviceInfo g_matchDeviceInfo = {0}; static struct { int subscribeId; @@ -181,12 +179,6 @@ static struct { bool valid; } g_discoveryCallbackMap; -static struct { - int rear; - int front; - DeviceInfo deviceWaitInfo[DM_MAX_MATCH_WAIT_NUMBER]; -} g_matchQueue; - #ifdef MINE_HARMONY_SOFTBUS IRefreshCallback g_refreshMineDiscoveryCallback = { .OnDeviceFound = OnDiscoveryDeviceFound, @@ -566,27 +558,31 @@ char *EncodeDMBroadcastData(const char *srcData) return rootJsonStr; } -// returned root, which needs to be manually cJSON_Delete by the invoker. -char *DecodeDMBroadcastData(cJSON *root, const char *srcData) +bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t destLen) { - root = cJSON_Parse(srcData); + cJSON *root = cJSON_Parse(srcData); if (root == NULL) { DMLOGE("root is nullptr."); - return NULL; + return false; } cJSON *object = cJSON_GetObjectItem(root, DEVICE_DM_KEY); if (!cJSON_IsString(object)) { DMLOGE("object is not string."); cJSON_Delete(root); - return NULL; + return false; } char *value = cJSON_GetStringValue(object); if (value == NULL) { DMLOGE("get policy data is nullptr."); cJSON_Delete(root); - return NULL; + return false; } - return value; + if (strcpy_s(destData, destLen, value) != 0) { + DMLOGE("strcpy_s is failed."); + cJSON_Delete(root); + return false; + } + return true; } static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *data, size_t dataLen) @@ -677,10 +673,10 @@ static int ParseBroadcastInfo(DeviceInfo *deviceInfo) static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLen) { - cJSON *root = NULL; - char *base64Data = DecodeDMBroadcastData(root, deviceInfo->custData); - if (root == NULL || base64Data == NULL) { - DMLOGE("get base64 data failed."); + char base64Data[DISC_MAX_CUST_DATA_LEN] = {0}; + bool bRet = DecodeDMBroadcastData(deviceInfo->custData, base64Data, DISC_MAX_CUST_DATA_LEN); + if (!bRet) { + DMLOGE("decodeDM data failed."); return false; } size_t base64OutLen = 0; @@ -688,7 +684,6 @@ static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLe char *data = (char*)base64Data; int retValue = mbedtls_base64_decode((unsigned char *)outData, outLen, &base64OutLen, (const unsigned char *)data, dataLen); - cJSON_Delete(root); if (retValue != 0) { DMLOGE("failed to with ret: %d.", retValue); return false; @@ -1151,52 +1146,21 @@ static bool ImportPkgNameToDiscoveryMap(const char *pkgName, const int subscribe return true; } -int CreateDealTask(void) -{ - g_matchQueue.front = 0; - g_matchQueue.rear = 0; - TSK_INIT_PARAM_S initParam; - initParam.pfnTaskEntry = (TSK_ENTRY_FUNC)MatchSearchDealTask; - initParam.usTaskPrio = DEAL_TASK_PRIOR; - initParam.pcName = "matchDealTask"; - initParam.uwStackSize = TASK_STACK_SIZE; - UINT32 osRet = LOS_TaskCreate(&g_matchDealTaskId, &initParam); - if (osRet != LOS_OK) { - DMLOGE("failed to create match deal task with ret: %u.", osRet); - return ERR_DM_LITEOS_CREATE_TASK; - } - DMLOGI("create match deal task successfully with taskId: %u.", g_matchDealTaskId); - return DM_OK; -} - -int DeleteDealTask(void) -{ - UINT32 osRet = LOS_TaskDelete(g_matchDealTaskId); - if (osRet != LOS_OK && osRet != LOS_ERRNO_TSK_ID_INVALID) { - DMLOGE("failed to delete match deal task."); - return ERR_DM_LITEOS_DELETE_TASK; - } - g_matchDealTaskId = LOSCFG_BASE_CORE_TSK_LIMIT; - DMLOGI("delete match deal task successfully with taskId: %u.", g_matchDealTaskId); - return DM_OK; -} - static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo) { if (deviceInfo == NULL) { DMLOGE("deviceInfo is NULL."); return; } - cJSON *root = NULL; - char *base64Data = DecodeDMBroadcastData(root, deviceInfo->custData); - if (root == NULL || base64Data == NULL) { - DMLOGE("get base64 data failed."); + char base64Data[DISC_MAX_CUST_DATA_LEN] = {0}; + bool bRet = DecodeDMBroadcastData(deviceInfo->custData, base64Data, DISC_MAX_CUST_DATA_LEN); + if (!bRet) { + DMLOGE("decodeDM data failed."); return; } size_t dataLen = strlen(base64Data); if (dataLen < sizeof(ReturnwaveHead)) { DMLOGE("deviceInfo is business data lenght: %u is error.", dataLen); - cJSON_Delete(root); return; } DMLOGI("softbus notify that a device was found with dataLen: %u.", dataLen); @@ -1206,7 +1170,6 @@ static void OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo) char *data = (unsigned char*)base64Data; int retValue = mbedtls_base64_decode((unsigned char *)base64Out, DISC_MAX_CUST_DATA_LEN, &base64OutLen, (const unsigned char *)data, dataLen); - cJSON_Delete(root); if (retValue != 0) { DMLOGE("failed to get search data base64 decode data with ret: %d.", retValue); return; @@ -1247,54 +1210,19 @@ static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason) } } -static void MatchSearchDealTask(void) -{ - DMLOGI("The match deal task has started to run."); - - while (true) { - bool matchWaitQueueFlag = false; - UINT32 osRet = LOS_SemPend(g_matchWaitSem, LOS_WAIT_FOREVER); - if (osRet != LOS_OK) { - DMLOGE("failed to block the task permanently with ret: %u.", osRet); - continue; - } - osRet = LOS_MuxPend(g_matchQueueMutex, SOFTBUS_DELAY_TICK_COUNT); - if (osRet != LOS_OK) { - DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); - continue; - } - int tempValue = g_matchQueue.front + DM_FULL_QUEUE_USELESS_LEN; - if (g_matchQueue.front != g_matchQueue.rear) { - g_matchDeviceInfo = g_matchQueue.deviceWaitInfo[g_matchQueue.front]; - g_matchQueue.front = (tempValue) % DM_MAX_MATCH_WAIT_NUMBER; - matchWaitQueueFlag = true; - } else { - DMLOGE("no device information is found in the circular queue."); - } - osRet = LOS_MuxPost(g_matchQueueMutex); - if (osRet != LOS_OK) { - DMLOGE("failed to post match wait mutex with ret: %u.", osRet); - } - if (matchWaitQueueFlag && ParseBroadcastInfo(&g_matchDeviceInfo) != DM_OK) { - DMLOGE("failed to parse broadcast info."); - } - } -} - -static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) +void OnPublishDeviceFound(const DeviceInfo *deviceInfo) { if (deviceInfo == NULL) { DMLOGE("deviceInfo is NULL."); return; } - cJSON *root = NULL; - char *base64Data = DecodeDMBroadcastData(root, deviceInfo->custData); - if (root == NULL || base64Data == NULL) { - DMLOGE("get base64 data failed."); + char base64Data[DISC_MAX_CUST_DATA_LEN] = {0}; + bool bRet = DecodeDMBroadcastData(deviceInfo->custData, base64Data, DISC_MAX_CUST_DATA_LEN); + if (!bRet) { + DMLOGE("decodeDM data failed."); return; } size_t custDataLen = strlen(base64Data); - cJSON_Delete(root); if (custDataLen >= DISC_MAX_CUST_DATA_LEN || custDataLen < DM_SEARCH_BROADCAST_MIN_LEN) { DMLOGE("deviceInfo data is too short with dataLen: %u", custDataLen); @@ -1307,16 +1235,13 @@ static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) DMLOGE("failed to pend match queue mutex with ret: %u.", osRet); return; } - int tempValue = g_matchQueue.rear + DM_FULL_QUEUE_USELESS_LEN; - if (g_matchQueue.front != tempValue % DM_MAX_MATCH_WAIT_NUMBER) { - g_matchQueue.deviceWaitInfo[g_matchQueue.rear] = *deviceInfo; - g_matchQueue.rear = tempValue % DM_MAX_MATCH_WAIT_NUMBER; - osRet = LOS_SemPost(g_matchWaitSem); - if (osRet != LOS_OK) { - DMLOGE("failed to post match wait semaphore with ret: %u.", osRet); - } - } else { - DMLOGE("circular queue has no space to store the user match data."); + osThreadAttr_t attr = { 0 }; + attr.stack_size = LIC_LITEOS_M_STACK_SIZE; + attr.priority = osPriorityNormal; + attr.name = "DeviceManagerTask"; + osThreadId_t *taskId = osThreadNew((osThreadFunc_t)MatchDealTask, (void *)deviceInfo, &attr); + if (taskId == NULL) { + DMLOGE("osThreadNew fail."); } osRet = LOS_MuxPost(g_matchQueueMutex); if (osRet != LOS_OK) { @@ -1324,6 +1249,14 @@ static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) } } +void MatchDealTask(void *param) +{ + DeviceInfo deviceInfo = *((DeviceInfo *)param); + if (ParseBroadcastInfo(&deviceInfo) != DM_OK) { + DMLOGE("failed to parse broadcast info."); + } +} + static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInfo *deviceInfo, bool isExistCredential) { (void)memset_s(dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); -- Gitee From 5b34596447a19b6fe107949b3b9924164c50f539 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Mon, 13 May 2024 15:30:46 +0800 Subject: [PATCH 4/8] =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=AE=8F=E9=9A=94?= =?UTF-8?q?=E7=A6=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../include/mini/device_manager_impl_lite_m.h | 4 --- .../src/mini/device_manager_impl_lite_m.c | 4 --- .../src/mini/mine_softbus_adapter.c | 13 +++------ .../native_cpp/src/mini/softbus_adapter.c | 28 +------------------ 4 files changed, 5 insertions(+), 44 deletions(-) diff --git a/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h b/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h index bedde731..df62428c 100644 --- a/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h +++ b/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h @@ -19,9 +19,7 @@ #include #include "device_manager_common.h" -#ifdef MINE_HARMONY_SOFTBUS #include "softbus_common.h" -#endif #ifdef __cplusplus extern "C" { @@ -100,9 +98,7 @@ typedef struct { char networkId[DM_MAX_DEVICE_NETWORKID_LEN + 1]; char deviceName[DM_MAX_DEVICE_NAME_LEN + 1]; unsigned int deviceTypeId; -#ifdef MINE_HARMONY_SOFTBUS ConnectionAddr connectAddr; -#endif int range; int credible; bool isTrust; diff --git a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c index 9fa64025..ed6d949f 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c +++ b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c @@ -41,13 +41,11 @@ int InitDeviceManager(void) return DM_OK; } int retValue = ERR_DM_FAILED; -#ifdef MINE_HARMONY_SOFTBUS retValue = InitSoftbusModle(); if (retValue != DM_OK) { DMLOGE("failed to init softbus with ret: %d.", retValue); return retValue; } -#endif retValue = PublishDeviceDiscovery(true); if (retValue != DM_OK) { DMLOGE("failed to en with ret: %d.", retValue); @@ -75,9 +73,7 @@ int UnInitDeviceManager(void) return DM_OK; } PublishDeviceDiscovery(false); -#ifdef MINE_HARMONY_SOFTBUS UnInitSoftbusModle(); -#endif UnInitHichainModle(); g_deviceManagerInitFlag = false; return DM_OK; diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c index a03d0151..a744de34 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -179,14 +179,12 @@ static struct { bool valid; } g_discoveryCallbackMap; -#ifdef MINE_HARMONY_SOFTBUS IRefreshCallback g_refreshMineDiscoveryCallback = { .OnDeviceFound = OnDiscoveryDeviceFound, .OnDiscoverResult = OnRefreshDiscoveryResult }; -#endif -#ifdef MINE_HARMONY_SOFTBUS +#ifdef MINE_HARMONY_POLICY static IDiscoveryPolicyCallback publishLNNCallback_ = { .PolicyReport = OnPublishDeviceFound }; @@ -194,7 +192,7 @@ static IDiscoveryPolicyCallback publishLNNCallback_ = { int PublishDeviceDiscovery(bool enable) { -#ifdef MINE_HARMONY_SOFTBUS +#ifdef MINE_HARMONY_POLICY int retValue = EnableDiscoveryPolicy(DM_PKG_NAME, DM_CAPABILITY_OSD, enable, &publishLNNCallback_); if (retValue != SOFTBUS_OK) { DMLOGE("[softbus]failed to call softbus EnableDiscoveryPolicy function with ret: %d.", retValue); @@ -582,6 +580,7 @@ bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t destLen) cJSON_Delete(root); return false; } + cJSON_Delete(root); return true; } @@ -603,7 +602,6 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d size_t custDataLen = strlen(custData); DMLOGI("send search broadcast info %s, dataLen: %d.", custData, custDataLen); -#ifdef MINE_HARMONY_SOFTBUS SubscribeInfo subscribeInfo; subscribeInfo.mode = DISCOVER_MODE_ACTIVE, subscribeInfo.medium = AUTO, @@ -626,7 +624,6 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d DMLOGE("failed to refresh quick discovery with ret: %u.", osRet); return ERR_DM_FAILED; } -#endif DMLOGI("send search broadcast info by softbus successfully with dataLen: %u, pkgName: %s.", custDataLen, pkgName); return DM_OK; @@ -738,7 +735,7 @@ static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcast DMLOGE("failed to strcpy_s with ret: %d.", retValue); return ERR_DM_FAILED; } -#ifdef MINE_HARMONY_SOFTBUS +#ifdef MINE_HARMONY_POLICY retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, &deviceInfo); if (retValue != SOFTBUS_OK) { DMLOGE("failed to set discovery policy with ret: %d.", retValue); @@ -1270,10 +1267,8 @@ static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInf } dmDeviceInfo->isTrust = deviceInfo->isOnline; dmDeviceInfo->deviceTypeId = deviceInfo->devType; -#ifdef MINE_HARMONY_SOFTBUS const size_t arrayStartPosition = 0; dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; -#endif dmDeviceInfo->isLocalExistCredential = IsHichainCredentialExist(); dmDeviceInfo->isPeerExistCredential = isExistCredential; } diff --git a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c index df34f181..f519051e 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c @@ -241,7 +241,7 @@ static struct { bool valid; } g_devIdMap[DM_MAX_DEVICE_SIZE]; -#ifdef MINE_HARMONY_SOFTBUS + IPublishCb g_publishLNNCallback = { .OnPublishResult = OnPublishLNNResult }; @@ -252,7 +252,6 @@ INodeStateCb g_softbusStatusChangeCb = { .onNodeOffline = OnSoftbusDeviceOffline, .onNodeBasicInfoChanged = NULL }; - IRefreshCallback g_refreshDiscoveryCallback = { .OnDeviceFound = OnDiscoveryDeviceFound, .OnDiscoverResult = OnRefreshDiscoveryResult @@ -268,7 +267,6 @@ ISessionListener g_sessionListener = { OnJoinLNNResult g_joinLNNResult = OnJoinLNNCallback; OnLeaveLNNResult g_leaveLNNResult = OnLeaveLNNCallback; -#endif int InitSoftbusModle(void) { @@ -283,7 +281,6 @@ int InitSoftbusModle(void) } do { -#ifdef MINE_HARMONY_SOFTBUS InitSoftBusServer(); DMLOGI("Softbus adapter create session session server start."); int32_t ret = CreateSessionServer(DM_PKG_NAME, DM_SESSION_NAME, &g_sessionListener); @@ -298,7 +295,6 @@ int InitSoftbusModle(void) retValue = ERR_DM_SOFTBUS_REG_STATE_CALLBACK; break; } -#endif if (CreateSoftbusSemaphoreAndMutex() != DM_OK) { DMLOGE("failed to create mutex and semaphore."); retValue = ERR_DM_LITEOS_CREATE_MUTEX_OR_SEM; @@ -318,13 +314,11 @@ int InitSoftbusModle(void) int UnInitSoftbusModle(void) { int returnResult = DM_OK; -#ifdef MINE_HARMONY_SOFTBUS int retValue = UnregNodeDeviceStateCb(&g_softbusStatusChangeCb); if (retValue != SOFTBUS_OK) { DMLOGE("failed to unregister device state callback with ret: %d.", retValue); returnResult = ERR_DM_SOFTBUS_UNREG_STATE_CALLBACK; } -#endif if (DeleteSoftbusSemaphoreAndMutex() != DM_OK) { DMLOGE("failed to delete semaphore."); returnResult = ERR_DM_LITEOS_DELETE_MUTEX_OR_SEM; @@ -412,7 +406,6 @@ int GetSoftbusTrustedDeviceList(const char *pkgName, DmDeviceBasicInfo *deviceLi DMLOGE("input point is NULL."); return ERR_DM_INPUT_INVALID_VALUE; } -#ifdef MINE_HARMONY_SOFTBUS NodeBasicInfo *nodeInfo = NULL; int retValue = GetAllNodeDeviceInfo(DM_PKG_NAME, &nodeInfo, trustListLen); if (retValue != SOFTBUS_OK || *trustListLen < 0) { @@ -425,7 +418,6 @@ int GetSoftbusTrustedDeviceList(const char *pkgName, DmDeviceBasicInfo *deviceLi NodeBasicInfoCopyToDmDevice(&deviceList[i], &nodeInfo[i]); } FreeNodeInfo(nodeInfo); -#endif DMLOGI("get trusted device with trustDeviceCount: %d.", *trustListLen); return DM_OK; } @@ -623,7 +615,6 @@ static int ParseDiscoverFilterOption(const char *filterOption) static int SoftbusRefreshLNN(const char *pkgName, const int subscribeId) { -#ifdef MINE_HARMONY_SOFTBUS SubscribeInfo subscribeInfo; subscribeInfo.mode = DISCOVER_MODE_ACTIVE; subscribeInfo.medium = AUTO; @@ -639,7 +630,6 @@ static int SoftbusRefreshLNN(const char *pkgName, const int subscribeId) DMLOGE("failed to start to refresh discovery with ret: %d.", retValue); return ERR_DM_FAILED; } -#endif DMLOGI("softbus RefreshLNN successfully."); return DM_OK; } @@ -800,9 +790,7 @@ static bool ImportDeviceToAddrMap(const DmDeviceInfo *deviceInfo) return false; } g_deviceIdAddrMap[i].valid = true; -#ifdef MINE_HARMONY_SOFTBUS g_deviceIdAddrMap[i].connectAddr = deviceInfo->connectAddr; -#endif return true; } DMLOGE("addr map not memory for a new deviceid."); @@ -915,7 +903,6 @@ int StartSoftbusPublish(const char *pkgName, OnAdvertisingResult cb) DMLOGE("pkgName is invalid."); return ERR_DM_INPUT_INVALID_VALUE; } -#ifdef MINE_HARMONY_SOFTBUS PublishInfo publishInfo; publishInfo.publishId = DEVICEMANAGER_SA_ID; publishInfo.mode = DISCOVER_MODE_ACTIVE; @@ -929,7 +916,6 @@ int StartSoftbusPublish(const char *pkgName, OnAdvertisingResult cb) DMLOGE("failed to call softbus publishLNN function with ret: %d.", retValue); return ERR_DM_SOFTBUS_PUBLISH_LNN; } -#endif g_publishLNNFlag = true; if (!ImportPkgNameToAdvertisingMap(pkgName, cb)) { DMLOGE("failed to import pkgName to advertising map."); @@ -950,13 +936,11 @@ int StopSoftbusPublish(const char *pkgName) DMLOGE("pkgName is invalid."); return ERR_DM_INPUT_INVALID_VALUE; } -#ifdef MINE_HARMONY_SOFTBUS int retValue = StopPublishLNN(pkgName, DEVICEMANAGER_SA_ID); if (retValue != SOFTBUS_OK) { DMLOGE("failed to call stop softbus publishLNN function with ret: %d.", retValue); return ERR_DM_SOFTBUS_STOP_PUBLISH_LNN; } -#endif g_publishLNNFlag = false; g_advertisingCallbackMap.valid = false; DMLOGI("StopSoftbusPublish end."); @@ -1045,9 +1029,7 @@ static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInf dmDeviceInfo->credible = deviceInfo->isOnline; dmDeviceInfo->deviceTypeId = deviceInfo->devType; dmDeviceInfo->range = deviceInfo->range; -#ifdef MINE_HARMONY_SOFTBUS dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; -#endif int ret = GetAuthFormByDeviceId(dmDeviceInfo->deviceId, dmDeviceInfo->authForm); if (ret != DM_OK) { DMLOGE("failed to get authForm from hichain, ret: %d.", ret); @@ -1231,7 +1213,6 @@ static char* CreateRespNegotiateMsg(const int bindType) static int OnSessionOpened(int sessionId, int result) { -#ifdef MINE_HARMONY_SOFTBUS if (result != SOFTBUS_OK) { DMLOGE("open auth session failed, ret: %d.", result); CloseSession(sessionId); @@ -1251,7 +1232,6 @@ static int OnSessionOpened(int sessionId, int result) return ERR_DM_FAILED; } cJSON_free(msg); -#endif return DM_OK; } @@ -1313,13 +1293,11 @@ static void ProcessSinkMsg(const char *data, unsigned int dataLen) DMLOGE("failed to create response negotiate message."); return; } -#ifdef MINE_HARMONY_SOFTBUS if (SendBytes(g_sessionId, retStr, strlen(retStr)) != SOFTBUS_OK) { DMLOGE("send bytes failed, cmd: %d.", MSG_NEGOTIATE_RESP); cJSON_free(retStr); return; } -#endif cJSON_free(retStr); } @@ -1368,10 +1346,8 @@ static void ProcessSourceMsg(const char *data, unsigned int dataLen) DMLOGE("remote client no credential or not support bind type."); return; } -#ifdef MINE_HARMONY_SOFTBUS JoinLNN(DM_PKG_NAME, &g_bindAddr, g_joinLNNResult); CloseSession(g_sessionId); -#endif UINT32 osRet = LOS_SemPost(g_bindSem); if (osRet != LOS_OK) { DMLOGE("failed to post bind sem with ret: %u.", osRet); @@ -1400,9 +1376,7 @@ int SoftbusUnBindTarget(const char *pkgName, const char *networkId) DMLOGE("not meet the condition with network id len: %u.", len); return ERR_DM_INPUT_INVALID_VALUE; } -#ifdef MINE_HARMONY_SOFTBUS LeaveLNN(DM_PKG_NAME, networkId, g_leaveLNNResult); -#endif DMLOGI("SoftbusUnBindTarget stop."); return DM_OK; } \ No newline at end of file -- Gitee From fd58fb7dbc2ee2fb03f0b9a326ccbb9f58b51b4a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Mon, 13 May 2024 16:22:46 +0800 Subject: [PATCH 5/8] =?UTF-8?q?=E5=88=A0=E9=99=A4=E8=B0=83=E8=AF=95?= =?UTF-8?q?=E6=97=A5=E5=BF=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c | 1 - 1 file changed, 1 deletion(-) diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c index a744de34..4a076551 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -600,7 +600,6 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d return ERR_DM_FAILED; } size_t custDataLen = strlen(custData); - DMLOGI("send search broadcast info %s, dataLen: %d.", custData, custDataLen); SubscribeInfo subscribeInfo; subscribeInfo.mode = DISCOVER_MODE_ACTIVE, -- Gitee From 8bff7efe1e0ad3f2e6b1a6cc8d0a5f85942e4024 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Tue, 14 May 2024 09:28:48 +0800 Subject: [PATCH 6/8] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=8F=91=E7=8E=B0?= =?UTF-8?q?=E6=9D=A1=E4=BB=B6=E6=8E=A7=E5=88=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../native_cpp/include/mini/mine_softbus_adapter.h | 1 + .../native_cpp/src/mini/device_manager_impl_lite_m.c | 6 +++++- .../inner_kits/native_cpp/src/mini/mine_softbus_adapter.c | 5 +++++ 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h b/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h index e819afcf..9a44a1e9 100644 --- a/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h +++ b/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h @@ -26,6 +26,7 @@ extern "C" { int StartMineSoftbusQuickDiscovery(const char *pkgName, const int subscribeId, const char *searchJson, OnTargetFound callback); int PublishDeviceDiscovery(bool enable); +void SetStartDiscoveyVaild(); #ifdef __cplusplus } diff --git a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c index ed6d949f..8a7da593 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c +++ b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c @@ -214,7 +214,11 @@ int StopDiscovering(const char *pkgName, const int subscribeId) DMLOGE("device manager module is not initialized."); return ERR_DM_NO_INIT; } - return StopSoftbusDiscovery(pkgName, subscribeId); + int ret = StopSoftbusDiscovery(pkgName, subscribeId); + if (ret == DM_OK) { + SetStartDiscoveyVaild(); + } + return ret; } int BindTarget(const char *pkgName, const char *deviceId, const char *bindParam, OnBindResult cb) diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c index 4a076551..23f6f10c 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -1206,6 +1206,11 @@ static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason) } } +void SetStartDiscoveyVaild() +{ + g_discoveryCallbackMap.valid = false; +} + void OnPublishDeviceFound(const DeviceInfo *deviceInfo) { if (deviceInfo == NULL) { -- Gitee From 4f9df1f0a99910e6d2afa99ae94d3b6bde935372 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Wed, 15 May 2024 09:38:29 +0800 Subject: [PATCH 7/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9codecheck?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- interfaces/inner_kits/native_cpp/BUILD.gn | 2 +- .../include/mini/device_manager_impl_lite_m.h | 4 ++++ .../src/mini/mine_softbus_adapter.c | 20 +++++++++---------- .../native_cpp/src/mini/softbus_adapter.c | 6 +++++- 4 files changed, 19 insertions(+), 13 deletions(-) diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn index f06e7f92..656273c3 100644 --- a/interfaces/inner_kits/native_cpp/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/BUILD.gn @@ -44,8 +44,8 @@ if (defined(ohos_lite)) { sources = [ "${innerkits_path}/native_cpp/src/mini/device_manager_impl_lite_m.c", "${innerkits_path}/native_cpp/src/mini/hichain_adapter.c", - "${innerkits_path}/native_cpp/src/mini/softbus_adapter.c", "${innerkits_path}/native_cpp/src/mini/mine_softbus_adapter.c", + "${innerkits_path}/native_cpp/src/mini/softbus_adapter.c", ] deps = [ diff --git a/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h b/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h index df62428c..bedde731 100644 --- a/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h +++ b/interfaces/inner_kits/native_cpp/include/mini/device_manager_impl_lite_m.h @@ -19,7 +19,9 @@ #include #include "device_manager_common.h" +#ifdef MINE_HARMONY_SOFTBUS #include "softbus_common.h" +#endif #ifdef __cplusplus extern "C" { @@ -98,7 +100,9 @@ typedef struct { char networkId[DM_MAX_DEVICE_NETWORKID_LEN + 1]; char deviceName[DM_MAX_DEVICE_NAME_LEN + 1]; unsigned int deviceTypeId; +#ifdef MINE_HARMONY_SOFTBUS ConnectionAddr connectAddr; +#endif int range; int credible; bool isTrust; diff --git a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c index 23f6f10c..e3640be0 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -59,17 +59,13 @@ static const char DEVICE_ALIAS_NUMBER = 1; // device alias matching type #define DM_TLV_SCOPE_DATA_OFFSET 4 // offset from the TLV header to the hash truncated part #define DM_TLV_VERTEX_DATA_OFFSET 2 // offset from the TLV header to the hash truncated part #define DM_SEARCH_BROADCAST_MIN_LEN 18 // Minimum broadcast length -#define DM_FULL_QUEUE_USELESS_LEN 1 // Indicates the idle flag length of the full cyclic queue #define DM_MAX_DEVICE_ALIAS_LEN 65 // maximum length of the device alias hat can be imported. #define DM_INVALID_DEVICE_NUMBER (-1) // invaild number of device #define DM_MAX_SCOPE_TLV_NUM 2 // maximum Types of input options for scope search. #define DM_MAX_VERTEX_TLV_NUM 6 // maximum Types of input options for vertex search. -#define DM_MAX_MATCH_WAIT_NUMBER 256 // maximum number of devices waiting for match #define DM_MAX_DEVICE_NUMBER 100000000 // maxinum number of device #define SOFTBUS_DELAY_TICK_COUNT (10 * LOSCFG_BASE_CORE_TICK_PER_SECOND) // 10s -static const UINT16 DEAL_TASK_PRIOR = 13; // priority of a timer task -static const UINT32 TASK_STACK_SIZE = 10240; // stack size of the networking task static const UINT32 LIC_LITEOS_M_STACK_SIZE = 8192; static const int DM_MAX_SEARCH_JSON_LEN = 3072; @@ -184,7 +180,7 @@ IRefreshCallback g_refreshMineDiscoveryCallback = { .OnDiscoverResult = OnRefreshDiscoveryResult }; -#ifdef MINE_HARMONY_POLICY +#ifdef MINE_HARMONY_SOFTBUS static IDiscoveryPolicyCallback publishLNNCallback_ = { .PolicyReport = OnPublishDeviceFound }; @@ -192,7 +188,7 @@ static IDiscoveryPolicyCallback publishLNNCallback_ = { int PublishDeviceDiscovery(bool enable) { -#ifdef MINE_HARMONY_POLICY +#ifdef MINE_HARMONY_SOFTBUS int retValue = EnableDiscoveryPolicy(DM_PKG_NAME, DM_CAPABILITY_OSD, enable, &publishLNNCallback_); if (retValue != SOFTBUS_OK) { DMLOGE("[softbus]failed to call softbus EnableDiscoveryPolicy function with ret: %d.", retValue); @@ -534,7 +530,7 @@ static int ParseVertexDeviceJsonArray(const cJSON *object, const int arraySize, } // returned string, which needs to be manually cJSON_free by the invoker. -char *EncodeDMBroadcastData(const char *srcData) +static char *EncodeDMBroadcastData(const char *srcData) { cJSON *root = cJSON_CreateObject(); if (root == NULL) { @@ -556,7 +552,7 @@ char *EncodeDMBroadcastData(const char *srcData) return rootJsonStr; } -bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t destLen) +static bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t destLen) { cJSON *root = cJSON_Parse(srcData); if (root == NULL) { @@ -734,7 +730,7 @@ static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcast DMLOGE("failed to strcpy_s with ret: %d.", retValue); return ERR_DM_FAILED; } -#ifdef MINE_HARMONY_POLICY +#ifdef MINE_HARMONY_SOFTBUS retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, &deviceInfo); if (retValue != SOFTBUS_OK) { DMLOGE("failed to set discovery policy with ret: %d.", retValue); @@ -1211,7 +1207,7 @@ void SetStartDiscoveyVaild() g_discoveryCallbackMap.valid = false; } -void OnPublishDeviceFound(const DeviceInfo *deviceInfo) +static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) { if (deviceInfo == NULL) { DMLOGE("deviceInfo is NULL."); @@ -1250,7 +1246,7 @@ void OnPublishDeviceFound(const DeviceInfo *deviceInfo) } } -void MatchDealTask(void *param) +static void MatchDealTask(void *param) { DeviceInfo deviceInfo = *((DeviceInfo *)param); if (ParseBroadcastInfo(&deviceInfo) != DM_OK) { @@ -1271,8 +1267,10 @@ static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInf } dmDeviceInfo->isTrust = deviceInfo->isOnline; dmDeviceInfo->deviceTypeId = deviceInfo->devType; +#ifdef MINE_HARMONY_SOFTBUS const size_t arrayStartPosition = 0; dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; +#endif dmDeviceInfo->isLocalExistCredential = IsHichainCredentialExist(); dmDeviceInfo->isPeerExistCredential = isExistCredential; } diff --git a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c index f519051e..f0ee1edb 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c @@ -790,7 +790,9 @@ static bool ImportDeviceToAddrMap(const DmDeviceInfo *deviceInfo) return false; } g_deviceIdAddrMap[i].valid = true; +#ifdef MINE_HARMONY_SOFTBUS g_deviceIdAddrMap[i].connectAddr = deviceInfo->connectAddr; +#endif return true; } DMLOGE("addr map not memory for a new deviceid."); @@ -1016,7 +1018,6 @@ static void NodeBasicInfoCopyToDmDevice(DmDeviceBasicInfo *dmDeviceInfo, const N static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInfo *deviceInfo) { - const size_t arrayStartPosition = 0; (void)memset_s(dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); errno_t retValue = strcpy_s(dmDeviceInfo->deviceId, sizeof(dmDeviceInfo->deviceId), deviceInfo->devId); if (retValue != EOK) { @@ -1029,7 +1030,10 @@ static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInf dmDeviceInfo->credible = deviceInfo->isOnline; dmDeviceInfo->deviceTypeId = deviceInfo->devType; dmDeviceInfo->range = deviceInfo->range; +#ifdef MINE_HARMONY_SOFTBUS + const size_t arrayStartPosition = 0; dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; +#endif int ret = GetAuthFormByDeviceId(dmDeviceInfo->deviceId, dmDeviceInfo->authForm); if (ret != DM_OK) { DMLOGE("failed to get authForm from hichain, ret: %d.", ret); -- Gitee From c85c408f23a4b6a9c3f3210d5112674f1fad3bc3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Mon, 3 Jun 2024 15:12:28 +0800 Subject: [PATCH 8/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c index 8a7da593..65bd4b08 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c +++ b/interfaces/inner_kits/native_cpp/src/mini/device_manager_impl_lite_m.c @@ -197,7 +197,7 @@ int StartDiscovering(const char *discoverParam, const char *filterOption, OnTarg return ERR_DM_INPUT_INVALID_VALUE; } int subscribeId = subscribeIdObj->valueint; - int ret = ERR_DM_FAILED; + int ret = ERR_DM_FAILED; if (IsQuickStartDiscovery(filterOption)) { ret = StartMineSoftbusQuickDiscovery(pkgName, subscribeId, filterOption, callback); } else { -- Gitee