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

code revert

Browse Source 
Signed-off-by: guo-chunting <guochunting3@huawei.com>
Change-Id: Ia0108c3ee0c71106c983d3a89964088a4fe2c772
This commit is contained in:
guo-chunting 2023-06-29 16:46:16 +08:00
parent b6c1457aef
commit 9dd3b516b2
85 changed files with 184 additions and 886 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
adapter/common/include/softbus_adapter_file.h
View File

@ -47,7 +47,6 @@ extern "C" {
int32_t SoftBusReadFile(int32_t fd, void *readBuf, uint32_t maxLen);
int32_t SoftBusReadFullFile(const char *fileName, char *readBuf, uint32_t maxLen);
int32_t SoftBusWriteFile(const char *fileName, const char *writeBuf, uint32_t len);
int32_t SoftBusWriteFileFd(int32_t fd, const char *writeBuf, uint32_t len);
int32_t SoftBusOpenFile(const char *fileName, int32_t flags);
int32_t SoftBusOpenFileWithPerms(const char *fileName, int32_t flags, int32_t perms);
void SoftBusRemoveFile(const char *fileName);

8
adapter/common/kernel/liteos_m/softbus_adapter_file.c
View File

@ -85,14 +85,6 @@ int32_t SoftBusWriteFile(const char *fileName, const char *writeBuf, uint32_t le
return SOFTBUS_OK;
}
int32_t SoftBusWriteFileFd(int32_t fd, const char *writeBuf, uint32_t len)
{
(void)fd;
(void)writeBuf;
(void)len;
return SOFTBUS_INVALID_FD;
}
int32_t SoftBusOpenFile(const char *fileName, int32_t flags)
{
(void)fileName;

12
adapter/common/kernel/posix/softbus_adapter_file.c
View File

@ -138,18 +138,6 @@ int32_t SoftBusWriteFile(const char *fileName, const char *writeBuf, uint32_t le
return SOFTBUS_OK;
}
int32_t SoftBusWriteFileFd(int32_t fd, const char *writeBuf, uint32_t len)
{
if (writeBuf == NULL || len == 0) {
return SOFTBUS_FILE_ERR;
}
int32_t ret = write(fd, writeBuf, len);
if (ret != (int32_t)len) {
HILOG_ERROR(SOFTBUS_HILOG_ID, "WriteFileFd write fail");
}
return ret;
}
int32_t SoftBusOpenFile(const char *fileName, int32_t flags)
{
if (fileName == NULL) {

1
core/authentication/include/auth_connection.h
View File

@ -50,7 +50,6 @@ bool CheckActiveAuthConnection(const AuthConnInfo *connInfo);
const char *GetConnTypeStr(uint64_t connId);
uint32_t GetConnId(uint64_t connId);
int32_t GetConnType(uint64_t connId);
uint64_t GenConnId(int32_t connType, int32_t id);
uint32_t GetAuthDataSize(uint32_t len);
int32_t PackAuthData(const AuthDataHead *head, const uint8_t *data, uint8_t *buf, uint32_t size);

1
core/authentication/include/auth_manager.h
View File

@ -70,7 +70,6 @@ int32_t AuthDeviceGetPreferConnInfo(const char *uuid, AuthConnInfo *connInfo);
int64_t AuthDeviceGetLatestIdByUuid(const char *uuid, bool isIpConnection);
int64_t AuthDeviceGetIdByConnInfo(const AuthConnInfo *connInfo, bool isServer);
int64_t AuthDeviceGetIdByP2pMac(const char *p2pMac, AuthLinkType type, bool isServer);
AuthManager *NewAuthManager(int64_t authSeq, const AuthSessionInfo *info);
int32_t AuthDeviceEncrypt(int64_t authId, const uint8_t *inData, uint32_t inLen, uint8_t *outData, uint32_t *outLen);
int32_t AuthDeviceDecrypt(int64_t authId, const uint8_t *inData, uint32_t inLen, uint8_t *outData, uint32_t *outLen);

10
core/authentication/include/auth_tcp_connection.h
View File

@ -29,23 +29,21 @@ extern "C" {
#define AUTH_INVALID_FD (-1)
typedef struct {
void (*onConnected)(ListenerModule module, int32_t fd, bool isClient);
void (*onConnected)(int32_t fd, bool isClient);
void (*onDisconnected)(int32_t fd);
void (*onDataReceived)(ListenerModule module, int32_t fd, const AuthDataHead *head, const uint8_t *data);
void (*onDataReceived)(int32_t fd, const AuthDataHead *head, const uint8_t *data);
} SocketCallback;
int32_t SetSocketCallback(const SocketCallback *cb);
void UnsetSocketCallback(void);
// connect succ, return fd; otherwise, return -1.
int32_t SocketConnectDevice(const char *ip, int32_t port, bool isBlockMode);
int32_t NipSocketConnectDevice(ListenerModule module, const char *addr, int32_t port, bool isBlockMode);
void SocketDisconnectDevice(ListenerModule module, int32_t fd);
void SocketDisconnectDevice(int32_t fd);
int32_t SocketPostBytes(int32_t fd, const AuthDataHead *head, const uint8_t *data);
int32_t SocketGetConnInfo(int32_t fd, AuthConnInfo *connInfo, bool *isServer);
int32_t StartSocketListening(ListenerModule module, const LocalListenerInfo *info);
int32_t StartSocketListening(const char *ip, int32_t port);
void StopSocketListening(void);
#ifdef __cplusplus

1
core/authentication/interface/auth_interface.h
View File

@ -152,7 +152,6 @@ int32_t AuthGetServerSide(int64_t authId, bool *isServer);
int32_t AuthGetDeviceUuid(int64_t authId, char *uuid, uint16_t size);
int32_t AuthGetVersion(int64_t authId, SoftBusVersion *version);
int32_t AuthGetMetaType(int64_t authId, bool *isMetaAuth);
int32_t AuthGetConnByNodeAddr(const char *addr, uint32_t cipherFlag, AuthConnInfo *connInfo);
int32_t AuthInit(void);
void AuthDeinit(void);

43
core/authentication/src/auth_connection.c
View File

@ -42,16 +42,8 @@ typedef struct {
static ListNode g_connRequestList = { &g_connRequestList, &g_connRequestList };
static AuthConnListener g_listener = { 0 };
void __attribute__((weak)) RouteBuildClientAuthManager(int32_t cfd)
{
(void)cfd;
}
void __attribute__((weak)) RouteClearAuthChannelId(int32_t cfd)
{
(void)cfd;
}
uint64_t GenConnId(int32_t connType, int32_t id)
static uint64_t GenConnId(int32_t connType, int32_t id)
{
uint64_t connId = (uint64_t)connType;
connId = (connId << INT32_BIT_NUM) & MASK_UINT64_H32;
@ -237,7 +229,7 @@ static void HandleConnConnectTimeout(const void *para)
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthConn: connect timeout, requestId=%u.", requestId);
ConnRequest *item = FindConnRequestByRequestId(requestId);
if (item != NULL) {
SocketDisconnectDevice(AUTH, item->fd);
SocketDisconnectDevice(item->fd);
DelConnRequest(item);
}
NotifyClientConnected(requestId, 0, SOFTBUS_AUTH_CONN_TIMEOUT, NULL);
@ -285,7 +277,6 @@ static void HandleConnConnectResult(const void *para)
{
CHECK_NULL_PTR_RETURN_VOID(para);
int32_t fd = *(int32_t *)(para);
RouteBuildClientAuthManager(fd);
ConnRequest *item = FindConnRequestByFd(fd);
if (item == NULL) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "ConnRequest not found, fd=%d.", fd);
@ -297,7 +288,7 @@ static void HandleConnConnectResult(const void *para)
}
/* WiFi Connection */
static void OnWiFiConnected(ListenerModule module, int32_t fd, bool isClient)
static void OnWiFiConnected(int32_t fd, bool isClient)
{
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "OnWiFiConnected: fd=%d, side=%s.", fd,
isClient ? "client" : "server(ignored)");
@ -315,17 +306,12 @@ static void OnWiFiDisconnected(int32_t fd)
(void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
connInfo.type = AUTH_LINK_TYPE_WIFI;
NotifyDisconnected(GenConnId(connInfo.type, fd), &connInfo);
RouteClearAuthChannelId(fd);
}
static void OnWiFiDataReceived(ListenerModule module, int32_t fd, const AuthDataHead *head, const uint8_t *data)
static void OnWiFiDataReceived(int32_t fd, const AuthDataHead *head, const uint8_t *data)
{
CHECK_NULL_PTR_RETURN_VOID(head);
CHECK_NULL_PTR_RETURN_VOID(data);
if (module != AUTH && module != AUTH_P2P) {
return;
}
bool fromServer = false;
AuthConnInfo connInfo;
(void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
@ -559,7 +545,7 @@ NO_SANITIZE("cfi") void DisconnectAuthDevice(uint64_t connId)
GetConnId(connId));
switch (GetConnType(connId)) {
case AUTH_LINK_TYPE_WIFI:
SocketDisconnectDevice(AUTH, GetFd(connId));
SocketDisconnectDevice(GetFd(connId));
break;
case AUTH_LINK_TYPE_BLE:
case AUTH_LINK_TYPE_BR:
@ -631,23 +617,8 @@ NO_SANITIZE("cfi") int32_t AuthStartListening(AuthLinkType type, const char *ip,
}
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "start auth listening, type=%d, port=%d.", type, port);
switch (type) {
case AUTH_LINK_TYPE_WIFI: {
LocalListenerInfo info = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "",
.port = port,
.moduleId = AUTH,
.protocol = LNN_PROTOCOL_IP,
},
};
if (strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), ip) != EOK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s ip fail.");
return SOFTBUS_MEM_ERR;
}
return StartSocketListening(AUTH, &info);
}
case AUTH_LINK_TYPE_WIFI:
return StartSocketListening(ip, port);
case AUTH_LINK_TYPE_P2P: {
LocalListenerInfo local = {
.type = CONNECT_TCP,

97
core/authentication/src/auth_interface.c
View File

@ -16,17 +16,10 @@
#include <stdbool.h>
#include <stdint.h>
#include <securec.h>
#include <string.h>
#include "auth_hichain.h"
#include "auth_manager.h"
#include "auth_meta_manager.h"
#include "softbus_def.h"
#include "softbus_adapter_mem.h"
#include "lnn_distributed_net_ledger.h"
#include "bus_center_manager.h"
#define BLE_CIPHER 0x4
typedef struct {
int32_t module;
@ -270,96 +263,6 @@ NO_SANITIZE("cfi") bool AuthHasTrustedRelation(void)
return sameGroupCnt != 0 || pointGroupCnt != 0;
}
static int32_t AuthBuildNodeConnInfo(const char *networkId, const char *nodeAddr,
uint32_t cipherFlag, AuthConnInfo *connInfo)
{
bool hasIp = false;
char ip[IP_LEN] = {0};
NodeInfo *nodeInfo = LnnGetNodeInfoById(networkId, CATEGORY_NETWORK_ID);
if (nodeInfo != NULL && LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_LSA)) {
if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, nodeAddr) != EOK) {
return SOFTBUS_MEM_ERR;
}
connInfo->type = AUTH_LINK_TYPE_WIFI;
return SOFTBUS_OK;
}
if (LnnGetRemoteStrInfo(networkId, STRING_KEY_WLAN_IP, ip, IP_LEN) == SOFTBUS_OK) {
if (strnlen(ip, sizeof(ip)) == 0 ||
strncmp(ip, LOCAL_IP, strlen(LOCAL_IP)) == 0) {
SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "not has ip addr");
} else {
hasIp = true;
}
}
if (hasIp) {
connInfo->type = AUTH_LINK_TYPE_WIFI;
if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, ip) != EOK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "copy ip addr fail");
return SOFTBUS_NOT_FIND;
}
} else if (LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC,
connInfo->info.brInfo.brMac, BT_MAC_LEN) == SOFTBUS_OK) {
if ((cipherFlag & BLE_CIPHER) != 0) {
char udid[UDID_BUF_LEN] = {0};
(void)LnnConvertDlId(networkId, CATEGORY_NETWORK_ID, CATEGORY_UDID, udid, UDID_BUF_LEN);
if (SoftBusGenerateStrHash((unsigned char *)udid, strlen(udid),
connInfo->info.bleInfo.deviceIdHash) == SOFTBUS_OK) {
} else {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "generate udid hash failed");
return SOFTBUS_NOT_FIND;
}
connInfo->type = AUTH_LINK_TYPE_BLE;
} else {
connInfo->type = AUTH_LINK_TYPE_BR;
}
} else {
SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "get connect info failed");
return SOFTBUS_NOT_FIND;
}
return SOFTBUS_OK;
}
NO_SANITIZE("cfi") int32_t AuthGetConnByNodeAddr(const char *addr, uint32_t cipherFlag, AuthConnInfo *connInfo)
{
int32_t num = 0;
int32_t ret = SOFTBUS_OK;
NodeBasicInfo *info = NULL;
if (LnnGetAllOnlineNodeInfo(&info, &num) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "get online node failed");
return SOFTBUS_NOT_FIND;
}
if (info == NULL || num == 0) {
return SOFTBUS_NOT_FIND;
}
for (int32_t i = 0; i < num; i++) {
char nodeAddr[SHORT_ADDRESS_MAX_LEN] = {0};
char *tmpNetworkId = info[i].networkId;
if (!LnnIsLSANode(&info[i])) {
continue;
}
if (LnnGetRemoteStrInfo(tmpNetworkId, STRING_KEY_NODE_ADDR, nodeAddr, SHORT_ADDRESS_MAX_LEN) != SOFTBUS_OK ||
strcmp(addr, nodeAddr) != 0) {
continue;
}
ret = AuthBuildNodeConnInfo(tmpNetworkId, nodeAddr, cipherFlag, connInfo);
SoftBusFree(info);
return ret;
}
connInfo->type = AUTH_LINK_TYPE_WIFI;
if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, addr) != EOK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "copy ip addr failed");
ret = SOFTBUS_NOT_FIND;
}
SoftBusFree(info);
return ret;
}
NO_SANITIZE("cfi") int32_t AuthInit(void)
{
AuthTransCallback callBack = {

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

@ -42,7 +42,7 @@ static AuthVerifyListener g_verifyListener = { 0 };
static GroupChangeListener g_groupChangeListener = { 0 };
static AuthTransCallback g_transCallback = { 0 };
/* Auth Manager */
NO_SANITIZE("cfi") AuthManager *NewAuthManager(int64_t authSeq, const AuthSessionInfo *info)
static AuthManager *NewAuthManager(int64_t authSeq, const AuthSessionInfo *info)
{
AuthManager *auth = (AuthManager *)SoftBusMalloc(sizeof(AuthManager));
if (auth == NULL) {

119
core/authentication/src/auth_tcp_connection.c
View File

@ -59,12 +59,6 @@ static SocketCallback g_callback = {NULL, NULL, NULL};
static void NotifyChannelDisconnected(int32_t channelId);
static void NotifyChannelDataReceived(int32_t channelId, const SocketPktHead *head, const uint8_t *data);
int32_t __attribute__((weak)) RouteBuildServerAuthManager(int32_t cfd, const ConnectOption *clientAddr)
{
(void)cfd;
(void)clientAddr;
return SOFTBUS_OK;
}
static uint32_t GetSocketPktSize(uint32_t len)
{
@ -115,10 +109,10 @@ static int32_t UnpackSocketPkt(const uint8_t *data, uint32_t len, SocketPktHead
return SOFTBUS_OK;
}
NO_SANITIZE("cfi") static void NotifyConnected(ListenerModule module, int32_t fd, bool isClient)
NO_SANITIZE("cfi") static void NotifyConnected(int32_t fd, bool isClient)
{
if (g_callback.onConnected != NULL) {
g_callback.onConnected(module, fd, isClient);
g_callback.onConnected(fd, isClient);
}
}
@ -145,8 +139,7 @@ static uint32_t ModuleToDataType(int32_t module)
return DATA_TYPE_CONNECTION;
}
NO_SANITIZE("cfi") static void NotifyDataReceived(ListenerModule module, int32_t fd,
const SocketPktHead *pktHead, const uint8_t *data)
NO_SANITIZE("cfi") static void NotifyDataReceived(int32_t fd, const SocketPktHead *pktHead, const uint8_t *data)
{
if (pktHead->module == MODULE_AUTH_CHANNEL || pktHead->module == MODULE_AUTH_MSG) {
NotifyChannelDataReceived(fd, pktHead, data);
@ -160,18 +153,18 @@ NO_SANITIZE("cfi") static void NotifyDataReceived(ListenerModule module, int32_t
.len = pktHead->len,
};
if (g_callback.onDataReceived != NULL) {
g_callback.onDataReceived(module, fd, &head, data);
g_callback.onDataReceived(fd, &head, data);
}
}
static int32_t RecvPacketHead(ListenerModule module, int32_t fd, SocketPktHead *head)
static int32_t RecvPacketHead(int32_t fd, SocketPktHead *head)
{
uint8_t buf[AUTH_PKT_HEAD_LEN] = {0};
ssize_t len = ConnRecvSocketData(fd, (char *)&buf[0], sizeof(buf), 0);
if (len < AUTH_PKT_HEAD_LEN) {
if (len < 0) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "recv head fail(=%d).", ConnGetSocketError(fd));
(void)DelTrigger(module, fd, READ_TRIGGER);
(void)DelTrigger(AUTH, fd, READ_TRIGGER);
NotifyDisconnected(fd);
}
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "head not enough, len=%d, abandon it.", len);
@ -200,11 +193,11 @@ static uint8_t *RecvPacketData(int32_t fd, uint32_t len)
return data;
}
static int32_t ProcessSocketOutEvent(ListenerModule module, int32_t fd)
static int32_t ProcessSocketOutEvent(int32_t fd)
{
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "socket client connect succ: fd=%d.", fd);
(void)DelTrigger(module, fd, WRITE_TRIGGER);
if (AddTrigger(module, fd, READ_TRIGGER) != SOFTBUS_OK) {
(void)DelTrigger(AUTH, fd, WRITE_TRIGGER);
if (AddTrigger(AUTH, fd, READ_TRIGGER) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddTrigger fail.");
goto FAIL;
}
@ -212,20 +205,20 @@ static int32_t ProcessSocketOutEvent(ListenerModule module, int32_t fd)
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set none block mode fail.");
goto FAIL;
}
NotifyConnected(module, fd, true);
NotifyConnected(fd, true);
return SOFTBUS_OK;
FAIL:
(void)DelTrigger(module, fd, READ_TRIGGER);
(void)DelTrigger(AUTH, fd, READ_TRIGGER);
ConnShutdownSocket(fd);
NotifyDisconnected(fd);
return SOFTBUS_ERR;
}
static int32_t ProcessSocketInEvent(ListenerModule module, int32_t fd)
static int32_t ProcessSocketInEvent(int32_t fd)
{
SocketPktHead head = {0};
if (RecvPacketHead(module, fd, &head) != SOFTBUS_OK) {
if (RecvPacketHead(fd, &head) != SOFTBUS_OK) {
return SOFTBUS_ERR;
}
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO,
@ -243,14 +236,15 @@ static int32_t ProcessSocketInEvent(ListenerModule module, int32_t fd)
if (data == NULL) {
return SOFTBUS_ERR;
}
NotifyDataReceived(module, fd, &head, data);
NotifyDataReceived(fd, &head, data);
SoftBusFree(data);
return SOFTBUS_OK;
}
NO_SANITIZE("cfi") static int32_t OnConnectEvent(ListenerModule module,
int32_t cfd, const ConnectOption *clientAddr)
NO_SANITIZE("cfi") static int32_t OnConnectEvent(ListenerModule module, int32_t cfd, const ConnectOption *clientAddr)
{
(void)module;
(void)clientAddr;
if (cfd < 0) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
return SOFTBUS_INVALID_PARAM;
@ -260,22 +254,12 @@ NO_SANITIZE("cfi") static int32_t OnConnectEvent(ListenerModule module,
ConnShutdownSocket(cfd);
return SOFTBUS_ERR;
}
if (AddTrigger(module, cfd, READ_TRIGGER) != SOFTBUS_OK) {
if (AddTrigger(AUTH, cfd, READ_TRIGGER) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddTrigger fail.");
ConnShutdownSocket(cfd);
return SOFTBUS_ERR;
}
if (module != AUTH && module != AUTH_P2P) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "newip auth process");
if (RouteBuildServerAuthManager(cfd, clientAddr) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "build auth manager fail.");
(void)DelTrigger(module, cfd, READ_TRIGGER);
ConnShutdownSocket(cfd);
return SOFTBUS_ERR;
}
return SOFTBUS_OK;
}
NotifyConnected(module, cfd, false);
NotifyConnected(cfd, false);
return SOFTBUS_OK;
}
@ -283,9 +267,9 @@ NO_SANITIZE("cfi") static int32_t OnDataEvent(ListenerModule module, int32_t eve
{
(void)module;
if (events == SOFTBUS_SOCKET_OUT) {
return ProcessSocketOutEvent(module, fd);
return ProcessSocketOutEvent(fd);
} else if (events == SOFTBUS_SOCKET_IN) {
return ProcessSocketInEvent(module, fd);
return ProcessSocketInEvent(fd);
}
return SOFTBUS_ERR;
}
@ -305,13 +289,28 @@ NO_SANITIZE("cfi") void UnsetSocketCallback(void)
(void)memset_s(&g_callback, sizeof(SocketCallback), 0, sizeof(SocketCallback));
}
NO_SANITIZE("cfi") int32_t StartSocketListening(ListenerModule module, const LocalListenerInfo *info)
NO_SANITIZE("cfi") int32_t StartSocketListening(const char *ip, int32_t port)
{
CHECK_NULL_PTR_RETURN_VALUE(ip, SOFTBUS_INVALID_PARAM);
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "start socket listening.");
LocalListenerInfo info = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "",
.port = port,
.moduleId = AUTH,
.protocol = LNN_PROTOCOL_IP
}
};
if (strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), ip) != EOK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s ip fail.");
return SOFTBUS_MEM_ERR;
}
SoftbusBaseListener listener = {
.onConnectEvent = OnConnectEvent,
.onDataEvent = OnDataEvent,
};
int32_t port = StartBaseListener(info, &listener);
port = StartBaseListener(&info, &listener);
if (port <= 0) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "StartBaseListener fail(=%d).", port);
return SOFTBUS_ERR;
@ -367,48 +366,12 @@ NO_SANITIZE("cfi") int32_t SocketConnectDevice(const char *ip, int32_t port, boo
return fd;
}
NO_SANITIZE("cfi") int32_t NipSocketConnectDevice(ListenerModule module,
const char *addr, int32_t port, bool isBlockMode)
{
ConnectOption option = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "",
.port = port,
.moduleId = module,
.protocol = LNN_PROTOCOL_NIP
}
};
if (strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), addr) != EOK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy remote ip fail.");
return AUTH_INVALID_FD;
}
int32_t fd = ConnOpenClientSocket(&option, BIND_ADDR_ALL, !isBlockMode);
if (fd < 0) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "ConnOpenClientSocket fail.");
return AUTH_INVALID_FD;
}
TriggerType triggerMode = isBlockMode ? READ_TRIGGER : WRITE_TRIGGER;
if (AddTrigger(module, fd, triggerMode) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddTrigger fail.");
ConnShutdownSocket(fd);
return AUTH_INVALID_FD;
}
if (ConnSetTcpKeepAlive(fd, AUTH_KEEP_ALIVE_TIME_INTERVAL) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set tcp keep alive fail.");
(void)DelTrigger(module, fd, triggerMode);
ConnShutdownSocket(fd);
return AUTH_INVALID_FD;
}
return fd;
}
NO_SANITIZE("cfi") void SocketDisconnectDevice(ListenerModule module, int32_t fd)
NO_SANITIZE("cfi") void SocketDisconnectDevice(int32_t fd)
{
if (fd < 0) {
return;
}
(void)DelTrigger(module, fd, RW_TRIGGER);
(void)DelTrigger(AUTH, fd, RW_TRIGGER);
ConnShutdownSocket(fd);
}
@ -560,7 +523,7 @@ NO_SANITIZE("cfi") int32_t AuthOpenChannel(const char *ip, int32_t port)
NO_SANITIZE("cfi") void AuthCloseChannel(int32_t channelId)
{
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "AuthChannel: close auth channel, id=%d.", channelId);
SocketDisconnectDevice(AUTH, channelId);
SocketDisconnectDevice(channelId);
}
NO_SANITIZE("cfi") int32_t AuthPostChannelData(int32_t channelId, const AuthChannelData *data)

9
core/authentication/src/virtual/auth_tcp_connection_virtual.c
View File

@ -74,9 +74,8 @@ int32_t SocketConnectDevice(const char *ip, int32_t port, bool isBlockMode)
return SOFTBUS_NOT_IMPLEMENT;
}
void SocketDisconnectDevice(ListenerModule module, int32_t fd)
void SocketDisconnectDevice(int32_t fd)
{
(void)module;
(void)fd;
return;
}
@ -97,10 +96,10 @@ int32_t SocketGetConnInfo(int32_t fd, AuthConnInfo *connInfo, bool *isServer)
return SOFTBUS_NOT_IMPLEMENT;
}
int32_t StartSocketListening(ListenerModule module, const LocalListenerInfo *info)
int32_t StartSocketListening(const char *ip, int32_t port)
{
(void)module;
(void)info;
(void)ip;
(void)port;
SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_WARN, "%s not implement.", __func__);
return SOFTBUS_NOT_IMPLEMENT;
}

36
core/bus_center/bus_center_server.gni
View File

@ -112,7 +112,7 @@ if (defined(ohos_lite)) {
}
native_source_path = rebase_path("$dsoftbus_root_path")
agcr_dir = "dsoftbus_enhance/components/newip/agcr"
agcr_dir = "dsoftbus_enhance/components/agcr"
agcr_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
[
"$native_source_path",
@ -122,40 +122,8 @@ agcr_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
if (agcr_enhanced) {
import(
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/agcr/agcr.gni")
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/agcr/agcr.gni")
bus_center_server_src += agcr_src
bus_center_server_inc += agcr_inc
}
route_dir = "dsoftbus_enhance/components/newip/route"
route_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
[
"$native_source_path",
"$route_dir",
],
"value")
if (route_enhanced) {
import(
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/route/route.gni")
bus_center_server_src += route_src
bus_center_server_inc += route_inc
}
btn_dir = "dsoftbus_enhance/components/newip/btn"
btn_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
[
"$native_source_path",
"$btn_dir",
],
"value")
if (btn_enhanced) {
import(
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/btn/btn.gni")
bus_center_server_src += btn_src
bus_center_server_inc += btn_inc
}

1
core/bus_center/interface/bus_center_manager.h
View File

@ -50,7 +50,6 @@ int32_t LnnGetLocalNum16Info(InfoKey key, int16_t *info);
int32_t LnnSetLocalNum16Info(InfoKey key, int16_t info);
int32_t LnnSetLocalByteInfo(InfoKey key, const uint8_t *info, uint32_t len);
int32_t LnnGetLocalByteInfo(InfoKey key, uint8_t *info, uint32_t len);
bool LnnIsLSANode(const NodeBasicInfo *info);
int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum);
int32_t LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum);
int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info);

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

@ -148,9 +148,6 @@ static void SendCheckOffLineMessage(SoftBusScreenState state, LnnHeartbeatType h
return;
}
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
(void)LnnStopScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType));
if (LnnStartScreenChangeOfflineTiming(info[i].networkId,
LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
@ -177,9 +174,6 @@ static void RemoveCheckOffLineMessage(LnnHeartbeatType hbType)
return;
}
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
if (LnnStopScreenChangeOfflineTiming(info[i].networkId, LnnConvertHbTypeToConnAddrType(hbType)) != SOFTBUS_OK) {
LLOGE("stop check offline target msg failed,networkid:%s", AnonymizesNetworkID(info[i].networkId));
}

7
core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_fsm.c
View File

@ -868,9 +868,6 @@ static int32_t OnCheckDevStatus(FsmStateMachine *fsm, int32_t msgType, void *par
break;
}
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
CheckDevStatusByNetworkId(hbFsm, info[i].networkId, msgPara->hbType, nowTime);
}
SoftBusFree(info);
@ -916,9 +913,6 @@ static int32_t OnScreeOffCheckDevStatus(FsmStateMachine *fsm, int32_t msgType, v
break;
}
for (int32_t i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
CheckDevStatusForScreenOff(hbFsm, info[i].networkId, msgPara->hbType, nowTime);
}
SoftBusFree(info);
@ -1041,7 +1035,6 @@ NO_SANITIZE("cfi") int32_t LnnPostNextSendOnceMsgToHbFsm(LnnHeartbeatFsm *hbFsm,
SoftBusFree(dupPara);
return SOFTBUS_ERR;
}
LnnNotifyHBRepeat();
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "HB post next loop msg, delayMillis: %" PRIu64, delayMillis);
return SOFTBUS_OK;
}

6
core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_medium_mgr.c
View File

@ -165,9 +165,6 @@ static const NodeInfo *HbGetOnlineNodeByRecvInfo(const char *recvUdidHash, const
}
DiscoveryType discType = LnnConvAddrTypeToDiscType(recvAddrType);
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
const NodeInfo *nodeInfo = LnnGetNodeInfoById(info[i].networkId, CATEGORY_NETWORK_ID);
if (nodeInfo == NULL || !LnnHasDiscoveryType(nodeInfo, discType)) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "HB node online not have discType:%d", discType);
@ -391,9 +388,6 @@ NO_SANITIZE("cfi") void LnnDumpHbOnlineNodeList(void)
return;
}
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
if (i > HB_DUMP_ONLINE_NODE_MAX_NUM) {
break;
}

1
core/bus_center/lnn/lane_hub/lane_manager/include/lnn_lane_def.h
View File

@ -97,7 +97,6 @@ typedef struct {
int32_t pid;
LaneTransType transType;
LaneLinkType linkType;
ProtocolType acceptableProtocols;
} LinkRequest;
typedef struct {

1
core/bus_center/lnn/lane_hub/lane_manager/include/lnn_lane_interface.h
View File

@ -137,7 +137,6 @@ typedef struct {
uint32_t expectedBw;
int32_t pid;
LanePreferredLinkList expectedLink;
ProtocolType acceptableProtocols;
} TransOption;
typedef struct {

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

@ -522,11 +522,7 @@ static ProtocolType LnnLaneSelectProtocol(LnnNetIfType ifType, const char *netWo
(void)LnnVisitPhysicalSubnet(FindBestProtocol, &req);
LLOGI("protocol = %ld", req.selectedProtocol);
if (req.selectedProtocol == 0) {
req.selectedProtocol = LNN_PROTOCOL_IP;
}
return req.selectedProtocol;
return LNN_PROTOCOL_IP;
}
static void FillWlanLinkInfo(
@ -558,18 +554,12 @@ NO_SANITIZE("cfi") static int32_t LaneLinkOfWlan(uint32_t reqId, const LinkReque
LLOGE("peer node is not wifi online");
return SOFTBUS_ERR;
}
ProtocolType acceptableProtocols = LNN_PROTOCOL_ALL ^ LNN_PROTOCOL_NIP;
if (reqInfo->transType == LANE_T_MSG || reqInfo->transType == LANE_T_BYTE) {
acceptableProtocols |= LNN_PROTOCOL_NIP;
ProtocolType acceptableProtocols = LNN_PROTOCOL_ALL;
if (reqInfo->transType != LANE_T_MSG && reqInfo->transType != LANE_T_BYTE) {
acceptableProtocols ^= LNN_PROTOCOL_NIP;
}
acceptableProtocols = acceptableProtocols & reqInfo->acceptableProtocols;
ProtocolType protocol =
LnnLaneSelectProtocol(LNN_NETIF_TYPE_WLAN | LNN_NETIF_TYPE_ETH, reqInfo->peerNetworkId, acceptableProtocols);
if (protocol == 0) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "protocal is invalid!");
return SOFTBUS_ERR;
}
if (protocol == LNN_PROTOCOL_IP) {
ret = LnnGetRemoteStrInfo(reqInfo->peerNetworkId, STRING_KEY_WLAN_IP, linkInfo.linkInfo.wlan.connInfo.addr,
sizeof(linkInfo.linkInfo.wlan.connInfo.addr));

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

@ -33,7 +33,6 @@
#include "softbus_log.h"
#include "softbus_utils.h"
#include "softbus_def.h"
#include "softbus_protocol_def.h"
typedef enum {
MSG_TYPE_LANE_TRIGGER_LINK = 0,
@ -178,7 +177,7 @@ static int32_t TriggerLink(uint32_t laneId, TransOption *request,
}
ListTailInsert(&g_multiLinkList, &linkNode->node);
Unlock();
if (PostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneId, request->acceptableProtocols, NULL) != SOFTBUS_OK) {
if (PostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneId, 0, NULL) != SOFTBUS_OK) {
DeleteLaneLinkNode(laneId);
return SOFTBUS_ERR;
}
@ -436,7 +435,6 @@ static LaneLinkNodeInfo *GetLaneLinkNodeWithoutLock(uint32_t laneId)
static void LaneTriggerLink(SoftBusMessage *msg)
{
uint32_t laneId = msg->arg1;
ProtocolType acceptableProtocols = (ProtocolType)msg->arg2;
LaneLinkCb linkCb = {
.OnLaneLinkSuccess = LinkSuccess,
.OnLaneLinkFail = LinkFail,
@ -460,7 +458,6 @@ static void LaneTriggerLink(SoftBusMessage *msg)
nodeInfo->linkRetryIdx++;
requestInfo.pid = nodeInfo->pid;
requestInfo.transType = nodeInfo->transType;
requestInfo.acceptableProtocols = acceptableProtocols;
Unlock();
if (memcpy_s(requestInfo.peerNetworkId, sizeof(requestInfo.peerNetworkId),
nodeInfo->networkId, sizeof(nodeInfo->networkId)) != EOK) {
@ -470,7 +467,7 @@ static void LaneTriggerLink(SoftBusMessage *msg)
if (ret == SOFTBUS_OK) {
return;
}
if (PostMsgToHandler(MSG_TYPE_LANE_LINK_FAIL, laneId, acceptableProtocols, NULL) != SOFTBUS_OK) {
if (PostMsgToHandler(MSG_TYPE_LANE_LINK_FAIL, laneId, ret, NULL) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "post laneLinkFail msg err");
}
}
@ -492,7 +489,7 @@ static void LaneLinkSuccess(SoftBusMessage *msg)
static void LaneLinkFail(SoftBusMessage *msg)
{
uint32_t laneId = (uint32_t)msg->arg1;
int32_t reason = SOFTBUS_ERR;
int32_t reason = (int32_t)msg->arg2;
if (Lock() != SOFTBUS_OK) {
return;
}
@ -510,11 +507,7 @@ static void LaneLinkFail(SoftBusMessage *msg)
}
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "Continue to build link");
Unlock();
ProtocolType acceptableProtocols = (ProtocolType)msg->arg2;
if (msg->arg2 == (uint64_t)SOFTBUS_ERR) {
acceptableProtocols = LNN_PROTOCOL_ALL ^ LNN_PROTOCOL_NIP;
}
if (PostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneId, acceptableProtocols, NULL) != SOFTBUS_OK) {
if (PostMsgToHandler(MSG_TYPE_LANE_TRIGGER_LINK, laneId, 0, NULL) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "post triggerLink msg fail");
return;
}

13
core/bus_center/lnn/net_builder/include/lnn_net_builder.h
View File

@ -31,19 +31,6 @@ typedef enum {
NODE_TYPE_L
} NodeType;
#define JSON_KEY_NODE_CODE "NODE_CODE"
#define JSON_KEY_NODE_ADDR "NODE_ADDR"
#define JSON_KEY_NODE_PROXY_PORT "PROXY_PORT"
#define JSON_KEY_NODE_SESSION_PORT "SESSION_PORT"
typedef struct {
int32_t code;
char nodeAddr[SHORT_ADDRESS_MAX_LEN];
int32_t proxyPort;
int32_t sessionPort;
int32_t authPort;
} LnnNodeAddr;
typedef struct {
ListNode node;
ConnectionAddr addr;

1
core/bus_center/lnn/net_builder/include/lnn_sync_info_manager.h
View File

@ -38,7 +38,6 @@ typedef enum {
LNN_INFO_TYPE_NODE_ADDR,
LNN_INFO_TYPE_NODE_ADDR_DETECTION,
LNN_INFO_TYPE_SYNC_CIPHERKEY,
LNN_INFO_TYPE_ROUTE_LSU,
LNN_INFO_TYPE_COUNT,
} LnnSyncInfoType;

7
core/bus_center/lnn/net_builder/include/lnn_topo_manager.h
View File

@ -30,13 +30,6 @@ typedef struct {
uint8_t relation[CONNECTION_ADDR_MAX];
} LnnRelation;
typedef struct {
ConnectionAddrType type;
uint8_t relation;
bool isJoin;
char udid[UDID_BUF_LEN];
} LnnRelationChangedMsg;
int32_t LnnInitTopoManager(void);
void LnnDeinitTopoManager(void);

3
core/bus_center/lnn/net_builder/src/lnn_devicename_info.c
View File

@ -108,9 +108,6 @@ static void HandlerGetDeviceName(void)
return;
}
for (int32_t i = 0; i < infoNum; i++) {
if (LnnIsLSANode(&info[i])) {
continue;
}
if (LnnSyncDeviceName(info[i].networkId) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnSyncDeviceName fail");
}

113
core/bus_center/lnn/net_builder/src/lnn_net_builder.c
View File

@ -153,12 +153,6 @@ typedef struct {
static NetBuilder g_netBuilder;
static bool g_watchdogFlag = true;
void __attribute__((weak)) SfcSyncNodeAddrHandle(const char *networkId, int32_t code)
{
(void)networkId;
(void)code;
}
NO_SANITIZE("cfi") void SetWatchdogFlag(bool flag)
{
g_watchdogFlag = flag;
@ -1788,85 +1782,70 @@ static void OnReceiveMasterElectMsg(LnnSyncInfoType type, const char *networkId,
}
}
static int32_t LnnUnpackNodeAddr(const uint8_t *data, uint32_t dataLen, LnnNodeAddr *addr)
static void OnReceiveNodeAddrChangedMsg(LnnSyncInfoType type, const char *networkId, const uint8_t *msg, uint32_t size)
{
cJSON *json = cJSON_Parse((char *)data);
if (json == NULL) {
LLOGE("json parse failed");
return SOFTBUS_ERR;
}
if (!GetJsonObjectNumberItem(json, JSON_KEY_NODE_CODE, &addr->code) ||
!GetJsonObjectStringItem(json, JSON_KEY_NODE_ADDR, addr->nodeAddr, SHORT_ADDRESS_MAX_LEN) ||
!GetJsonObjectNumberItem(json, JSON_KEY_NODE_PROXY_PORT, &addr->proxyPort) ||
!GetJsonObjectNumberItem(json, JSON_KEY_NODE_SESSION_PORT, &addr->sessionPort)) {
LLOGE("parse addr info failed");
cJSON_Delete(json);
return SOFTBUS_ERR;
}
cJSON_Delete(json);
return SOFTBUS_OK;
}
static void OnReceiveNodeAddrChangedMsg(LnnSyncInfoType type, const char *networkId,
const uint8_t *msg, uint32_t size)
{
if (type != LNN_INFO_TYPE_NODE_ADDR) {
return;
}
(void)type;
size_t addrLen = strnlen((const char *)msg, size);
if (addrLen != size - 1 || addrLen == 0) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:bad addr received!networkId=%s", __func__,
AnonymizesNetworkID(networkId));
return;
}
LLOGI("networkId=%s", AnonymizesNetworkID(networkId));
LnnNodeAddr addr;
(void)memset_s(&addr, sizeof(LnnNodeAddr), 0, sizeof(LnnNodeAddr));
if (LnnUnpackNodeAddr(msg, size, &addr) != SOFTBUS_OK) {
return;
int ret = LnnSetDLNodeAddr(networkId, CATEGORY_NETWORK_ID, (const char *)msg);
if (ret != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:update node addr failed!networkId=%s,ret=%d", __func__,
AnonymizesNetworkID(networkId), ret);
}
SfcSyncNodeAddrHandle(networkId, addr.code);
if (LnnSetDLNodeAddr(networkId, CATEGORY_NETWORK_ID, addr.nodeAddr) != SOFTBUS_OK) {
return;
}
if (addr.proxyPort > 0) {
(void)LnnSetDLProxyPort(networkId, CATEGORY_NETWORK_ID, addr.proxyPort);
}
if (addr.sessionPort > 0) {
(void)LnnSetDLSessionPort(networkId, CATEGORY_NETWORK_ID, addr.sessionPort);
}
if (addr.authPort > 0) {
(void)LnnSetDLAuthPort(networkId, CATEGORY_NETWORK_ID, addr.authPort);
}
LnnNotifyNodeAddressChanged(addr.nodeAddr, networkId, false);
}
NO_SANITIZE("cfi") int32_t LnnUpdateNodeAddr(const char *addr)
{
if (addr == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:null ptr!", __func__);
return SOFTBUS_INVALID_PARAM;
}
int32_t ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, addr);
if (ret != SOFTBUS_OK) {
LLOGE("set local node addr failed");
return ret;
}
NodeBasicInfo *info = NULL;
int32_t infoNum, i;
char localNetworkId[NETWORK_ID_BUF_LEN] = {0};
ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, sizeof(localNetworkId));
char addrHis[SHORT_ADDRESS_MAX_LEN];
if (LnnGetLocalStrInfo(STRING_KEY_NODE_ADDR, addrHis, SHORT_ADDRESS_MAX_LEN) == SOFTBUS_OK) {
if (strlen(addr) == strlen(addrHis) && (strcmp(addr, addrHis) == 0)) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "%s update the same node addr", __func__);
}
}
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "%s start updating node addr", __func__);
int32_t ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, localNetworkId, sizeof(localNetworkId));
if (ret != SOFTBUS_OK) {
LLOGE("get local network id failed");
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:get local network id failed!", __func__);
return SOFTBUS_ERR;
}
LnnNotifyNodeAddressChanged(addr, localNetworkId, true);
ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, addr);
if (ret != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:set local node addr failed!ret=%d", __func__, ret);
return ret;
}
ret = LnnGetAllOnlineNodeInfo(&info, &infoNum);
if (ret != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:get all online node info fail", __func__);
} else {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "%s:online nodes count=%d", __func__, infoNum);
for (i = 0; i < infoNum; ++i) {
if (strcmp(localNetworkId, info[i].networkId) == 0) {
continue;
}
SoftBusLog(
SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "sync node address to %s", AnonymizesNetworkID(info[i].networkId));
if (LnnSendSyncInfoMsg(LNN_INFO_TYPE_NODE_ADDR, info[i].networkId, (const uint8_t *)addr, strlen(addr) + 1,
NULL) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "sync node address to %s failed",
AnonymizesNetworkID(info[i].networkId));
}
}
SoftBusFree(info);
}
LnnNotifyNodeAddressChanged(addr);
return SOFTBUS_OK;
}

3
core/bus_center/lnn/net_builder/src/lnn_network_info.c
View File

@ -147,9 +147,6 @@ static void SendNetCapabilityToRemote(uint32_t netCapability, uint32_t type)
return;
}
for (int32_t i = 0; i< infoNum; i++) {
if (LnnIsLSANode(&netInfo[i])) {
continue;
}
NodeInfo *nodeInfo = LnnGetNodeInfoById(netInfo[i].networkId, CATEGORY_NETWORK_ID);
if (nodeInfo == NULL) {
continue;

3
core/bus_center/lnn/net_builder/src/lnn_p2p_info.c
View File

@ -115,9 +115,6 @@ static void ProcessSyncP2pInfo(void *para)
}
len = strlen(msg) + 1; /* add 1 for '\0' */
for (i = 0; i < infoNum; i++) {
if (LnnIsLSANode(&info[i])) {
continue;
}
if (LnnSendSyncInfoMsg(LNN_INFO_TYPE_P2P_INFO, info[i].networkId, (uint8_t *)msg, len, NULL) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "sync p2p info to %s fail.", info[i].deviceName);
}

25
core/bus_center/lnn/net_builder/src/lnn_topo_manager.c
View File

@ -49,6 +49,13 @@
#define TOPO_HASH_TABLE_SIZE 16
typedef struct {
ConnectionAddrType type;
uint8_t relation;
bool isJoin;
char udid[UDID_BUF_LEN];
} RelationChangedMsg;
typedef enum {
TOPO_MSG_TYPE_UPDATE,
} TopoUpdateMsgType;
@ -80,11 +87,6 @@ typedef struct {
static TopoHashTable g_topoTable;
void __attribute__((weak)) RouteLnnRelationEventHandler(const LnnRelationChangedMsg *msg)
{
(void)msg;
}
static bool IsSameRelation(const uint8_t *newRelation, const uint8_t *oldRelation, uint32_t len)
{
uint32_t i;
@ -431,9 +433,6 @@ static void ForwardTopoMsgToAll(const char *networkId, const uint8_t *msg, uint3
return;
}
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
if (strcmp(networkId, info[i].networkId) == 0) {
continue;
}
@ -611,9 +610,6 @@ static void NotifyLnnRelationChange(const char *localUdid, const char *udid,
}
msgLen = strlen(msg) + 1;
for (i = 0; i < infoNum; ++i) {
if (LnnIsLSANode(&info[i])) {
continue;
}
if (strcmp(networkId, info[i].networkId) == 0) {
continue;
}
@ -676,12 +672,11 @@ static void OnLnnRelationChangedDelay(void *para)
{
uint8_t newRelation[CONNECTION_ADDR_MAX] = {0};
int32_t rc;
LnnRelationChangedMsg *msg = (LnnRelationChangedMsg *)para;
RelationChangedMsg *msg = (RelationChangedMsg *)para;
if (msg == NULL) {
return;
}
RouteLnnRelationEventHandler(msg);
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "OnLnnRelationChangedDelay: %d", msg->type);
if (msg->type == CONNECTION_ADDR_MAX) {
SoftBusFree(msg);
@ -715,7 +710,7 @@ static void OnLnnRelationChangedDelay(void *para)
static void OnLnnRelationChanged(const LnnEventBasicInfo *info)
{
const LnnRelationChanedEventInfo *eventInfo = (const LnnRelationChanedEventInfo *)info;
LnnRelationChangedMsg *msg = NULL;
RelationChangedMsg *msg = NULL;
if (info == NULL || info->event != LNN_EVENT_RELATION_CHANGED) {
return;
@ -724,7 +719,7 @@ static void OnLnnRelationChanged(const LnnEventBasicInfo *info)
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid relation changed params");
return;
}
msg = (LnnRelationChangedMsg *)SoftBusMalloc(sizeof(LnnRelationChangedMsg));
msg = (RelationChangedMsg *)SoftBusMalloc(sizeof(RelationChangedMsg));
if (msg == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "malloc relation changed msg fail");
return;

3
core/bus_center/lnn/net_buscenter/include/lnn_network_manager.h
View File

@ -59,8 +59,7 @@ typedef VisitNextChoice (*VisitNetifCallback)(const LnnNetIfMgr *, void *);
typedef enum {
LNN_LISTENER_MODE_PROXY,
LNN_LISTENER_MODE_DIRECT,
LNN_LISTENER_MODE_AUTH
LNN_LISTENER_MODE_DIRECT
} ListenerMode;
typedef struct LnnProtocolManager {

4
core/bus_center/lnn/net_buscenter/net_manager.gni
View File

@ -32,7 +32,7 @@ if (dsoftbus_feature_conn_br || dsoftbus_feature_conn_ble) {
bus_center_net_mgr_deps = []
native_source_path = rebase_path("$dsoftbus_root_path")
newip_dir = "dsoftbus_enhance/components/newip/network"
newip_dir = "dsoftbus_enhance/components/newip"
newip_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
[
"$native_source_path",
@ -42,7 +42,7 @@ newip_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
if (newip_enhanced) {
import(
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/network/network.gni")
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/newip.gni")
bus_center_net_mgr_src += newip_manager_src
bus_center_net_mgr_inc += newip_manager_include

39
core/bus_center/lnn/net_buscenter/src/lnn_ip_network_impl.c
View File

@ -65,25 +65,16 @@ static int32_t OpenAuthPort(void)
int32_t port;
char localIp[MAX_ADDR_LEN] = {0};
int32_t authPort;
if (LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &authPort) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get port failed");
authPort = 0;
}
if (LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, localIp, MAX_ADDR_LEN) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ip failed");
return SOFTBUS_ERR;
}
port = AuthStartListening(AUTH_LINK_TYPE_WIFI, localIp, authPort);
port = AuthStartListening(AUTH_LINK_TYPE_WIFI, localIp, 0);
if (port < 0) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AuthStartListening failed");
return SOFTBUS_ERR;
}
if (authPort == 0) {
return LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, port);
}
return SOFTBUS_OK;
return LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, port);
}
static void CloseAuthPort(void)
@ -94,18 +85,12 @@ static void CloseAuthPort(void)
static int32_t OpenSessionPort(void)
{
int32_t sessionPort;
if (LnnGetLocalNumInfo(NUM_KEY_SESSION_PORT, &sessionPort) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get port failed");
sessionPort = 0;
}
int32_t port;
LocalListenerInfo info = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "",
.port = sessionPort,
.port = 0,
.moduleId = DIRECT_CHANNEL_SERVER_WIFI,
.protocol = LNN_PROTOCOL_IP,
}
@ -119,11 +104,7 @@ static int32_t OpenSessionPort(void)
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open session server failed");
return SOFTBUS_ERR;
}
if (sessionPort == 0) {
return LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, port);
}
return SOFTBUS_OK;
return LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, port);
}
static void CloseSessionPort(void)
@ -134,17 +115,11 @@ static void CloseSessionPort(void)
static void OpenProxyPort(void)
{
int32_t proxyPort;
if (LnnGetLocalNumInfo(NUM_KEY_PROXY_PORT, &proxyPort) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get port failed");
proxyPort = 0;
}
LocalListenerInfo listenerInfo = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "",
.port = proxyPort,
.port = 0,
.moduleId = PROXY,
.protocol = LNN_PROTOCOL_IP,
}
@ -160,9 +135,7 @@ static void OpenProxyPort(void)
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open proxy server failed");
return;
}
if (proxyPort == 0) {
(void)LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, port);
}
(void)LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, port);
}
static void CloseProxyPort(void)

2
core/bus_center/lnn/net_buscenter/src/lnn_network_manager.c
View File

@ -60,7 +60,7 @@ int32_t __attribute__((weak)) RegistNewIPProtocolManager(void)
return SOFTBUS_OK;
}
int32_t __attribute__((weak)) RegistBtProtocolManager(void)
int32_t __attribute__ ((weak)) RegistBtProtocolManager(void)
{
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "regist virtual bt protocol manager");
return SOFTBUS_OK;

2
core/bus_center/lnn/net_buscenter/src/lnn_physical_subnet_manager.c
View File

@ -23,7 +23,7 @@
#include "softbus_errcode.h"
#include "softbus_log.h"
#define MAX_SUPPORTED_PHYSICAL_SUBNET 6
#define MAX_SUPPORTED_PHYSICAL_SUBNET 4
static SoftBusMutex g_physicalSubnetsLock;
static LnnPhysicalSubnet *g_physicalSubnets[MAX_SUPPORTED_PHYSICAL_SUBNET];

2
core/bus_center/lnn/net_ledger/common/include/lnn_node_info.h
View File

@ -55,7 +55,6 @@ typedef enum {
DISCOVERY_TYPE_BLE,
DISCOVERY_TYPE_BR,
DISCOVERY_TYPE_P2P,
DISCOVERY_TYPE_LSA,
DISCOVERY_TYPE_COUNT,
} DiscoveryType;
@ -118,7 +117,6 @@ bool LnnHasSupportDiscoveryType(const char *destType, const char *type);
bool LnnPeerHasExchangeDiscoveryType(const NodeInfo *info, DiscoveryType type);
const char *LnnGetDeviceUdid(const NodeInfo *info);
int32_t LnnSetDeviceUdid(NodeInfo *info, const char *udid);
const char *LnnGetDeviceUuid(const NodeInfo *info);
bool LnnHasDiscoveryType(const NodeInfo *info, DiscoveryType type);
int32_t LnnSetDiscoveryType(NodeInfo *info, DiscoveryType type);
int32_t LnnClearDiscoveryType(NodeInfo *info, DiscoveryType type);

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

@ -99,8 +99,6 @@ static int32_t LnnGetNodeKeyInfoLocal(const char *networkId, int key, uint8_t *i
return LnnGetLocalNumInfo(NUM_KEY_DISCOVERY_TYPE, (int32_t *)info);
case NODE_KEY_DATA_CHANGE_FLAG:
return LnnGetLocalNum16Info(NUM_KEY_DATA_CHANGE_FLAG, (int16_t *)info);
case NODE_KEY_NODE_ADDRESS:
return LnnGetLocalStrInfo(STRING_KEY_NODE_ADDR, (char *)info, infoLen);
default:
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid node key type: %d", key);
return SOFTBUS_ERR;
@ -132,8 +130,6 @@ static int32_t LnnGetNodeKeyInfoRemote(const char *networkId, int key, uint8_t *
return LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, (int32_t *)info);
case NODE_KEY_DATA_CHANGE_FLAG:
return LnnGetRemoteNum16Info(networkId, NUM_KEY_DATA_CHANGE_FLAG, (int16_t *)info);
case NODE_KEY_NODE_ADDRESS:
return LnnGetRemoteStrInfo(networkId, STRING_KEY_NODE_ADDR, (char *)info, infoLen);
default:
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid node key type: %d", key);
return SOFTBUS_ERR;
@ -205,8 +201,6 @@ NO_SANITIZE("cfi") int32_t LnnGetNodeKeyInfoLen(int32_t key)
return LNN_COMMON_LEN;
case NODE_KEY_DATA_CHANGE_FLAG:
return DATA_CHANGE_FLAG_BUF_LEN;
case NODE_KEY_NODE_ADDRESS:
return SHORT_ADDRESS_MAX_LEN;
default:
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid node key type: %d", key);
return SOFTBUS_ERR;

10
core/bus_center/lnn/net_ledger/common/src/lnn_node_info.c
View File

@ -149,14 +149,6 @@ NO_SANITIZE("cfi") int32_t LnnSetDeviceUdid(NodeInfo *info, const char *udid)
return SOFTBUS_OK;
}
NO_SANITIZE("cfi") const char *LnnGetDeviceUuid(const NodeInfo *info)
{
if (info == NULL) {
return NULL;
}
return info->uuid;
}
NO_SANITIZE("cfi") int32_t LnnSetDiscoveryType(NodeInfo *info, DiscoveryType type)
{
if (info == NULL || type >= DISCOVERY_TYPE_COUNT) {
@ -423,7 +415,7 @@ NO_SANITIZE("cfi") const char *LnnGetP2pGoMac(const NodeInfo *info)
NO_SANITIZE("cfi") uint64_t LnnGetSupportedProtocols(const NodeInfo *info)
{
if (info == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
return 0;
}
return info->supportedProtocols;

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

@ -80,10 +80,6 @@ void LnnRefreshDeviceOnlineStateAndDevIdInfo(const char *pkgName, DeviceInfo *de
int32_t LnnUpdateNodeInfo(NodeInfo *newInfo);
int32_t LnnAddMetaInfo(NodeInfo *info);
int32_t LnnDeleteMetaInfo(const char *udid, ConnectionAddrType type);
int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort);
int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort);
int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort);
bool LnnHasIpByUuid(const char *uuid);
#ifdef __cplusplus
}
#endif

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

@ -871,8 +871,7 @@ NO_SANITIZE("cfi") int32_t LnnUpdateNodeInfo(NodeInfo *newInfo)
SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_ERR;
}
if (LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_WIFI) ||
LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_LSA)) {
if (LnnHasDiscoveryType(newInfo, DISCOVERY_TYPE_WIFI)) {
oldInfo->discoveryType = newInfo->discoveryType | oldInfo->discoveryType;
oldInfo->connectInfo.authPort = newInfo->connectInfo.authPort;
oldInfo->connectInfo.proxyPort = newInfo->connectInfo.proxyPort;
@ -1370,38 +1369,6 @@ static int32_t GetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNu
return ret;
}
NO_SANITIZE("cfi") bool LnnIsLSANode(const NodeBasicInfo *info)
{
NodeInfo *nodeInfo = LnnGetNodeInfoById(info->networkId, CATEGORY_NETWORK_ID);
if (nodeInfo != NULL && LnnHasDiscoveryType(nodeInfo, DISCOVERY_TYPE_LSA)) {
return true;
}
return false;
}
NO_SANITIZE("cfi") bool LnnHasIpByUuid(const char *uuid)
{
bool hasIp = true;
NodeInfo *info = LnnGetNodeInfoById(uuid, CATEGORY_UUID);
if (info == NULL) {
return true;
}
if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_LSA)) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "node is lsa neighbor");
return true;
}
if (strnlen(info->connectInfo.deviceIp, IP_LEN) == 0 ||
strncmp(info->connectInfo.deviceIp, LOCAL_IP, sizeof(LOCAL_IP)) == 0) {
hasIp = false;
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "not has ip addr");
} else {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "has ip addr");
}
return hasIp;
}
NO_SANITIZE("cfi") int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
{
return GetAllOnlineAndMetaNodeInfo(info, infoNum, false);
@ -1676,57 +1643,6 @@ NO_SANITIZE("cfi") int32_t LnnSetDLNodeAddr(const char *id, IdCategory type, con
return ret == EOK ? SOFTBUS_OK : SOFTBUS_ERR;
}
int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort)
{
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
return SOFTBUS_ERR;
}
NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
if (nodeInfo == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
(void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_ERR;
}
nodeInfo->connectInfo.proxyPort = proxyPort;
(void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_OK;
}
int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort)
{
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
return SOFTBUS_ERR;
}
NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
if (nodeInfo == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
(void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_ERR;
}
nodeInfo->connectInfo.sessionPort = sessionPort;
(void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_OK;
}
int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort)
{
if (SoftBusMutexLock(&g_distributedNetLedger.lock) != 0) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!");
return SOFTBUS_ERR;
}
NodeInfo *nodeInfo = LnnGetNodeInfoById(id, type);
if (nodeInfo == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get info fail");
(void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_ERR;
}
nodeInfo->connectInfo.authPort = authPort;
(void)SoftBusMutexUnlock(&g_distributedNetLedger.lock);
return SOFTBUS_OK;
}
int32_t SoftBusDumpBusCenterRemoteDeviceInfo(int32_t fd)
{
SOFTBUS_DPRINTF(fd, "-----RemoteDeviceInfo-----\n");

6
core/bus_center/lnn/net_ledger/distributed_ledger/src/lnn_distributed_net_ledger_virtual.c
View File

@ -45,12 +45,6 @@ int32_t LnnGetDLNumInfo(const char *networkId, InfoKey key, int32_t *info)
return SOFTBUS_NOT_IMPLEMENT;
}
bool LnnIsLSANode(const NodeBasicInfo *info)
{
(void)info;
return true;
}
int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
{
(void)info;

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

@ -981,10 +981,6 @@ NO_SANITIZE("cfi") int32_t LnnInitLocalLedger(void)
if (InitOfflineCode(nodeInfo) != SOFTBUS_OK) {
goto EXIT;
}
if (strcpy_s(nodeInfo->nodeAddress, sizeof(nodeInfo->nodeAddress), NODE_ADDR_LOOPBACK) != EOK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail:strncpy_s fail!");
goto EXIT;
}
if (InitLocalDeviceInfo(deviceInfo) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init local device info error!");
goto EXIT;

7
core/bus_center/service/include/bus_center_event.h
View File

@ -39,7 +39,6 @@ typedef enum {
LNN_EVENT_RELATION_CHANGED,
LNN_EVENT_NODE_MASTER_STATE_CHANGED,
LNN_EVENT_NODE_ADDR_CHANGED,
LNN_EVENT_NODE_HB_REPEAT_CYCLE,
LNN_EVENT_TYPE_MAX,
} LnnEventType;
@ -127,9 +126,7 @@ typedef struct {
typedef struct {
LnnEventBasicInfo basic;
char addr[SHORT_ADDRESS_MAX_LEN];
char networkId[NETWORK_ID_BUF_LEN];
bool delFlag;
bool isLocal;
} LnnNodeAddrChangedEvent;
typedef void (*LnnEventHandler)(const LnnEventBasicInfo *info);
@ -161,9 +158,7 @@ void LnnNotifyTimeSyncResult(const char *pkgName, int32_t pid, const TimeSyncRes
void LnnNotifyMasterNodeChanged(bool isMaster, const char* masterNodeUdid, int32_t weight);
void LnnNotifyNodeAddressChanged(const char *addr, const char *networkId, bool isLocal);
void LnnNotifyHBRepeat(void);
void LnnNotifyNodeAddressChanged(const char* addr);
#ifdef __cplusplus
}

17
core/bus_center/service/src/bus_center_event.c
View File

@ -356,17 +356,17 @@ NO_SANITIZE("cfi") void LnnNotifyMasterNodeChanged(bool isMaster, const char *ma
NotifyEvent((const LnnEventBasicInfo *)&event);
}
NO_SANITIZE("cfi") void LnnNotifyNodeAddressChanged(const char *addr, const char *networkId, bool isLocal)
NO_SANITIZE("cfi") void LnnNotifyNodeAddressChanged(const char *addr)
{
if (addr == NULL) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:nullptr!", __func__);
return;
}
LnnNodeAddrChangedEvent eventInfo;
(void)memset_s(&eventInfo, sizeof(eventInfo), 0, sizeof(eventInfo));
eventInfo.basic.event = LNN_EVENT_NODE_ADDR_CHANGED;
if (strcpy_s(eventInfo.addr, sizeof(eventInfo.addr), addr) != EOK ||
strcpy_s(eventInfo.networkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
if (strcpy_s(eventInfo.addr, sizeof(eventInfo.addr), addr) != EOK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:strcpy_s failed", __func__);
return;
}
if (strcmp(addr, NODE_ADDR_LOOPBACK) == 0) {
@ -374,18 +374,9 @@ NO_SANITIZE("cfi") void LnnNotifyNodeAddressChanged(const char *addr, const char
} else {
eventInfo.delFlag = false;
}
eventInfo.isLocal = isLocal;
NotifyEvent((LnnEventBasicInfo *)&eventInfo);
}
NO_SANITIZE("cfi") void LnnNotifyHBRepeat(void)
{
LnnEventBasicInfo event;
event.event = LNN_EVENT_NODE_HB_REPEAT_CYCLE;
NotifyEvent(&event);
}
NO_SANITIZE("cfi") int32_t LnnInitBusCenterEvent(void)
{
int32_t i;

11
core/bus_center/service/src/bus_center_manager.c
View File

@ -46,12 +46,6 @@ int32_t __attribute__((weak)) InitNodeAddrAllocator(void)
}
void __attribute__((weak)) DeinitNodeAddrAllocator(void) {}
int32_t __attribute__((weak)) RouteLSInit(void)
{
return SOFTBUS_OK;
}
void __attribute__((weak)) RouteLSDeinit(void) {}
typedef int32_t (*LnnInitDelayImpl)(void);
typedef enum {
@ -198,10 +192,6 @@ NO_SANITIZE("cfi") int32_t BusCenterServerInit(void)
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init nodeAddr failed.");
return SOFTBUS_ERR;
}
if (RouteLSInit() != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init route failed.");
return SOFTBUS_ERR;
}
if (StartDelayInit() != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start delay init fail!");
return SOFTBUS_ERR;
@ -212,7 +202,6 @@ NO_SANITIZE("cfi") int32_t BusCenterServerInit(void)
NO_SANITIZE("cfi") void BusCenterServerDeinit(void)
{
RouteLSDeinit();
DeinitNodeAddrAllocator();
LnnDeinitLaneHub();
LnnDeinitNetBuilder();

1
core/common/include/softbus_utils.h
View File

@ -50,7 +50,6 @@ typedef enum {
SOFTBUS_UDP_CHANNEL_TIMER_FUN,
SOFTBUS_TIME_SYNC_TIMER_FUN,
SOFTBUS_PROXY_SENDFILE_TIMER_FUN,
SOFTBUS_NIP_NODE_AGING_TIMER_FUN,
SOFTBUS_MAX_TIMER_FUN_NUM
} SoftBusTimerFunEnum;

1
core/connection/br/include/softbus_conn_br_manager.h
View File

@ -34,7 +34,6 @@ extern "C" {
#define BR_CONNECTION_PEND_TIMEOUT_MAX_MILLIS (20 * 1000)
#define BR_CONNECTION_ACL_CONNECT_COLLISION_MILLIS (6 * 1000)
#define BR_WAIT_BLE_DISCONNECTED_PEND_MILLIS (20 * 1000)
#define BR_NIP_SEQ (0xeaddeaddeaddeadd)
enum ConnBrDeviceState {
BR_DEVICE_STATE_INIT,

1
core/connection/br/include/softbus_conn_br_trans.h
View File

@ -70,7 +70,6 @@ typedef struct {
} ConnBrTransEventListener;
int32_t ConnBrTransReadOneFrame(uint32_t connectionId, int32_t socketHandle, LimitedBuffer *buffer, uint8_t **outData);
int32_t BrTransSend(uint32_t connectionId, int32_t socketHandle, uint32_t mtu, const uint8_t *data, uint32_t dataLen);
int64_t ConnBrPackCtlMessage(BrCtlMessageSerializationContext ctx, uint8_t **outData, uint32_t *outLen);
int32_t ConnBrPostBytes(
uint32_t connectionId, uint8_t *data, uint32_t len, int32_t pid, int32_t flag, int32_t module, int64_t seq);

27
core/connection/br/src/softbus_conn_br_manager.c
View File

@ -93,23 +93,6 @@ static SoftBusHandlerWrapper g_brManagerAsyncHandler = {
.eventCompareFunc = BrCompareManagerLooperEventFunc,
};
void __attribute__((weak)) NipRecvDataFromBr(uint32_t connId, const char *buf, int32_t len)
{
(void)connId;
(void)buf;
}
void __attribute__((weak)) NipConnectDevice(uint32_t connId, const char *mac)
{
(void)connId;
(void)mac;
}
void __attribute__((weak)) NipDisconnectDevice(uint32_t connId)
{
(void)connId;
}
static void DfxRecordBrConnectFail(uint32_t reqId, uint32_t pId, ConnBrDevice *device,
const ConnectStatistics *statistics, int32_t reason)
{
@ -247,12 +230,6 @@ static void NotifyDeviceConnectResult(
char anomizeAddress[BT_MAC_LEN] = { 0 };
ConvertAnonymizeMacAddress(anomizeAddress, BT_MAC_LEN, device->addr, BT_MAC_LEN);
if (reason == 0) {
NipConnectDevice(connection->connectionId, connection->addr);
} else {
NipDisconnectDevice(connection->connectionId);
}
ConnBrRequest *it = NULL;
if (connection == NULL) {
LIST_FOR_EACH_ENTRY(it, &device->requests, ConnBrRequest, node) {
@ -771,8 +748,6 @@ static void DataReceived(ConnBrDataReceivedContext *ctx)
ctx->connectionId, ctx->dataLen, head->flag, head->module, head->seq);
if (head->module == MODULE_CONNECTION) {
ReceivedControlData(connection, ctx->data + ConnGetHeadSize(), ctx->dataLen - ConnGetHeadSize());
} else if (head->module == MODULE_NIP_BR_CHANNEL && head->seq == (int64_t)BR_NIP_SEQ) {
NipRecvDataFromBr(ctx->connectionId, (char *)ctx->data, ctx->dataLen);
} else {
g_connectCallback.OnDataReceived(
ctx->connectionId, (ConnModule)head->module, head->seq, (char *)ctx->data, ctx->dataLen);
@ -1446,7 +1421,6 @@ static int32_t BrDisconnectDevice(uint32_t connectionId)
"br disconnect device failed: connection not exist, connection id=%u", connectionId);
char animizeAddress[BT_MAC_LEN] = { 0 };
ConvertAnonymizeMacAddress(animizeAddress, BT_MAC_LEN, connection->addr, BT_MAC_LEN);
NipDisconnectDevice(connection->connectionId);
ConnBrReturnConnection(&connection);
int32_t status = ConnPostMsgToLooper(&g_brManagerAsyncHandler, MGR_DISCONNECT_REQUEST, connectionId, 0, NULL, 0);
CLOGI("br disconnect device, connection id=%u, address=%s, status=%d", connectionId, animizeAddress, status);
@ -1468,7 +1442,6 @@ static int32_t BrDisconnectDeviceNow(const ConnectOption *option)
CONN_CHECK_AND_RETURN_RET_LOG(connection != NULL, SOFTBUS_CONN_BR_CONNECTION_NOT_EXIST_ERR,
"br disconnect device now failed: connection is not exist, address=%s, side=%d", animizeAddress,
option->brOption.sideType);
NipDisconnectDevice(connection->connectionId);
ConnBrDisconnectNow(connection);
ConnBrReturnConnection(&connection);
return SOFTBUS_OK;

2
core/connection/br/src/softbus_conn_br_trans.c
View File

@ -107,7 +107,7 @@ int32_t ConnBrTransReadOneFrame(uint32_t connectionId, int32_t socketHandle, Lim
}
}
NO_SANITIZE("cfi") int32_t BrTransSend(
static int32_t BrTransSend(
uint32_t connectionId, int32_t socketHandle, uint32_t mtu, const uint8_t *data, uint32_t dataLen)
{
uint32_t waitWriteLen = dataLen;

4
core/connection/common/conn_common.gni
View File

@ -27,7 +27,7 @@ conn_common_inc = [
]
native_source_path = rebase_path("$dsoftbus_root_path")
newip_dir = "dsoftbus_enhance/components/newip/network"
newip_dir = "dsoftbus_enhance/components/newip"
newip_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
[
"$native_source_path",
@ -37,7 +37,7 @@ newip_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py",
if (newip_enhanced) {
import(
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/network/network.gni")
"//foundation/communication/dsoftbus/dsoftbus_enhance/components/newip/newip.gni")
conn_common_src += newip_connection_src
conn_common_inc += newip_connection_include

1
core/connection/interface/softbus_conn_interface.h
View File

@ -47,7 +47,6 @@ typedef enum {
MODULE_META_AUTH = 21,
MODULE_BLE_NET = 100,
MODULE_BLE_CONN = 101,
MODULE_NIP_BR_CHANNEL = 201,
MODULE_OLD_NEARBY = 300,
} ConnModule;

3
core/connection/tcp/src/softbus_tcp_connect_manager.c
View File

@ -184,8 +184,7 @@ static void DelTcpConnNode(uint32_t connectionId)
return;
}
NO_SANITIZE("cfi") static int32_t TcpOnConnectEvent(ListenerModule module, int32_t cfd,
const ConnectOption *clientAddr)
NO_SANITIZE("cfi") static int32_t TcpOnConnectEvent(ListenerModule module, int32_t cfd, const ConnectOption *clientAddr)
{
if (cfd < 0 || clientAddr == NULL) {
return SOFTBUS_INVALID_PARAM;

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

@ -28,7 +28,6 @@
#include "softbus_log.h"
#include "softbus_utils.h"
#include "trans_session_manager.h"
#include "lnn_distributed_net_ledger.h"
#define TRANS_REQUEST_PENDING_TIMEOUT (5000)
@ -331,13 +330,6 @@ static int32_t GetRequestOptionBySessionParam(const SessionParam *param, LaneReq
requestOption->requestInfo.trans.transType = transType;
requestOption->requestInfo.trans.expectedBw = 0; /* init expectBW */
requestOption->requestInfo.trans.acceptableProtocols = LNN_PROTOCOL_ALL ^ LNN_PROTOCOL_NIP;
NodeInfo *info = LnnGetNodeInfoById(requestOption->requestInfo.trans.networkId, CATEGORY_NETWORK_ID);
if (info != NULL && LnnHasDiscoveryType(info, DISCOVERY_TYPE_LSA)) {
requestOption->requestInfo.trans.acceptableProtocols |= LNN_PROTOCOL_NIP;
}
int32_t uid;
if (TransGetUidAndPid(param->sessionName, &uid, &(requestOption->requestInfo.trans.pid)) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "transGetUidAndPid failed.");

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

@ -40,7 +40,6 @@
#include "trans_udp_negotiation.h"
#include "softbus_hisysevt_transreporter.h"
#include "trans_tcp_direct_sessionconn.h"
#include "lnn_network_manager.h"
NO_SANITIZE("cfi") int32_t TransChannelInit(void)
{
@ -202,18 +201,6 @@ static int32_t TransOpenChannelProc(ChannelType type, AppInfo *appInfo, const Co
return SOFTBUS_OK;
}
static void TransOpenChannelSetModule(int32_t channelType, ConnectOption *connOpt)
{
if (connOpt->type != CONNECT_TCP || connOpt->socketOption.protocol != LNN_PROTOCOL_NIP ||
channelType != CHANNEL_TYPE_PROXY) {
return;
}
int32_t module = LnnGetProtocolListenerModule(connOpt->socketOption.protocol, LNN_LISTENER_MODE_PROXY);
if (module != UNUSE_BUTT) {
connOpt->socketOption.moduleId = module;
}
}
NO_SANITIZE("cfi") int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo)
{
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "server TransOpenChannel");
@ -248,7 +235,6 @@ NO_SANITIZE("cfi") int32_t TransOpenChannel(const SessionParam *param, TransInfo
}
transInfo->channelType = TransGetChannelType(param, &connInfo);
TransOpenChannelSetModule(transInfo->channelType, &connOpt);
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "lane[%u] get channel type[%u].", laneId, transInfo->channelType);
if (TransOpenChannelProc((ChannelType)transInfo->channelType, appInfo, &connOpt,

3
core/transmission/trans_channel/manager/src/trans_link_listener.c
View File

@ -54,9 +54,6 @@ static int32_t GetNetworkIdByP2pMac(const char *peerMac, char *networkId, int32_
for (int32_t i = 0; i < num; i++) {
char p2pMac[MAC_LEN] = {0};
char *tmpNetworkId = info[i].networkId;
if (LnnIsLSANode(&info[i])) {
continue;
}
if (LnnGetRemoteStrInfo(tmpNetworkId, STRING_KEY_P2P_MAC, p2pMac, sizeof(p2pMac)) != SOFTBUS_OK) {
continue;
}

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

@ -223,7 +223,6 @@ static int32_t TransGetConnectOption(const char *peerNetworkId, ConnectOption *c
option.requestInfo.trans.pid = DEFAULT_PID;
option.requestInfo.trans.transType = LANE_T_MSG;
option.requestInfo.trans.expectedBw = 0;
option.requestInfo.trans.acceptableProtocols = LNN_PROTOCOL_ALL ^ LNN_PROTOCOL_NIP;
if (memcpy_s(option.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
peerNetworkId, NETWORK_ID_BUF_LEN) != EOK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "memcpy networkId failed.");

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

@ -39,7 +39,6 @@
#include "trans_channel_limit.h"
#include "trans_pending_pkt.h"
#include "softbus_adapter_hitracechain.h"
#include "lnn_distributed_net_ledger.h"
#define ID_OFFSET (1)
@ -958,13 +957,8 @@ NO_SANITIZE("cfi") int32_t TransProxyCreateChanInfo(ProxyChannelInfo *chan, int3
return SOFTBUS_ERR;
}
bool hasIp = false;
if (chan->type == CONNECT_TCP) {
hasIp = LnnHasIpByUuid(appInfo->peerData.deviceId);
}
if (appInfo->appType != APP_TYPE_AUTH) {
chan->authId = AuthGetLatestIdByUuid(appInfo->peerData.deviceId, hasIp, false);
chan->authId = AuthGetLatestIdByUuid(appInfo->peerData.deviceId, chan->type == CONNECT_TCP, false);
if (chan->authId == AUTH_INVALID_ID) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get authId for cipher err");
return SOFTBUS_ERR;

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

@ -32,7 +32,6 @@
#include "softbus_datahead_transform.h"
#include "softbus_adapter_socket.h"
#include "softbus_proxychannel_callback.h"
#include "lnn_distributed_net_ledger.h"
static int32_t TransProxyParseMessageHead(char *data, int32_t len, ProxyMessage *msg)
{
@ -106,7 +105,7 @@ static int32_t GetRemoteBtMacByUdidHash(const char *udidHash, char *brMac, int32
}
static int32_t TransProxyGetAuthConnInfo(uint32_t connId, AuthConnInfo *connInfo, uint8_t cipher)
static int32_t TransProxyGetAuthConnInfo(uint32_t connId, AuthConnInfo *connInfo)
{
ConnectionInfo info = {0};
if (ConnGetConnectionInfo(connId, &info) != SOFTBUS_OK) {
@ -115,9 +114,10 @@ static int32_t TransProxyGetAuthConnInfo(uint32_t connId, AuthConnInfo *connInfo
}
switch (info.type) {
case CONNECT_TCP:
if (AuthGetConnByNodeAddr(info.socketInfo.addr, (uint32_t)cipher, connInfo) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get auth conn fail.");
return SOFTBUS_ERR;
connInfo->type = AUTH_LINK_TYPE_WIFI;
if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, info.socketInfo.addr) != EOK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "copy ip fail.");
return SOFTBUS_MEM_ERR;
}
break;
case CONNECT_BR:
@ -180,7 +180,7 @@ static int32_t ConvertBleConnInfo2BrConnInfo(AuthConnInfo *connInfo)
static int64_t GetAuthIdByHandshakeMsg(uint32_t connId, uint8_t cipher)
{
AuthConnInfo connInfo;
if (TransProxyGetAuthConnInfo(connId, &connInfo, cipher) != SOFTBUS_OK) {
if (TransProxyGetAuthConnInfo(connId, &connInfo) != SOFTBUS_OK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get connInfo fail connId[%d]", connId);
return AUTH_INVALID_ID;
}

9
core/transmission/trans_channel/proxy/src/softbus_proxychannel_transceiver.c
View File

@ -695,14 +695,7 @@ NO_SANITIZE("cfi") int32_t TransProxyOpenConnChannel(const AppInfo *appInfo, con
if (TransGetConn(connInfo, &conn) == SOFTBUS_OK) {
ret = TransProxyConnExistProc(&conn, appInfo, chanNewId);
} else {
ListenerModule module = PROXY;
if (connInfo->type == CONNECT_TCP) {
module = LnnGetProtocolListenerModule(connInfo->socketOption.protocol, LNN_LISTENER_MODE_PROXY);
if (module == UNUSE_BUTT) {
return SOFTBUS_INVALID_PARAM;
}
}
ret = TransProxyOpenNewConnChannel(module, appInfo, connInfo, chanNewId);
ret = TransProxyOpenNewConnChannel(PROXY, appInfo, connInfo, chanNewId);
}
if (ret == SOFTBUS_OK) {
*channelId = chanNewId;

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

@ -557,8 +557,9 @@ static int64_t GetAuthIdByChannelInfo(int32_t channelId, uint64_t seq, uint32_t
char p2pMac[P2P_MAC_LEN] = {0};
if (P2pLinkGetPeerMacByPeerIp(appInfo.peerData.addr, p2pMac, sizeof(p2pMac)) != SOFTBUS_OK) {
AuthConnInfo connInfo;
(void)memset_s(&connInfo, sizeof(connInfo), 0, sizeof(connInfo));
if (AuthGetConnByNodeAddr(appInfo.peerData.addr, cipherFlag, &connInfo) != SOFTBUS_OK) {
connInfo.type = AUTH_LINK_TYPE_WIFI;
if (strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, appInfo.peerData.addr) != EOK) {
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "copy ip addr fail");
return AUTH_INVALID_ID;
}
return AuthGetIdByConnInfo(&connInfo, !fromAuthServer, false);

10
core/transmission/trans_channel/tcp_direct/src/trans_tcp_direct_wifi.c
View File

@ -27,7 +27,6 @@
#include "trans_tcp_direct_message.h"
#include "trans_tcp_direct_sessionconn.h"
#include "softbus_adapter_hitracechain.h"
#include "lnn_distributed_net_ledger.h"
#define ID_OFFSET (1)
@ -39,10 +38,8 @@ NO_SANITIZE("cfi") int32_t OpenTcpDirectChannel(const AppInfo *appInfo, const Co
return SOFTBUS_INVALID_PARAM;
}
ListenerModule module = LnnGetProtocolListenerModule(connInfo->socketOption.protocol, LNN_LISTENER_MODE_DIRECT);
if (module == UNUSE_BUTT) {
return SOFTBUS_INVALID_PARAM;
}
ListenerModule module = DIRECT_CHANNEL_SERVER_WIFI;
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "%s:get listener module %d!", __func__, module);
SessionConn *newConn = CreateNewSessinConn(module, false);
if (newConn == NULL) {
@ -54,8 +51,7 @@ NO_SANITIZE("cfi") int32_t OpenTcpDirectChannel(const AppInfo *appInfo, const Co
int32_t newchannelId = newConn->channelId;
(void)memcpy_s(&newConn->appInfo, sizeof(AppInfo), appInfo, sizeof(AppInfo));
bool hasIp = LnnHasIpByUuid(newConn->appInfo.peerData.deviceId);
newConn->authId = AuthGetLatestIdByUuid(newConn->appInfo.peerData.deviceId, hasIp, false);
newConn->authId = AuthGetLatestIdByUuid(newConn->appInfo.peerData.deviceId, true, false);
if (newConn->authId == AUTH_INVALID_ID) {
SoftBusFree(newConn);
SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "OpenTcpDirectChannel get authId fail");

1
interfaces/kits/bus_center/softbus_bus_center.h
View File

@ -156,7 +156,6 @@ typedef enum {
NODE_KEY_NETWORK_TYPE, /**< Network type in number format */
NODE_KEY_BLE_OFFLINE_CODE, /**< Ble offlinecode in string format */
NODE_KEY_DATA_CHANGE_FLAG,
NODE_KEY_NODE_ADDRESS, /**< Node address in string format */
} NodeDeviceInfoKey;
/**

2
interfaces/kits/common/softbus_common.h
View File

@ -189,7 +189,7 @@ extern "C" {
* @brief Indicates the maximum length of the node address.
*
*/
#define SHORT_ADDRESS_MAX_LEN 20
#define SHORT_ADDRESS_MAX_LEN 8
/**
* @brief Indicates the maximum num of the node status.

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

@ -28,7 +28,6 @@ ohos_unittest("AuthTest") {
"$dsoftbus_root_path/core/bus_center/utils/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/common/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/distributed_ledger/include",
"$dsoftbus_root_path/core/common/include",
"$dsoftbus_root_path/core/common/message_handler/include",
"$dsoftbus_root_path/core/connection/interface",

10
tests/core/authentication/unittest/auth_net_ledger_mock.cpp
View File

@ -158,16 +158,6 @@ bool LnnPeerHasExchangeDiscoveryType(const NodeInfo *info, DiscoveryType type)
{
return GetNetLedgerInterface()->LnnPeerHasExchangeDiscoveryType(info, type);
}
void RouteBuildClientAuthManager(int32_t cfd)
{
return GetNetLedgerInterface()->RouteBuildClientAuthManager(cfd);
}
void RouteClearAuthChannelId(int32_t cfd)
{
return GetNetLedgerInterface()->RouteClearAuthChannelId(cfd);
}
}
char *AuthNetLedgertInterfaceMock::Pack(int64_t authSeq, const AuthSessionInfo *info, AuthDataHead &head)

4
tests/core/authentication/unittest/auth_net_ledger_mock.h
View File

@ -58,8 +58,6 @@ public:
virtual int32_t LnnSetSupportDiscoveryType(char *info, const char *type) = 0;
virtual bool LnnHasSupportDiscoveryType(const char *destType, const char *type) = 0;
virtual bool LnnPeerHasExchangeDiscoveryType(const NodeInfo *info, DiscoveryType type) = 0;
virtual void RouteBuildClientAuthManager(int32_t cfd) = 0;
virtual void RouteClearAuthChannelId(int32_t cfd) = 0;
};
class AuthNetLedgertInterfaceMock : public AuthNetLedgerInterface {
public:
@ -87,8 +85,6 @@ public:
MOCK_METHOD2(LnnSetSupportDiscoveryType, int32_t(char *, const char *));
MOCK_METHOD2(LnnHasSupportDiscoveryType, bool(const char *, const char *));
MOCK_METHOD2(LnnPeerHasExchangeDiscoveryType, bool(const NodeInfo *, DiscoveryType));
MOCK_METHOD1(RouteBuildClientAuthManager, void (int32_t));
MOCK_METHOD1(RouteClearAuthChannelId, void (int32_t));
static inline bool isRuned;
static inline SoftBusMutex mutex;

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

@ -212,9 +212,9 @@ HWTEST_F(AuthOtherTest, ON_WIFI_DATA_RECEIVED_TEST_001, TestSize.Level1)
const uint8_t data[TEST_DATA_LEN] = { 0 };
(void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
OnWiFiDataReceived(AUTH, fd, nullptr, data);
OnWiFiDataReceived(AUTH, fd, &head, nullptr);
OnWiFiDataReceived(AUTH, fd, &head, data);
OnWiFiDataReceived(fd, nullptr, data);
OnWiFiDataReceived(fd, &head, nullptr);
OnWiFiDataReceived(fd, &head, data);
}
/*

27
tests/core/authentication/unittest/auth_tcp_connection_test.cpp
View File

@ -101,7 +101,7 @@ HWTEST_F(AuthTcpConnectionTest, RECV_PACKET_HEAD_TEST_001, TestSize.Level1)
int32_t fd = 0;
SocketPktHead pktHead;
(void)memset_s(&pktHead, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
int32_t ret = RecvPacketHead(AUTH, fd, &pktHead);
int32_t ret = RecvPacketHead(fd, &pktHead);
EXPECT_TRUE(ret == SOFTBUS_ERR);
}
@ -118,11 +118,11 @@ HWTEST_F(AuthTcpConnectionTest, RECV_PACKET_DATA_TEST_001, TestSize.Level1)
uint8_t data[TEST_DATA_LEN] = { 0 };
(void)memset_s(&pktHead, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
pktHead.module = MODULE_AUTH_CHANNEL;
NotifyDataReceived(AUTH, fd, &pktHead, data);
NotifyDataReceived(fd, &pktHead, data);
pktHead.module = MODULE_AUTH_MSG;
NotifyDataReceived(AUTH, fd, &pktHead, data);
NotifyDataReceived(fd, &pktHead, data);
pktHead.module = MODULE_CONNECTION;
NotifyDataReceived(AUTH, fd, &pktHead, data);
NotifyDataReceived(fd, &pktHead, data);
uint32_t len = TEST_DATA_LEN;
uint8_t *packetData = RecvPacketData(fd, len);
@ -139,11 +139,11 @@ HWTEST_F(AuthTcpConnectionTest, PROCESS_SOCKET_OUT_EVENT_TEST_001, TestSize.Leve
{
int32_t fd = 0;
bool isClient = true;
NotifyConnected(AUTH, fd, isClient);
NotifyConnected(fd, isClient);
NotifyDisconnected(fd);
StopSocketListening();
int32_t ret = ProcessSocketOutEvent(AUTH, fd);
int32_t ret = ProcessSocketOutEvent(fd);
EXPECT_TRUE(ret == SOFTBUS_ERR);
}
@ -163,7 +163,7 @@ HWTEST_F(AuthTcpConnectionTest, PROCESS_SOCKET_IN_EVENT_TEST_001, TestSize.Level
NotifyChannelDataReceived(channelId, &head, data);
NotifyChannelDisconnected(channelId);
int32_t ret = ProcessSocketInEvent(AUTH, fd);
int32_t ret = ProcessSocketInEvent(fd);
EXPECT_TRUE(ret == SOFTBUS_ERR);
}
@ -217,16 +217,9 @@ HWTEST_F(AuthTcpConnectionTest, ON_DATA_EVENT_TEST_001, TestSize.Level1)
*/
HWTEST_F(AuthTcpConnectionTest, START_SOCKET_LISTENING_TEST_001, TestSize.Level1)
{
LocalListenerInfo info = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "192.168.12.1",
.port = 22,
.moduleId = AUTH,
.protocol = LNN_PROTOCOL_IP,
},
};
int32_t ret = StartSocketListening(AUTH, &info);
const char *ip = "192.168.12.1";
int32_t port = 22;
int32_t ret = StartSocketListening(ip, port);
EXPECT_TRUE(ret == SOFTBUS_ERR);
}

14
tests/core/authentication/unittest/auth_test.cpp
View File

@ -536,16 +536,10 @@ HWTEST_F(AuthTest, POST_VERIFY_DEVICE_MESSAGE_001, TestSize.Level1)
*/
HWTEST_F(AuthTest, START_SOCKET_LISTENING_Test_001, TestSize.Level1)
{
LocalListenerInfo info = {
.type = CONNECT_TCP,
.socketOption = {
.addr = "192.168.12.1",
.port = 22,
.moduleId = AUTH,
.protocol = LNN_PROTOCOL_IP,
},
};
int32_t ret = StartSocketListening(AUTH, &info);
const char *ip = "192.168.12.1";
int32_t port = 22;
int32_t ret = StartSocketListening(ip, port);
EXPECT_TRUE(ret == SOFTBUS_ERR);
}

12
tests/core/bus_center/lnn/net_builder/include/lnn_net_builder_deps_mock.h
View File

@ -109,9 +109,6 @@ public:
virtual int32_t LnnGenLocalUuid(char *uuid, uint32_t len);
virtual int32_t LnnGenLocalNetworkId(char *networkId, uint32_t len);
virtual int32_t LnnSetDLNodeAddr(const char *id, IdCategory type, const char *addr);
virtual int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort);
virtual int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort);
virtual int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort);
virtual int32_t LnnInitP2p(void);
virtual void LnnDeinitP2p(void);
virtual int32_t LnnInitNetworkInfo(void);
@ -144,8 +141,7 @@ public:
virtual void LnnNotifyMasterNodeChanged(bool isMaster, const char* masterNodeUdid, int32_t weight);
virtual int32_t LnnInitFastOffline(void);
virtual int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum);
virtual bool LnnIsLSANode(const NodeBasicInfo *info) = 0;
virtual void LnnNotifyNodeAddressChanged(const char *addr, const char *networkId, bool isLocal);
virtual void LnnNotifyNodeAddressChanged(const char* addr);
virtual int32_t LnnInitOffline(void);
virtual void LnnDeinitOffline(void);
};
@ -204,9 +200,6 @@ public:
MOCK_METHOD2(LnnGenLocalUuid, int32_t (char *, uint32_t));
MOCK_METHOD2(LnnGenLocalNetworkId, int32_t (char *, uint32_t));
MOCK_METHOD3(LnnSetDLNodeAddr, int32_t (const char *, IdCategory, const char *));
MOCK_METHOD3(LnnSetDLProxyPort, int32_t (const char *, IdCategory, int32_t));
MOCK_METHOD3(LnnSetDLSessionPort, int32_t (const char *, IdCategory, int32_t));
MOCK_METHOD3(LnnSetDLAuthPort, int32_t (const char *, IdCategory, int32_t));
MOCK_METHOD0(LnnInitP2p, int32_t ());
MOCK_METHOD0(LnnDeinitP2p, void ());
MOCK_METHOD0(LnnInitNetworkInfo, int32_t ());
@ -239,8 +232,7 @@ public:
MOCK_METHOD3(LnnNotifyMasterNodeChanged, void (bool, const char*, int32_t));
MOCK_METHOD0(LnnInitFastOffline, int32_t ());
MOCK_METHOD2(LnnGetAllOnlineNodeInfo, int32_t (NodeBasicInfo **, int32_t *));
MOCK_METHOD1(LnnIsLSANode, bool(const NodeBasicInfo *));
MOCK_METHOD3(LnnNotifyNodeAddressChanged, void (const char *, const char *, bool));
MOCK_METHOD1(LnnNotifyNodeAddressChanged, void (const char*));
MOCK_METHOD0(LnnInitOffline, int32_t ());
MOCK_METHOD0(LnnDeinitOffline, void ());

2
tests/core/bus_center/lnn/net_builder/include/lnn_net_ledger_mock.h
View File

@ -59,7 +59,6 @@ public:
virtual int32_t LnnSetP2pGoMac(NodeInfo *info, const char *goMac) = 0;
virtual int32_t LnnGetAllOnlineAndMetaNodeInfo(NodeBasicInfo **info, int32_t *infoNum) = 0;
virtual int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum) = 0;
virtual bool LnnIsLSANode(const NodeBasicInfo *info) = 0;
virtual NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type) = 0;
virtual int32_t LnnGetLnnRelation(const char *id, IdCategory type, uint8_t *relation, uint32_t len) = 0;
virtual int32_t LnnSetDLConnCapability(const char *networkId, uint64_t connCapability) = 0;
@ -111,7 +110,6 @@ public:
MOCK_METHOD2(LnnSetP2pGoMac, int32_t (NodeInfo *, const char *));
MOCK_METHOD2(LnnGetAllOnlineAndMetaNodeInfo, int32_t (NodeBasicInfo **, int32_t *));
MOCK_METHOD2(LnnGetAllOnlineNodeInfo, int32_t (NodeBasicInfo **, int32_t *));
MOCK_METHOD1(LnnIsLSANode, bool(const NodeBasicInfo *));
MOCK_METHOD2(LnnGetNodeInfoById, NodeInfo *(const char *, IdCategory));
MOCK_METHOD4(LnnGetLnnRelation, int32_t(const char *, IdCategory, uint8_t *, uint32_t));
MOCK_METHOD2(LnnSetDLConnCapability, int32_t (const char *, uint64_t));

24
tests/core/bus_center/lnn/net_builder/src/lnn_net_builder_deps_mock.cpp
View File

@ -305,21 +305,6 @@ int32_t LnnSetDLNodeAddr(const char *id, IdCategory type, const char *addr)
return GetNetBuilderDepsInterface()->LnnSetDLNodeAddr(id, type, addr);
}
int32_t LnnSetDLProxyPort(const char *id, IdCategory type, int32_t proxyPort)
{
return GetNetBuilderDepsInterface()->LnnSetDLProxyPort(id, type, proxyPort);
}
int32_t LnnSetDLSessionPort(const char *id, IdCategory type, int32_t sessionPort)
{
return GetNetBuilderDepsInterface()->LnnSetDLSessionPort(id, type, sessionPort);
}
int32_t LnnSetDLAuthPort(const char *id, IdCategory type, int32_t authPort)
{
return GetNetBuilderDepsInterface()->LnnSetDLAuthPort(id, type, authPort);
}
int32_t LnnInitP2p(void)
{
return GetNetBuilderDepsInterface()->LnnInitP2p();
@ -480,14 +465,9 @@ int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
return GetNetBuilderDepsInterface()->LnnGetAllOnlineNodeInfo(info, infoNum);
}
bool LnnIsLSANode(const NodeBasicInfo *info)
void LnnNotifyNodeAddressChanged(const char* addr)
{
return GetNetBuilderDepsInterface()->LnnIsLSANode(info);
}
void LnnNotifyNodeAddressChanged(const char *addr, const char *networkId, bool isLocal)
{
return GetNetBuilderDepsInterface()->LnnNotifyNodeAddressChanged(addr, networkId, isLocal);
return GetNetBuilderDepsInterface()->LnnNotifyNodeAddressChanged(addr);
}
int32_t LnnInitOffline(void)

4
tests/core/bus_center/lnn/net_builder/src/lnn_net_builder_mock_test.cpp
View File

@ -245,9 +245,7 @@ HWTEST_F(LNNNetBuilderMockTest, LNN_UPDATE_NODE_ADDR_TEST_001, TestSize.Level1)
EXPECT_CALL(NetBuilderMock, LnnGetAllOnlineNodeInfo(_, _))
.WillOnce(Return(SOFTBUS_ERR))
.WillRepeatedly(Return(SOFTBUS_OK));
EXPECT_CALL(NetBuilderMock, LnnNotifyNodeAddressChanged(_, _, _))
.WillOnce(Return())
.WillRepeatedly(Return());
EXPECT_CALL(NetBuilderMock, LnnNotifyNodeAddressChanged(_)).WillRepeatedly(Return());
EXPECT_TRUE(LnnUpdateNodeAddr(nullptr) == SOFTBUS_INVALID_PARAM);
EXPECT_TRUE(LnnUpdateNodeAddr(NODE_NETWORK_ID) == SOFTBUS_ERR);
EXPECT_TRUE(LnnUpdateNodeAddr(NODE_NETWORK_ID) == SOFTBUS_OK);

5
tests/core/bus_center/lnn/net_builder/src/lnn_net_ledger_mock.cpp
View File

@ -313,11 +313,6 @@ int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
return GetNetLedgerInterface()->LnnGetAllOnlineNodeInfo(info, infoNum);
}
bool LnnIsLSANode(const NodeBasicInfo *info)
{
return GetNetLedgerInterface()->LnnIsLSANode(info);
}
NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type)
{
return GetNetLedgerInterface()->LnnGetNodeInfoById(id, type);

2
tests/core/bus_center/test/mock/include/bus_center_ipc_mock.h
View File

@ -34,7 +34,6 @@ public:
virtual int32_t MetaNodeServerLeave(const char *networkId) = 0;
virtual int32_t LnnServerLeave(const char *networkId) = 0;
virtual int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum) = 0;
virtual bool LnnIsLSANode(const NodeBasicInfo *info) = 0;
virtual int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info) = 0;
virtual int32_t LnnGetNodeKeyInfo(const char *networkId, int key, uint8_t *info, uint32_t infoLen) = 0;
virtual int32_t LnnSetNodeDataChangeFlag(const char *networkId, uint16_t dataChangeFlag) = 0;
@ -80,7 +79,6 @@ public:
MOCK_METHOD1(LnnServerLeave, int32_t(const char *));
MOCK_METHOD1(MetaNodeServerLeave, int32_t(const char *));
MOCK_METHOD2(LnnGetAllOnlineNodeInfo, int32_t(NodeBasicInfo **, int32_t *));
MOCK_METHOD1(LnnIsLSANode, bool(const NodeBasicInfo *));
MOCK_METHOD1(LnnGetLocalDeviceInfo, int32_t(NodeBasicInfo *));
MOCK_METHOD4(LnnGetNodeKeyInfo, int32_t(const char *, int, uint8_t *, uint32_t));
MOCK_METHOD2(LnnSetNodeDataChangeFlag, int32_t(const char *, uint16_t));

2
tests/core/bus_center/test/mock/include/hb_fsm_mock.h
View File

@ -35,7 +35,6 @@ public:
virtual int32_t LnnNotifyDiscoveryDevice(const ConnectionAddr *addr) = 0;
virtual int32_t LnnSetHbAsMasterNodeState(bool isMasterNode) = 0;
virtual int32_t LnnNotifyMasterElect(const char *networkId, const char *masterUdid, int32_t masterWeight) = 0;
virtual void LnnNotifyHBRepeat(void);
virtual int32_t LnnStartHbByTypeAndStrategy(
LnnHeartbeatType hbType, LnnHeartbeatStrategyType strategyType, bool isRelay) = 0;
virtual int32_t LnnHbMediumMgrStop(LnnHeartbeatType *type) = 0;
@ -68,7 +67,6 @@ public:
MOCK_METHOD1(LnnNotifyDiscoveryDevice, int32_t(const ConnectionAddr *));
MOCK_METHOD3(LnnNotifyMasterElect, int32_t(const char *, const char *, int32_t));
MOCK_METHOD1(LnnSetHbAsMasterNodeState, int32_t(bool));
MOCK_METHOD0(LnnNotifyHBRepeat, void ());
MOCK_METHOD3(LnnStartHbByTypeAndStrategy, int32_t(LnnHeartbeatType, LnnHeartbeatStrategyType, bool));
MOCK_METHOD1(LnnHbMediumMgrStop, int32_t(LnnHeartbeatType *));
MOCK_METHOD0(LnnDumpHbMgrRecvList, void(void));

5
tests/core/bus_center/test/mock/src/bus_center_ipc_mock.cpp
View File

@ -62,11 +62,6 @@ int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum)
return BusCenterIpcInterfaceInstance()->LnnGetAllOnlineNodeInfo(info, infoNum);
}
bool LnnIsLSANode(const NodeBasicInfo *info)
{
return BusCenterIpcInterfaceInstance()->LnnIsLSANode(info);
}
int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info)
{
return BusCenterIpcInterfaceInstance()->LnnGetLocalDeviceInfo(info);

5
tests/core/bus_center/test/mock/src/hb_fsm_mock.cpp
View File

@ -62,11 +62,6 @@ int32_t LnnSetHbAsMasterNodeState(bool isMasterNode)
return HeartBeatFSMInterfaceInstance()->LnnSetHbAsMasterNodeState(isMasterNode);
}
void LnnNotifyHBRepeat(void)
{
return HeartBeatFSMInterfaceInstance()->LnnNotifyHBRepeat();
}
int32_t LnnStartHbByTypeAndStrategy(LnnHeartbeatType hbType, LnnHeartbeatStrategyType strategyType, bool isRelay)
{
return HeartBeatFSMInterfaceInstance()->LnnStartHbByTypeAndStrategy(hbType, strategyType, isRelay);

2
tests/core/transmission/common/mock/include/trans_auth_mock.h
View File

@ -84,7 +84,6 @@ public:
virtual int32_t LnnRequestLane(uint32_t laneId,
const LaneRequestOption *request, const ILaneListener *listener) = 0;
virtual int32_t LnnFreeLane(uint32_t laneId) = 0;
virtual int32_t AuthGetConnByNodeAddr(const char *addr, uint32_t cipherFlag, AuthConnInfo *connInfo) = 0;
};
class TransAuthInterfaceMock : public TransAuthInterface {
@ -142,7 +141,6 @@ public:
MOCK_METHOD1(ApplyLaneId, uint32_t (LaneType));
MOCK_METHOD3(LnnRequestLane, int32_t (uint32_t, const LaneRequestOption *, const ILaneListener *));
MOCK_METHOD1(LnnFreeLane, int32_t (uint32_t laneId));
MOCK_METHOD3(AuthGetConnByNodeAddr, int32_t (const char *, uint32_t, AuthConnInfo *));
};
} // namespace OHOS
#endif // TRANS_AUTH_MOCK_H

17
tests/core/transmission/common/mock/include/trans_conn_mock.h
View File

@ -20,9 +20,6 @@
#include "softbus_conn_interface.h"
#include "p2plink_interface.h"
#include "lnn_node_info.h"
#include "lnn_distributed_net_ledger.h"
#include "lnn_network_manager.h"
namespace OHOS {
class TransConnInterface {
@ -58,13 +55,6 @@ public:
virtual bool CheckActiveConnection(const ConnectOption *option) = 0;
virtual int32_t ConnSetConnectCallback(ConnModule moduleId, const ConnectCallback *callback) = 0;
virtual uint32_t ConnGetHeadSize(void) = 0;
virtual void NipRecvDataFromBr(uint32_t connId, const char *buf) = 0;
virtual void NipConnectDevice(uint32_t connId, const char *mac) = 0;
virtual void NipDisconnectDevice(uint32_t connId) = 0;
virtual ListenerModule LnnGetProtocolListenerModule(ProtocolType protocol, ListenerMode mode) = 0;
virtual NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type) = 0;
virtual bool LnnHasDiscoveryType(const NodeInfo *info, DiscoveryType type) = 0;
virtual bool LnnHasIpByUuid(const char *uuid) = 0;
};
class TransConnInterfaceMock : public TransConnInterface {
@ -97,13 +87,6 @@ public:
MOCK_METHOD0(ConnGetHeadSize, uint32_t (void));
MOCK_METHOD2(ConnSetConnectCallback, int32_t (ConnModule, const ConnectCallback *));
MOCK_METHOD2(NipRecvDataFromBr, void (uint32_t, const char *));
MOCK_METHOD2(NipConnectDevice, void (uint32_t, const char *));
MOCK_METHOD1(NipDisconnectDevice, void (uint32_t));
MOCK_METHOD2(LnnGetProtocolListenerModule, ListenerModule (ProtocolType, ListenerMode));
MOCK_METHOD2(LnnGetNodeInfoById, NodeInfo* (const char *, IdCategory));
MOCK_METHOD2(LnnHasDiscoveryType, bool (const NodeInfo *, DiscoveryType));
MOCK_METHOD1(LnnHasIpByUuid, bool (const char *));
};
} // namespace OHOS

7
tests/core/transmission/common/mock/mock.gni
View File

@ -19,10 +19,5 @@ trans_comm_mock_src = [
"$trans_comm_mock_path/src/trans_conn_mock.cpp",
"$trans_comm_mock_path/src/trans_auth_mock.cpp",
]
trans_comm_mock_inc = [
"$trans_comm_mock_path/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/common/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/distributed_ledger/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/include",
]
trans_comm_mock_inc = [ "$trans_comm_mock_path/include" ]
trans_comm_mock_deps = []

5
tests/core/transmission/common/mock/src/trans_auth_mock.cpp
View File

@ -233,10 +233,5 @@ int32_t LnnFreeLane(uint32_t laneId)
{
return GetTransAuthInterface()->LnnFreeLane(laneId);
}
int32_t AuthGetConnByNodeAddr(const char *addr, uint32_t cipherFlag, AuthConnInfo *connInfo)
{
return GetTransAuthInterface()->AuthGetConnByNodeAddr(addr, cipherFlag, connInfo);
}
}
}

34
tests/core/transmission/common/mock/src/trans_conn_mock.cpp
View File

@ -142,39 +142,5 @@ int32_t ConnSetConnectCallback(ConnModule moduleId, const ConnectCallback *callb
{
return GetConnectInterface()->ConnSetConnectCallback(moduleId, callback);
}
void NipRecvDataFromBr(uint32_t connId, const char *buf)
{
return GetConnectInterface()->NipRecvDataFromBr(connId, buf);
}
void NipConnectDevice(uint32_t connId, const char *mac)
{
return GetConnectInterface()->NipConnectDevice(connId, mac);
}
void NipDisconnectDevice(uint32_t connId)
{
return GetConnectInterface()->NipDisconnectDevice(connId);
}
ListenerModule LnnGetProtocolListenerModule(ProtocolType protocol, ListenerMode mode)
{
return GetConnectInterface()->LnnGetProtocolListenerModule(protocol, mode);
}
NodeInfo *LnnGetNodeInfoById(const char *id, IdCategory type)
{
return GetConnectInterface()->LnnGetNodeInfoById(id, type);
}
bool LnnHasDiscoveryType(const NodeInfo *info, DiscoveryType type)
{
return GetConnectInterface()->LnnHasDiscoveryType(info, type);
}
bool LnnHasIpByUuid(const char *uuid)
{
return GetConnectInterface()->LnnHasIpByUuid(uuid);
}
}
}

1
tests/core/transmission/trans_channel/manager/trans_channel_manager_test/BUILD.gn
View File

@ -49,7 +49,6 @@ ohos_unittest("TransChannelManagerTest") {
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/local_ledger/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_ledger/sync_ledger/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_builder/include",
"$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/include",
"$dsoftbus_root_path/core/common/message_handler/include",
"$dsoftbus_root_path/interfaces/kits/bus_center",
"//base/hiviewdfx/hilog_lite/interfaces/native/kits/hilog_lite",

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

@ -656,7 +656,7 @@ HWTEST_F(TransProxyChannelTest, TransProxyGetAuthConnInfoTest001, TestSize.Level
{
int32_t connId = 1;
AuthConnInfo connInfo;
int32_t ret = TransProxyGetAuthConnInfo(connId, &connInfo, ENCRYPTED);
int32_t ret = TransProxyGetAuthConnInfo(connId, &connInfo);
EXPECT_NE(SOFTBUS_OK, ret);
}