diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn index 5097fa9c41858bddfaf635fbd5fff0e212c653f7..656273c301338c8a033c414e6f70093732b1ccaa 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 e17cae79e59cad222e948924c2fb1fb45817b4b2..0c70263e8bbb50cc897b8df228d881e4bc40731c 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 5a58becddffa2d079ec21273787f2cbd163d7540..bedde731fbba859e5ff08222925996c2b17f33fd 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 220ba99ca234fde7113e1ba50b8a05c5102b198a..8f0b71f13c91650ea68d591ee0b3e17d79672f08 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 0000000000000000000000000000000000000000..9a44a1e9693c31aa4cc535b177cf6e196a7756ca --- /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 b5876f9316d4ca15d40c610fe513e0ad7e5b5fad..65bd4b0852973859e0d44e61bb67a13f472887b4 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 d57e61f67c4e0f8d0165518f998327a0c203d001..f9b17766812b7fe01a89eab915db893c104c8662 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 0000000000000000000000000000000000000000..e3640be0456d15ba9380441cb88725e71b4858a8 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/mini/mine_softbus_adapter.c @@ -0,0 +1,1276 @@ +/* + * 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_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 { + 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 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_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; + } + 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 = 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) +{ + 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 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 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; +#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 82b470b71732a23a6ee1e84e87a2eae970296a7a..f0ee1edb858b442cebfc84a19e24c5db6342dbc8 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