From f503ccdbadd179ad7c4dbecaba308e2ecd74d387 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Tue, 4 Jun 2024 09:37:09 +0800 Subject: [PATCH 1/8] =?UTF-8?q?=E7=AD=96=E7=95=A5=E5=8F=91=E7=8E=B0L0?= 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 | 7 +- .../native_cpp/include/mini/hichain_adapter.h | 1 + .../include/mini/mine_softbus_adapter.h | 35 + .../src/mini/device_manager_impl_lite_m.c | 42 +- .../native_cpp/src/mini/hichain_adapter.c | 1 - .../src/mini/mine_softbus_adapter.c | 1277 +++++++++++++++++ .../native_cpp/src/mini/softbus_adapter.c | 33 +- 9 files changed, 1363 insertions(+), 36 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 407cd2b5..25bb77b2 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", @@ -43,6 +44,7 @@ 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/mine_softbus_adapter.c", "${innerkits_path}/native_cpp/src/mini/softbus_adapter.c", ] 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..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,11 +98,11 @@ 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; + bool isPeerExistCredential; bool isLocalExistCredential; int authForm; } DmDeviceInfo; @@ -123,6 +121,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..9a44a1e9 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h @@ -0,0 +1,35 @@ +/* + * 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); +void SetStartDiscoveyVaild(); + +#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..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 @@ -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; @@ -39,13 +41,16 @@ 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); + return retValue; + } retValue = InitHichainModle(); if (retValue != DM_OK) { DMLOGE("failed to init hichain with ret: %d.", retValue); @@ -67,9 +72,8 @@ int UnInitDeviceManager(void) DMLOGI("device manager module not initialized."); return DM_OK; } -#ifdef MINE_HARMONY_SOFTBUS + PublishDeviceDiscovery(false); UnInitSoftbusModle(); -#endif UnInitHichainModle(); g_deviceManagerInitFlag = false; return DM_OK; @@ -146,6 +150,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 +197,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; } @@ -188,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/hichain_adapter.c b/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c index 41fbc1ef..23645ad9 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/hichain_adapter.c @@ -67,7 +67,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..d41f1264 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -0,0 +1,1277 @@ +/* + * 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" +#ifdef MINE_HARMONY_SOFTBUS +#include "softbus_bus_center_ex.h" +#endif + +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_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_DEVICE_NUMBER 100000000 // maxinum number of device +#define SOFTBUS_DELAY_TICK_COUNT (10 * LOSCFG_BASE_CORE_TICK_PER_SECOND) // 10s + +static const UINT32 LIC_LITEOS_M_STACK_SIZE = 8192; + +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 { + DM_DISCOVERY_POLICY_ALLOW_REPLY, + DM_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 OnDiscoveryDeviceFound(const DeviceInfo *deviceInfo); +static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason); + +static char *EncodeDMBroadcastData(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_matchQueueMutex = 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; + +IRefreshCallback g_refreshMineDiscoveryCallback = { + .OnDeviceFound = OnDiscoveryDeviceFound, + .OnDiscoverResult = OnRefreshDiscoveryResult +}; + +#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_LNN; + } +#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; + } + DMLOGI("quick search device mode is: %d.", object->valueint); + 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 cJSON_free by the invoker. +static char *EncodeDMBroadcastData(const char *srcData) +{ + cJSON *root = cJSON_CreateObject(); + if (root == NULL) { + DMLOGE("failed to create cjson object."); + return NULL; + } + if (cJSON_AddStringToObject(root, DEVICE_DM_KEY, srcData) == NULL) { + DMLOGE("failed to add true to object."); + cJSON_Delete(root); + return NULL; + } + char *rootJsonStr = cJSON_PrintUnformatted(root); + if (rootJsonStr == NULL) { + DMLOGE("cJSON_PrintUnformatted failed, rootJsonStr is null."); + cJSON_Delete(root); + return NULL; + } + cJSON_Delete(root); + return rootJsonStr; +} + +static bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t destLen) +{ + cJSON *root = cJSON_Parse(srcData); + if (root == NULL) { + DMLOGE("root is nullptr."); + return false; + } + cJSON *object = cJSON_GetObjectItem(root, DEVICE_DM_KEY); + if (!cJSON_IsString(object)) { + DMLOGE("object is not string."); + cJSON_Delete(root); + return false; + } + char *value = cJSON_GetStringValue(object); + if (value == NULL) { + DMLOGE("get policy data is nullptr."); + cJSON_Delete(root); + return false; + } + if (strcpy_s(destData, destLen, value) != 0) { + DMLOGE("strcpy_s is failed."); + cJSON_Delete(root); + return false; + } + cJSON_Delete(root); + return true; +} + +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; + } + size_t custDataLen = strlen(custData); + + 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 = custDataLen, + 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; + } + DMLOGI("send search broadcast info by softbus successfully with dataLen: %u, pkgName: %s.", custDataLen, + pkgName); + return DM_OK; +} + +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 = DM_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 == DM_DISCOVERY_POLICY_ALLOW_REPLY) { + return SendReturnwave(deviceInfo, broadcastHead, matchResult); + } + return DM_OK; +} + +static bool GetBroadcastData(DeviceInfo *deviceInfo, char *outData, size_t outLen) +{ + 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; + size_t dataLen = strlen(base64Data); + char *data = (char*)base64Data; + 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 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]; + } + + 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 DM_DISCOVERY_POLICY_ALLOW_REPLY; + } + if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DM_DISCOVERY_POLICY_ALLOW_REPLY; + } else if ((deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_NOTRUST_DEVICE)) { + return DM_DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DM_DISCOVERY_POLICY_REJECT_REPLY; + } else { + return DM_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 DM_DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DM_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 DM_DISCOVERY_POLICY_REJECT_REPLY; + } else if (!(deviceInfo->isOnline) && (broadcastHead->trustFilter == FIND_TRUST_DEVICE)) { + return DM_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 DM_DISCOVERY_POLICY_ALLOW_REPLY; + } else { + return DM_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 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; + } + 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); + 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*)base64Data; + 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; + } +} + +void SetStartDiscoveyVaild() +{ + g_discoveryCallbackMap.valid = false; +} + +static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) +{ + if (deviceInfo == NULL) { + DMLOGE("deviceInfo is NULL."); + return; + } + 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); + 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; + } + 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) { + DMLOGE("failed to post match queue mutex with ret: %u.", osRet); + } +} + +static 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)); + 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; + const size_t arrayStartPosition = 0; + dmDeviceInfo->connectAddr = deviceInfo->addr[arrayStartPosition]; + 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 82b470b7..f0ee1edb 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; } @@ -563,6 +555,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; @@ -618,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; @@ -629,12 +625,11 @@ 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; } -#endif DMLOGI("softbus RefreshLNN successfully."); return DM_OK; } @@ -910,7 +905,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; @@ -924,7 +918,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."); @@ -945,13 +938,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."); @@ -1027,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) { @@ -1041,6 +1031,7 @@ static void DeviceInfoCopyToDmDevice(DmDeviceInfo *dmDeviceInfo, const DeviceInf 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); @@ -1226,7 +1217,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); @@ -1246,7 +1236,6 @@ static int OnSessionOpened(int sessionId, int result) return ERR_DM_FAILED; } cJSON_free(msg); -#endif return DM_OK; } @@ -1308,13 +1297,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); } @@ -1363,10 +1350,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); @@ -1395,9 +1380,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 ce027e740f024663a13f5a0f04a2971d21a378ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Tue, 4 Jun 2024 15:49:16 +0800 Subject: [PATCH 2/8] =?UTF-8?q?=E6=B7=BB=E5=8A=A0pubishLnn=E5=8A=9F?= =?UTF-8?q?=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../native_cpp/src/mini/softbus_adapter.c | 31 ++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) 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 f0ee1edb..d0c54580 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c @@ -93,6 +93,7 @@ static int OnSessionOpened(int sessionId, int result); static void OnSessionClosed(int sessionId); static void OnJoinLNNCallback(ConnectionAddr *addr, const char *networkId, int32_t retCode); static void OnLeaveLNNCallback(const char *networkId, int32_t retCode); +static int PublishDeviceDiscovery(void); static void ProcessSinkMsg(const char *data, unsigned int dataLen); static void ProcessSourceMsg(const char *data, unsigned int dataLen); @@ -300,6 +301,11 @@ int InitSoftbusModle(void) retValue = ERR_DM_LITEOS_CREATE_MUTEX_OR_SEM; break; } + if (PublishDeviceDiscovery() != DM_OK) { + DMLOGE("failed to publish device discovery."); + retValue = ERR_DM_SOFTBUS_PUBLISH_LNN; + break; + } } while (false); if (retValue != DM_OK) { @@ -314,7 +320,12 @@ int InitSoftbusModle(void) int UnInitSoftbusModle(void) { int returnResult = DM_OK; - int retValue = UnregNodeDeviceStateCb(&g_softbusStatusChangeCb); + int retValue = StopPublishLNN(DM_PKG_NAME, DEVICEMANAGER_SA_ID); + if (retValue != SOFTBUS_OK) { + DMLOGE("failed to stop publishLNN with ret: %d", retValue); + returnResult = ERR_DM_SOFTBUS_STOP_PUBLISH_LNN; + } + 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; @@ -898,6 +909,24 @@ static bool ImportPkgNameToBindMap(const char *pkgName, OnBindResult cb) return true; } +int PublishDeviceDiscovery(void) +{ + PublishInfo publishInfo; + publishInfo.publishId = DEVICEMANAGER_SA_ID; + publishInfo.mode = DISCOVER_MODE_ACTIVE; + publishInfo.medium = AUTO; + publishInfo.freq = HIGH; + publishInfo.capability = DM_CAPABILITY_OSD; + publishInfo.capabilityData = NULL; + publishInfo.dataLen = 0; + int retValue = PublishLNN(DM_PKG_NAME, &publishInfo, &g_publishLNNCallback); + if (retValue != SOFTBUS_OK) { + DMLOGE("failed to call softbus publishLNN function with ret: %d.", retValue); + return ERR_DM_SOFTBUS_PUBLISH_LNN; + } + return DM_OK; +} + int StartSoftbusPublish(const char *pkgName, OnAdvertisingResult cb) { DMLOGI("StartSoftbusPublish start."); -- Gitee From b4ff66c48abdb19a671961ab5d57d9abe3d04cdc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Wed, 5 Jun 2024 10:10:34 +0800 Subject: [PATCH 3/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=8B=BC=E5=86=99?= =?UTF-8?q?=E9=94=99=E8=AF=AF?= 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/softbus_adapter.c | 4 ---- services/service/src/softbus/mine_softbus_listener.cpp | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) 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 d0c54580..f4672cdd 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c @@ -801,9 +801,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."); @@ -1059,10 +1057,8 @@ 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); diff --git a/services/service/src/softbus/mine_softbus_listener.cpp b/services/service/src/softbus/mine_softbus_listener.cpp index 6badeb87..0394bce5 100644 --- a/services/service/src/softbus/mine_softbus_listener.cpp +++ b/services/service/src/softbus/mine_softbus_listener.cpp @@ -54,7 +54,7 @@ constexpr int32_t DM_TLV_VERTEX_DATA_OFFSET = 2; constexpr int32_t DM_TLV_SCOPE_DATA_OFFSET = 4; constexpr int32_t DM_SEARCH_BROADCAST_MIN_LEN = 18; constexpr const char* FIELD_DEVICE_MODE = "findDeviceMode"; -constexpr const char* FIELD_TRUST_OPTIONS = "tructOptions"; +constexpr const char* FIELD_TRUST_OPTIONS = "trustOptions"; constexpr const char* FIELD_FILTER_OPTIONS = "filterOptions"; constexpr const char* DEVICE_ALIAS = "persist.devicealias"; constexpr const char* DEVICE_NUMBER = "persist.devicenumber"; -- Gitee From 764dbc4df609353595a12ee969d42260e72a9bbe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Fri, 7 Jun 2024 18:06:57 +0800 Subject: [PATCH 4/8] =?UTF-8?q?=E9=94=81=E9=97=AE=E9=A2=98=E4=BF=AE?= =?UTF-8?q?=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../include/mini/mine_softbus_adapter.h | 2 + .../src/mini/device_manager_impl_lite_m.c | 5 +++ .../src/mini/mine_softbus_adapter.c | 44 ++++++++++++------- 3 files changed, 36 insertions(+), 15 deletions(-) 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 9a44a1e9..16e039d4 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 @@ -27,6 +27,8 @@ int StartMineSoftbusQuickDiscovery(const char *pkgName, const int subscribeId, const char *searchJson, OnTargetFound callback); int PublishDeviceDiscovery(bool enable); void SetStartDiscoveyVaild(); +int CreateSemaphoreAndMutex(void); +int DeleteSemaphoreAndMutex(void); #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 65bd4b08..0f7cf814 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 @@ -51,6 +51,10 @@ int InitDeviceManager(void) DMLOGE("failed to en with ret: %d.", retValue); return retValue; } + if (CreateSemaphoreAndMutex() != DM_OK) { + DMLOGE("failed to create mutex."); + return retValue; + } retValue = InitHichainModle(); if (retValue != DM_OK) { DMLOGE("failed to init hichain with ret: %d.", retValue); @@ -73,6 +77,7 @@ int UnInitDeviceManager(void) return DM_OK; } PublishDeviceDiscovery(false); + DeleteSemaphoreAndMutex(); UnInitSoftbusModle(); UnInitHichainModle(); g_deviceManagerInitFlag = false; 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 d41f1264..45efac80 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 @@ -165,9 +165,7 @@ static bool DecodeDMBroadcastData(const char *srcData, char *destData, size_t de 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_matchQueueMutex = 0; static struct { @@ -616,12 +614,6 @@ static int SendBroadcastInfo(const char *pkgName, const int subscribeId, char *d 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; - } DMLOGI("send search broadcast info by softbus successfully with dataLen: %u, pkgName: %s.", custDataLen, pkgName); return DM_OK; @@ -1193,15 +1185,8 @@ 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; } } @@ -1210,6 +1195,35 @@ void SetStartDiscoveyVaild() g_discoveryCallbackMap.valid = false; } +int CreateSemaphoreAndMutex(void) +{ + UINT32 osRet = LOS_MuxCreate(&g_matchQueueMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to create match queue mutex with ret: %d", osRet); + return ERR_DM_LITEOS_FAILED; + } + osRet = LOS_MuxCreate(&g_discoveryMapMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to create discovery queue mutex with ret: %d", osRet); + return ERR_DM_LITEOS_FAILED; + } + return DM_OK; +} + +int DeleteSemaphoreAndMutex(void) +{ + UINT32 osRet = LOS_MuxDelete(g_matchQueueMutex); + if (osRet != LOS_OK && osRet != LOS_ERRNO_MUX_INVALID) { + DMLOGE("failed to delete match queue mutex with ret: %d", osRet); + return ERR_DM_LITEOS_FAILED; + } + osRet = LOS_MuxDelete(g_discoveryMapMutex); + if (osRet != LOS_OK && osRet != LOS_ERRNO_MUX_INVALID) { + DMLOGE("failed to delete discovery queue mutex with ret: %d", osRet); + return ERR_DM_LITEOS_FAILED; + } +} + static void OnPublishDeviceFound(const DeviceInfo *deviceInfo) { if (deviceInfo == NULL) { -- Gitee From 63ee594022f16bbf888b91bbb445fef4d501674c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Tue, 11 Jun 2024 15:18:19 +0800 Subject: [PATCH 5/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E8=B0=83=E7=94=A8?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../inner_kits/native_cpp/src/mini/mine_softbus_adapter.c | 2 +- 1 file changed, 1 insertion(+), 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 45efac80..bed490ac 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 @@ -726,7 +726,7 @@ static int SendReturnwave(DeviceInfo *deviceInfo, const BroadcastHead *broadcast return ERR_DM_FAILED; } #ifdef MINE_HARMONY_SOFTBUS - retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, &deviceInfo); + 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; -- Gitee From a303ec9f43ff2140beedc63dd87ffcc65817d159 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Tue, 11 Jun 2024 17:54:28 +0800 Subject: [PATCH 6/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=8B=B7=E8=B4=9D?= =?UTF-8?q?=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../inner_kits/native_cpp/src/mini/mine_softbus_adapter.c | 4 ++-- 1 file changed, 2 insertions(+), 2 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 bed490ac..17563087 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 @@ -1274,11 +1274,11 @@ static void MatchDealTask(void *param) 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); + errno_t retValue = strcpy_s(dmDeviceInfo->deviceId, sizeof(deviceInfo->devId) + 1, 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); + retValue = strcpy_s(dmDeviceInfo->deviceName, sizeof(deviceInfo->devName) + 1, deviceInfo->devName); if (retValue != EOK) { DMLOGE("failed to copy device name with ret: %d.", retValue); } -- Gitee From 49f868ba3d58d4d0f7f9fe482e59d653e35ed89c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Wed, 12 Jun 2024 17:14:10 +0800 Subject: [PATCH 7/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9stop=E6=96=B9=E6=B3=95?= 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 + .../include/mini/mine_softbus_adapter.h | 2 +- .../src/mini/device_manager_impl_lite_m.c | 10 ++- .../src/mini/mine_softbus_adapter.c | 74 +++++++++++++++++-- .../native_cpp/src/mini/softbus_adapter.c | 4 + 5 files changed, 83 insertions(+), 11 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 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/include/mini/mine_softbus_adapter.h b/interfaces/inner_kits/native_cpp/include/mini/mine_softbus_adapter.h index 16e039d4..f1cf6a68 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 @@ -25,8 +25,8 @@ extern "C" { int StartMineSoftbusQuickDiscovery(const char *pkgName, const int subscribeId, const char *searchJson, OnTargetFound callback); +int StopMineSoftbusDiscovery(const char *pkgName, const int subscribeId); int PublishDeviceDiscovery(bool enable); -void SetStartDiscoveyVaild(); int CreateSemaphoreAndMutex(void); int DeleteSemaphoreAndMutex(void); 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 0f7cf814..f0b06a40 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 @@ -219,10 +219,12 @@ int StopDiscovering(const char *pkgName, const int subscribeId) DMLOGE("device manager module is not initialized."); return ERR_DM_NO_INIT; } - int ret = StopSoftbusDiscovery(pkgName, subscribeId); - if (ret == DM_OK) { - SetStartDiscoveyVaild(); - } + int ret = ERR_DM_FAILED; +#ifdef MINE_HARMONY_SOFTBUS + ret = StopMineSoftbusDiscovery(pkgName, subscribeId); +#else + ret = StopSoftbusDiscovery(pkgName, subscribeId); +#endif return ret; } 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 17563087..ce5acdbf 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 @@ -147,7 +147,8 @@ static int ParseVertexDeviceJsonArray(const cJSON *object, const int arraySize, static bool ImportPkgNameToDiscoveryMap(const char *pkgName, const int subscribeId, OnTargetFound callback); static bool IsValidMineStartDiscoveryInput(const char *pkgName, const char *searchJson, OnTargetFound callback); - +static int StopSoftbusRefreshLNN(const char *pkgName, const int subscribeId); +static bool IsValidStopDiscoveryInput(const char *pkgName); static int ParseBroadcastInfo(DeviceInfo *deviceInfo); static Action MatchSearchAllDevice(DeviceInfo *deviceInfo, const BroadcastHead *broadcastHead); @@ -230,6 +231,70 @@ int StartMineSoftbusQuickDiscovery(const char *pkgName, const int subscribeId, return returnResult; } +int StopMineSoftbusDiscovery(const char *pkgName, const int subscribeId) +{ + if (!IsValidStopDiscoveryInput(pkgName)) { + 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 stop discovery device mutex with ret: %u.", osRet); + return ERR_DM_LITEOS_PEND_MUTEX; + } + returnResult = StopSoftbusRefreshLNN(pkgName, subscribeId); + if (returnResult != DM_OK) { + DMLOGE("failed to stop discovery device with ret: %u.", returnResult); + } + osRet = LOS_MuxPost(g_discoveryMapMutex); + if (osRet != LOS_OK) { + DMLOGE("failed to post stop 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("stop quick discovery successfully with pkgName: %s.", pkgName); + return returnResult; +} + +static int StopSoftbusRefreshLNN(const char *pkgName, const int subscribeId) +{ + if (!g_discoveryCallbackMap.valid) { + DMLOGI("pkgName has been released with pkgName: %s, subscribeId: %d.", pkgName, subscribeId); + return DM_OK; + } + if (subscribeId != g_discoveryCallbackMap.subscribeId || + strcmp(g_discoveryCallbackMap.pkgName, pkgName) != 0) { + DMLOGE("pkgName: %s and subscribeId: %d do not match.", pkgName, subscribeId); + return ERR_DM_SOFTBUS_STOP_DISCOVERY_DEVICE; + } + int retValue = StopRefreshLNN(DM_PKG_NAME, subscribeId); + if (retValue != SOFTBUS_OK) { + DMLOGE("failed to stop refreshLNN with ret: %d.", retValue); + return ERR_DM_SOFTBUS_STOP_DISCOVERY_DEVICE; + } + g_discoveryCallbackMap.valid = false; + DMLOGI("stop refreshLNN successfully."); + return DM_OK; +} + +static bool IsValidStopDiscoveryInput(const char *pkgName) +{ + if (pkgName == NULL) { + DMLOGE("pkgName point is NULL."); + return false; + } + size_t pkgNameLen = strlen(pkgName); + if (pkgNameLen == 0 || pkgNameLen >= DM_MAX_PKG_NAME_LEN) { + DMLOGE("not meet the requirements with pkgNameLen: %u.", pkgNameLen); + return false; + } + return true; +} + static bool IsValidMineStartDiscoveryInput(const char *pkgName, const char *searchJson, OnTargetFound callback) { @@ -1190,11 +1255,6 @@ static void OnRefreshDiscoveryResult(int32_t refreshId, RefreshResult reason) } } -void SetStartDiscoveyVaild() -{ - g_discoveryCallbackMap.valid = false; -} - int CreateSemaphoreAndMutex(void) { UINT32 osRet = LOS_MuxCreate(&g_matchQueueMutex); @@ -1284,8 +1344,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 f4672cdd..d0c54580 100644 --- a/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c +++ b/interfaces/inner_kits/native_cpp/src/mini/softbus_adapter.c @@ -801,7 +801,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."); @@ -1057,8 +1059,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 7661908bab68b27f521dd924c94da8d5f4d6dbae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8F=B2=E6=99=93=E6=99=93?= Date: Wed, 12 Jun 2024 17:57:12 +0800 Subject: [PATCH 8/8] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=AE=8F=E5=AE=9A?= =?UTF-8?q?=E4=B9=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 史晓晓 --- .../inner_kits/native_cpp/src/mini/mine_softbus_adapter.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 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 ce5acdbf..e646a01b 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 @@ -35,7 +35,7 @@ #include "softbus_bus_center.h" #include "softbus_common.h" #include "softbus_errcode.h" -#ifdef MINE_HARMONY_SOFTBUS +#ifdef MINE_HARMONY_SOFTBUS_EX #include "softbus_bus_center_ex.h" #endif @@ -182,7 +182,7 @@ IRefreshCallback g_refreshMineDiscoveryCallback = { .OnDiscoverResult = OnRefreshDiscoveryResult }; -#ifdef MINE_HARMONY_SOFTBUS +#ifdef MINE_HARMONY_SOFTBUS_EX static IDiscoveryPolicyCallback publishLNNCallback_ = { .PolicyReport = OnPublishDeviceFound }; @@ -190,7 +190,7 @@ static IDiscoveryPolicyCallback publishLNNCallback_ = { int PublishDeviceDiscovery(bool enable) { -#ifdef MINE_HARMONY_SOFTBUS +#ifdef MINE_HARMONY_SOFTBUS_EX 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); @@ -790,7 +790,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_SOFTBUS_EX retValue = SetDiscoveryPolicy(DM_CAPABILITY_OSD, (DiscoveryPolicy)matchResult, deviceInfo); if (retValue != SOFTBUS_OK) { DMLOGE("failed to set discovery policy with ret: %d.", retValue); -- Gitee