diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000000000000000000000000000000000000..9d8e1bde84f4cc59e06375f80053c5015cd19c7a --- /dev/null +++ b/.clang-format @@ -0,0 +1,29 @@ +BasedOnStyle: Webkit +ColumnLimit: 120 +PointerAlignment: Right +AlignAfterOpenBracket: DontAlign +AlignTrailingComments: true +AlignConsecutiveMacros: Consecutive +IndentCaseLabels: true +BreakBeforeBinaryOperators: None +SpaceBeforeParens: ControlStatementsExceptControlMacros +SpacesInCStyleCastParentheses: false +AlignEscapedNewlines: Left +NamespaceIndentation: None +FixNamespaceComments: true +ConstructorInitializerAllOnOneLineOrOnePerLine: true +BreakConstructorInitializers: AfterColon +AlignArrayOfStructures: Left +AllowShortFunctionsOnASingleLine: Empty +AllowShortLambdasOnASingleLine: Empty +AlwaysBreakTemplateDeclarations: true +SpaceInEmptyBlock: false +LambdaBodyIndentation: Signature +BreakBeforeTernaryOperators: false +Cpp11BracedListStyle: true +SpaceAroundPointerQualifiers: Both + +ForEachMacros: + - 'DLIST_FOR_EACH_ENTRY' + - 'DLIST_FOR_EACH_ENTRY_REVERSE' + - 'DLIST_FOR_EACH_ENTRY_SAFE' \ No newline at end of file diff --git a/adapter/common/bus_center/driver/lnn_driver_monitor_virtual.c b/adapter/common/bus_center/driver/lnn_driver_monitor_virtual.c index e24cf73904a2e879a97173fd66523290db363f9c..a45a237b5c13ca669e940783a8118a27c7b664fa 100644 --- a/adapter/common/bus_center/driver/lnn_driver_monitor_virtual.c +++ b/adapter/common/bus_center/driver/lnn_driver_monitor_virtual.c @@ -17,8 +17,7 @@ #include "softbus_errcode.h" -int32_t LnnInitDriverMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitDriverMonitorImpl(void) { - (void)handler; return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/bus_center/driver/lnn_hdf_driver_monitor.c b/adapter/common/bus_center/driver/lnn_hdf_driver_monitor.c index c15fb374d23e55845ed2378f79ccfe572711beff..51ecdc6a76772b8f655fe320382c137dd0d8b9d9 100644 --- a/adapter/common/bus_center/driver/lnn_hdf_driver_monitor.c +++ b/adapter/common/bus_center/driver/lnn_hdf_driver_monitor.c @@ -21,23 +21,22 @@ #include "lnn_async_callback_utils.h" #include "lnn_driver_request.h" -#include "lnn_ip_utils.h" +#include "lnn_network_manager.h" #include "message_handler.h" +#include "softbus_adapter_mem.h" #include "softbus_errcode.h" #include "softbus_log.h" -#include "softbus_adapter_mem.h" #define DRIVER_SERVICE_NAME "hdf_dsoftbus" #define NETIF_NAME_LENGTH 16 -#define BIND_HDF_DELAY 1000 +#define BIND_HDF_DELAY 1000 #define MAX_BIND_HDF_RETRY_COUNT 10 typedef struct { struct HdfIoService *softbusService; struct HdfDevEventlistener eventListener; - LnnMonitorEventHandler handler; } HdfDriverEventCtrl; typedef struct { @@ -50,74 +49,59 @@ typedef struct { static HdfDriverEventCtrl g_driverCtrl; -static void ProcessLwipEvent(const LnnMoniterData *monitorData) +static void ProcessLwipEvent(struct HdfSBuf *data) { - const LwipMonitorReportInfo *info = (const LwipMonitorReportInfo *)monitorData->value; - ConnectionAddrType type = CONNECTION_ADDR_MAX; + LnnNetIfType type = LNN_NETIF_TYPE_ETH; + uint32_t eventDataSize = 0; + uint8_t *eventData = NULL; + + if (!HdfSbufReadBuffer(data, (const void **)&eventData, &eventDataSize)) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "read data from sbuff failed!"); + return; + } - if (monitorData->len != sizeof(LwipMonitorReportInfo)) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "receive lwip monitor not correct size: %d<->%d", - monitorData->len, sizeof(LwipMonitorReportInfo)); + if (eventData == NULL || eventDataSize != sizeof(LwipMonitorReportInfo)) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "receive lwip monitor not correct size: %d<->%d", eventDataSize, + sizeof(LwipMonitorReportInfo)); return; } - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "receive lwip monitor event(%d) for %s", - info->event, info->ifName); - if (LnnGetAddrTypeByIfName(info->ifName, strlen(info->ifName), &type) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ProcessLwipEvent LnnGetAddrTypeByIfName error"); + const LwipMonitorReportInfo *info = (const LwipMonitorReportInfo *)eventData; + + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "receive lwip monitor event(%d) for %s", info->event, info->ifName); + if (LnnGetNetIfTypeByName(info->ifName, &type) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ProcessLwipEvent LnnGetNetIfTypeByName error"); return; } - if (type == CONNECTION_ADDR_ETH || type == CONNECTION_ADDR_WLAN) { + if (type == LNN_NETIF_TYPE_ETH || type == LNN_NETIF_TYPE_WLAN) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "network addr changed, type:%d", type); - g_driverCtrl.handler(LNN_MONITOR_EVENT_IP_ADDR_CHANGED, NULL); + LnnNotifyAddressChangedEvent(info->ifName); } } -static void DispatchModuleEvent(int32_t moduleId, const LnnMoniterData *monitorData) +static void ProcessWlanEvent(struct HdfSBuf *data) { - switch (moduleId) { - case LNN_DRIVER_MODULE_WLAN_PARAM: - g_driverCtrl.handler(LNN_MONITOR_EVENT_WLAN_PARAM, monitorData); - break; - case LNN_DRIVER_MODULE_LWIP_MONITOR: - ProcessLwipEvent(monitorData); - break; - default: - break; - } + LnnNotifyWlanStateChangeEvent(SOFTBUS_UNKNOWN); } -static int32_t OnReceiveDriverEvent(struct HdfDevEventlistener *listener, - struct HdfIoService *service, uint32_t moduleId, struct HdfSBuf *data) +static int32_t OnReceiveDriverEvent( + struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t moduleId, struct HdfSBuf *data) { - uint8_t *eventData = NULL; - uint32_t eventDataSize; - LnnMoniterData *monitorData = NULL; - (void)listener; (void)service; SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "receive hdf moudle(%d) event", moduleId); if (moduleId >= LNN_DRIVER_MODULE_MAX_INDEX) { return SOFTBUS_OK; } - if (!HdfSbufReadBuffer(data, (const void **)&eventData, &eventDataSize)) { - eventData = NULL; - eventDataSize = 0; - } - monitorData = (LnnMoniterData *)SoftBusMalloc(sizeof(LnnMoniterData) + eventDataSize); - if (monitorData == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "malloc monitor data fail"); - return SOFTBUS_ERR; - } - monitorData->len = eventDataSize; - if (eventData != NULL) { - if (memcpy_s(monitorData->value, eventDataSize, eventData, eventDataSize) != EOK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcopy monitor data fail"); - SoftBusFree(monitorData); - return SOFTBUS_ERR; - } + switch (moduleId) { + case LNN_DRIVER_MODULE_WLAN_PARAM: + ProcessWlanEvent(data); + break; + case LNN_DRIVER_MODULE_LWIP_MONITOR: + ProcessLwipEvent(data); + break; + default: + break; } - DispatchModuleEvent(moduleId, monitorData); - SoftBusFree(monitorData); return SOFTBUS_OK; } @@ -146,10 +130,9 @@ static void DelayInitFunction(void *para) ++retry; } -int32_t LnnInitDriverMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitDriverMonitorImpl(void) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "hdf driver monitor init enter"); g_driverCtrl.eventListener.onReceive = OnReceiveDriverEvent; - g_driverCtrl.handler = handler; return LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), DelayInitFunction, NULL, BIND_HDF_DELAY); } \ No newline at end of file diff --git a/adapter/common/bus_center/include/lnn_event_monitor_impl.h b/adapter/common/bus_center/include/lnn_event_monitor_impl.h index c24ce2b7552ebdf4534095799ddfa7b3d714e9d9..7145fe03c85d5c71bfb050f15f7b0cbfa5e989aa 100755 --- a/adapter/common/bus_center/include/lnn_event_monitor_impl.h +++ b/adapter/common/bus_center/include/lnn_event_monitor_impl.h @@ -17,43 +17,23 @@ #define LNN_EVENT_MONITOR_IMPL_H #include +#include "bus_center_event.h" #ifdef __cplusplus extern "C" { #endif -typedef enum { - LNN_MONITOR_EVENT_IP_ADDR_CHANGED, - LNN_MONITOR_EVENT_WIFI_STATE_CHANGED, - LNN_MONITOR_EVENT_WLAN_PARAM, - LNN_MONITOR_EVENT_TYPE_MAX, -} LnnMonitorEventType; +typedef int32_t (*LnnInitEventMonitorImpl)(void); -typedef struct { - uint32_t len; - uint8_t value[0]; -} LnnMoniterData; +int32_t LnnInitNetlinkMonitorImpl(void); -typedef enum { - SOFTBUS_WIFI_CONNECTED, - SOFTBUS_WIFI_DISCONNECTED, - SOFTBUS_WIFI_DISABLED, - SOFTBUS_UNKNOWN, -} SoftBusWifiState; +int32_t LnnInitProductMonitorImpl(void); -typedef void (*LnnMonitorEventHandler)(LnnMonitorEventType event, const LnnMoniterData *para); +int32_t LnnInitLwipMonitorImpl(void); -typedef int32_t (*LnnInitEventMonitorImpl)(LnnMonitorEventHandler handler); +int32_t LnnInitWifiServiceMonitorImpl(void); -int32_t LnnInitNetlinkMonitorImpl(LnnMonitorEventHandler handler); - -int32_t LnnInitProductMonitorImpl(LnnMonitorEventHandler handler); - -int32_t LnnInitLwipMonitorImpl(LnnMonitorEventHandler handler); - -int32_t LnnInitWifiServiceMonitorImpl(LnnMonitorEventHandler handler); - -int32_t LnnInitDriverMonitorImpl(LnnMonitorEventHandler handler); +int32_t LnnInitDriverMonitorImpl(void); #ifdef __cplusplus } #endif diff --git a/adapter/common/bus_center/include/lnn_linkwatch.h b/adapter/common/bus_center/include/lnn_linkwatch.h index d08d601d21c611391a0eda566d7cd67d0b0c31b5..0acda090a63834b5d9db42979272c25dd99c559b 100644 --- a/adapter/common/bus_center/include/lnn_linkwatch.h +++ b/adapter/common/bus_center/include/lnn_linkwatch.h @@ -25,7 +25,7 @@ extern "C" { #endif #endif -bool LnnIsLinkReady(const char *iface, uint32_t len); +bool LnnIsLinkReady(const char *iface); #ifdef __cplusplus #if __cplusplus diff --git a/adapter/common/bus_center/network/lnn_linkwatch.c b/adapter/common/bus_center/network/lnn_linkwatch.c index 6f4b77d42a7663de607edeee343717ce68e3a842..0786c99809ed0488c7c92a8e0960996156364e7d 100644 --- a/adapter/common/bus_center/network/lnn_linkwatch.c +++ b/adapter/common/bus_center/network/lnn_linkwatch.c @@ -46,7 +46,7 @@ static int32_t AddAttr(struct nlmsghdr *nlMsgHdr, uint32_t maxLen, int32_t type, SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AddAttr ERROR: message exceeded bound of %d\n", maxLen); return SOFTBUS_ERR; } - rta = ((struct rtattr *) (((void *) (nlMsgHdr)) + NLMSG_ALIGN((nlMsgHdr)->nlmsg_len))); + rta = ((struct rtattr *) (((uint8_t *) (nlMsgHdr)) + NLMSG_ALIGN((nlMsgHdr)->nlmsg_len))); rta->rta_type = (uint16_t)type; rta->rta_len = (uint16_t)len; if (memcpy_s(RTA_DATA(rta), rta->rta_len, data, attrLen) != EOK) { @@ -139,7 +139,7 @@ static int32_t GetRtAttr(struct rtattr *rta, int32_t len, uint16_t type, uint8_t return SOFTBUS_ERR; } -bool LnnIsLinkReady(const char *iface, uint32_t len) +bool LnnIsLinkReady(const char *iface) { struct ifinfomsg *info = NULL; struct { @@ -165,7 +165,7 @@ bool LnnIsLinkReady(const char *iface, uint32_t len) } req.hdr.nlmsg_seq = ++seq; (void)memset_s(&answer, sizeof(answer), 0, sizeof(answer)); - if (AddAttr(&req.hdr, sizeof(req), IFLA_IFNAME, (const uint8_t *)iface, len + 1) != SOFTBUS_OK) { + if (AddAttr(&req.hdr, sizeof(req), IFLA_IFNAME, (const uint8_t *)iface, strlen(iface) + 1) != SOFTBUS_OK) { return false; } if (RtNetlinkTalk(&req.hdr, &answer.hdr, sizeof(answer)) != SOFTBUS_OK) { diff --git a/adapter/common/bus_center/network/lnn_linkwatch_virtual.c b/adapter/common/bus_center/network/lnn_linkwatch_virtual.c index ab096372d402da790f60bef76e0448cdc0186d02..726853287264cd0871444c7295bbf3038c5ee2c9 100644 --- a/adapter/common/bus_center/network/lnn_linkwatch_virtual.c +++ b/adapter/common/bus_center/network/lnn_linkwatch_virtual.c @@ -15,9 +15,8 @@ #include "lnn_linkwatch.h" -bool LnnIsLinkReady(const char *iface, uint32_t len) +bool LnnIsLinkReady(const char *iface) { (void)iface; - (void)len; return true; } \ No newline at end of file diff --git a/adapter/common/bus_center/network/lnn_lwip_monitor.c b/adapter/common/bus_center/network/lnn_lwip_monitor.c index a6ac49595f2e2ea1f32b2c8e89db285b308cc56b..023bb080f9968771f4b85df9c63619d36def028a 100755 --- a/adapter/common/bus_center/network/lnn_lwip_monitor.c +++ b/adapter/common/bus_center/network/lnn_lwip_monitor.c @@ -15,15 +15,15 @@ #include "lnn_event_monitor_impl.h" +#include "bus_center_event.h" #include "lwip/netif.h" #include "softbus_errcode.h" #include "softbus_log.h" -static LnnMonitorEventHandler g_eventHandler; #define LWIP_NSC_IPSTATUS_CHANGE 0xf0 -static int32_t NetifStatusCallback(struct netif *netif, netif_nsc_reason_t reason, - const netif_ext_callback_args_t *args) +static int32_t NetifStatusCallback( + struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args) { (void)args; if (netif == NULL) { @@ -33,21 +33,21 @@ static int32_t NetifStatusCallback(struct netif *netif, netif_nsc_reason_t reaso if (reason == LWIP_NSC_IPSTATUS_CHANGE) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "ip monitor start success"); - g_eventHandler(LNN_MONITOR_EVENT_IP_ADDR_CHANGED, NULL); + char ifnameBuffer[NET_IF_NAME_LEN]; + char *ifName = lwip_if_indextoname(netif->num, ifnameBuffer); + if (ifName == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:bad netif! Cannot found ifName", __func__); + } else { + LnnNotifyAddressChangedEvent(ifName); + } } return SOFTBUS_OK; } -int32_t LnnInitLwipMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitLwipMonitorImpl(void) { - if (handler == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "input handler is NULL!"); - return SOFTBUS_ERR; - } NETIF_DECLARE_EXT_CALLBACK(NetifCallback); netif_add_ext_callback(&NetifCallback, NetifStatusCallback); - - g_eventHandler = handler; SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "LnnInitLwipMonitorImpl start success..."); return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/bus_center/network/lnn_lwip_monitor_virtual.c b/adapter/common/bus_center/network/lnn_lwip_monitor_virtual.c index 87b4d3e71de210ff7ac31aa1c976abb6560f61da..4b536da0bf8dc98d028d76f50aa01dadc123f60f 100755 --- a/adapter/common/bus_center/network/lnn_lwip_monitor_virtual.c +++ b/adapter/common/bus_center/network/lnn_lwip_monitor_virtual.c @@ -17,8 +17,7 @@ #include "softbus_errcode.h" -int32_t LnnInitLwipMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitLwipMonitorImpl(void) { - (void)handler; return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/bus_center/network/lnn_netlink_monitor.c b/adapter/common/bus_center/network/lnn_netlink_monitor.c index 917e710a6327f3ff6d2efcc0f555c18699e245c4..80504583d5890f8018141bdc3cb0883c96e426f7 100755 --- a/adapter/common/bus_center/network/lnn_netlink_monitor.c +++ b/adapter/common/bus_center/network/lnn_netlink_monitor.c @@ -28,24 +28,25 @@ #include #include #include -#include #include #include #include #include -#include "lnn_ip_utils.h" +#include "bus_center_event.h" +#include "lnn_network_manager.h" +#include "securec.h" #include "softbus_errcode.h" #include "softbus_log.h" + #undef NLMSG_OK -#define NLMSG_OK(nlh, len) (((len) >= (int32_t)(sizeof(struct nlmsghdr))) && (((nlh)->nlmsg_len) >= \ - sizeof(struct nlmsghdr)) && ((int32_t)((nlh)->nlmsg_len) <= (len))) +#define NLMSG_OK(nlh, len) \ + (((len) >= (int32_t)(sizeof(struct nlmsghdr))) && (((nlh)->nlmsg_len) >= sizeof(struct nlmsghdr)) && \ + ((int32_t)((nlh)->nlmsg_len) <= (len))) #define DEFAULT_NETLINK_RECVBUF (4 * 1024) -static LnnMonitorEventHandler g_eventHandler; - static int32_t CreateNetlinkSocket(void) { int32_t sockFd; @@ -89,30 +90,29 @@ static void ParseRtAttr(struct rtattr **tb, int max, struct rtattr *attr, int le static void ProcessAddrEvent(struct nlmsghdr *nlh) { struct ifaddrmsg *ifa = (struct ifaddrmsg *)NLMSG_DATA(nlh); - char name[IFNAMSIZ]; - ConnectionAddrType type = CONNECTION_ADDR_MAX; - - if (if_indextoname(ifa->ifa_index, name) == 0) { + LnnNetIfType type = LNN_NETIF_TYPE_ETH; + char ifnameBuffer[NET_IF_NAME_LEN]; + char *ifName = if_indextoname(ifa->ifa_index, ifnameBuffer); + if (ifName == NULL) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid iface index"); return; } - if (LnnGetAddrTypeByIfName(name, strlen(name), &type) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ProcessAddrEvent LnnGetAddrTypeByIfName error"); + if (LnnGetNetIfTypeByName(ifName, &type) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ProcessAddrEvent LnnGetNetIfTypeByName error"); return; } - if (type == CONNECTION_ADDR_ETH || type == CONNECTION_ADDR_WLAN) { + if (type == LNN_NETIF_TYPE_ETH || type == LNN_NETIF_TYPE_WLAN) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "network addr changed, type:%d", type); - g_eventHandler(LNN_MONITOR_EVENT_IP_ADDR_CHANGED, NULL); + LnnNotifyAddressChangedEvent(ifName); } } - static void ProcessLinkEvent(struct nlmsghdr *nlh) { int len; struct rtattr *tb[IFLA_MAX + 1] = {NULL}; struct ifinfomsg *ifinfo = NLMSG_DATA(nlh); - ConnectionAddrType type = CONNECTION_ADDR_MAX; + LnnNetIfType type = LNN_NETIF_TYPE_ETH; len = (int32_t)nlh->nlmsg_len - NLMSG_SPACE(sizeof(*ifinfo)); ParseRtAttr(tb, IFLA_MAX, IFLA_RTA(ifinfo), len); @@ -121,13 +121,15 @@ static void ProcessLinkEvent(struct nlmsghdr *nlh) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "netlink msg is invalid"); return; } - if (LnnGetAddrTypeByIfName(RTA_DATA(tb[IFLA_IFNAME]), strlen(RTA_DATA(tb[IFLA_IFNAME])), &type) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ProcessAddrEvent LnnGetAddrTypeByIfName error"); + + if (LnnGetNetIfTypeByName(RTA_DATA(tb[IFLA_IFNAME]), &type) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ProcessAddrEvent LnnGetNetIfTypeByName error"); return; } - if (type == CONNECTION_ADDR_ETH || type == CONNECTION_ADDR_WLAN) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "link status changed, type:%d", type); - g_eventHandler(LNN_MONITOR_EVENT_IP_ADDR_CHANGED, NULL); + if (type == LNN_NETIF_TYPE_ETH || type == LNN_NETIF_TYPE_WLAN) { + SoftBusLog( + SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "%s:link status changed, type:%d", RTA_DATA(tb[IFLA_IFNAME]), type); + LnnNotifyAddressChangedEvent(RTA_DATA(tb[IFLA_IFNAME])); } } @@ -180,18 +182,12 @@ static void *NetlinkMonitorThread(void *para) return NULL; } -int32_t LnnInitNetlinkMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitNetlinkMonitorImpl(void) { pthread_t tid; - - if (handler == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "netlink event handler is null"); - return SOFTBUS_ERR; - } if (pthread_create(&tid, NULL, NetlinkMonitorThread, NULL) != 0) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "create ip change monitor thread failed"); return SOFTBUS_ERR; } - g_eventHandler = handler; return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/bus_center/network/lnn_netlink_monitor_virtual.c b/adapter/common/bus_center/network/lnn_netlink_monitor_virtual.c index 8c34a6dcc6ca0643ecc573984f3d71c27bca8471..91ed7aa26cbed6904ace7e5c9c795f199f168f00 100755 --- a/adapter/common/bus_center/network/lnn_netlink_monitor_virtual.c +++ b/adapter/common/bus_center/network/lnn_netlink_monitor_virtual.c @@ -17,8 +17,7 @@ #include "softbus_errcode.h" -int32_t LnnInitNetlinkMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitNetlinkMonitorImpl(void) { - (void)handler; return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/bus_center/platform/lnn_product_monitor.c b/adapter/common/bus_center/platform/lnn_product_monitor.c index 4a6cc44a864e4e7e7cec0c32195fd0db07b501a4..2558f0e6e1cb59b2a566359932cfa82a7d050fb3 100644 --- a/adapter/common/bus_center/platform/lnn_product_monitor.c +++ b/adapter/common/bus_center/platform/lnn_product_monitor.c @@ -15,12 +15,11 @@ #include "lnn_event_monitor_impl.h" +#include "bus_center_event.h" #include "softbus_adapter_log.h" #include "softbus_errcode.h" #include "hdf_io_service_if.h" -static LnnMonitorEventHandler g_eventHandler; - #define HISYSLINK_SERVICE_NAME "hisyslink_sevice" #define IP_READY 124 @@ -29,8 +28,8 @@ static struct HdfIoService *g_serv = NULL; static int OnDevEventReceived(void* priv, unsigned int id, struct HdfSBuf* data) { if (id == IP_READY) { - g_eventHandler(LNN_MONITOR_EVENT_IP_ADDR_CHANGED, NULL); HILOG_INFO(SOFTBUS_HILOG_ID, "envent %{public}s: dev event received: %{public}u", (char*)priv, id); + LnnNotifyAddressChangedEvent(NULL); } return HDF_SUCCESS; } @@ -40,12 +39,8 @@ static struct HdfDevEventlistener g_listener = { .priv = "Service0", }; -int32_t LnnInitProductMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitProductMonitorImpl(void) { - if (handler == NULL) { - HILOG_ERROR(SOFTBUS_HILOG_ID, "hisyslink event handler is null"); - return SOFTBUS_ERR; - } g_serv = HdfIoServiceBind(HISYSLINK_SERVICE_NAME); if (g_serv == NULL) { HILOG_WARN(SOFTBUS_HILOG_ID, "fail to get service %{public}s", HISYSLINK_SERVICE_NAME); @@ -56,7 +51,6 @@ int32_t LnnInitProductMonitorImpl(LnnMonitorEventHandler handler) HILOG_WARN(SOFTBUS_HILOG_ID, "fail to register event listener"); return SOFTBUS_OK; } - g_eventHandler = handler; HILOG_ERROR(SOFTBUS_HILOG_ID, "start success..."); return SOFTBUS_OK; } diff --git a/adapter/common/bus_center/platform/lnn_product_monitor_virtual.c b/adapter/common/bus_center/platform/lnn_product_monitor_virtual.c index 4a5090347df49a9e74475c3e1e209ba804a55536..830d79087ca314746dad713e91e4b4da6a1c51bc 100755 --- a/adapter/common/bus_center/platform/lnn_product_monitor_virtual.c +++ b/adapter/common/bus_center/platform/lnn_product_monitor_virtual.c @@ -17,8 +17,7 @@ #include "softbus_errcode.h" -int32_t LnnInitProductMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitProductMonitorImpl(void) { - (void)handler; return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/bus_center/wlan/lnn_wifiservice_monitor.cpp b/adapter/common/bus_center/wlan/lnn_wifiservice_monitor.cpp index e1af52509eacbce6ed67b7303c13090672641871..f0353e16e9810d414d6e4d189eaba6ef4e9a95c3 100755 --- a/adapter/common/bus_center/wlan/lnn_wifiservice_monitor.cpp +++ b/adapter/common/bus_center/wlan/lnn_wifiservice_monitor.cpp @@ -17,6 +17,7 @@ #include +#include "bus_center_event.h" #include "common_event_data.h" #include "common_event_manager.h" #include "common_event_subscriber.h" @@ -43,20 +44,15 @@ public: }; WifiServiceMonitor::WifiServiceMonitor(const CommonEventSubscribeInfo &subscriberInfo) - : CommonEventSubscriber(subscriberInfo) -{} + :CommonEventSubscriber(subscriberInfo) +{ +} void WifiServiceMonitor::OnReceiveEvent(const CommonEventData &data) { int code = data.GetCode(); std::string action = data.GetWant().GetAction(); SoftBusWifiState state = SOFTBUS_UNKNOWN; - LnnMoniterData *para = (LnnMoniterData *)SoftBusCalloc(sizeof(LnnMoniterData) + sizeof(int)); - if (para == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "LnnMoniterData malloc failed"); - return; - } - para->len = sizeof(int); SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "notify wifiservice event %s, code(%d)", action.c_str(), code); if (action == CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE) { @@ -83,11 +79,8 @@ void WifiServiceMonitor::OnReceiveEvent(const CommonEventData &data) } } if (state != SOFTBUS_UNKNOWN) { - (void)memcpy_s(para->value, para->len, &state, sizeof(int)); - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "send wifi state change event to LNN"); - g_eventHandler(LNN_MONITOR_EVENT_WIFI_STATE_CHANGED, para); + LnnNotifyWlanStateChangeEvent(state); } - SoftBusFree(para); } class SubscribeEvent { @@ -119,7 +112,7 @@ int32_t SubscribeEvent::SubscribeWifiPowerStateEvent() } return SOFTBUS_OK; } -} // namespace EventFwkc +} // namespace EventFwk } // namespace OHOS static void LnnSubscribeWifiService(void *para) @@ -149,13 +142,8 @@ static void LnnSubscribeWifiService(void *para) delete subscriberPtr; } -int32_t LnnInitWifiServiceMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitWifiServiceMonitorImpl(void) { - if (handler == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "handler is null"); - return SOFTBUS_ERR; - } - g_eventHandler = handler; SoftBusLooper *looper = GetLooper(LOOP_TYPE_DEFAULT); int32_t ret = LnnAsyncCallbackDelayHelper(looper, LnnSubscribeWifiService, NULL, DELAY_LEN); if (ret != SOFTBUS_OK) { diff --git a/adapter/common/bus_center/wlan/lnn_wifiservice_monitor_virtual.cpp b/adapter/common/bus_center/wlan/lnn_wifiservice_monitor_virtual.cpp index d8d506d0de771d54cbf705118b7570b1e6fc5d5c..ada76d33e3732a5984930c0f0cc6d6b7b409a59b 100755 --- a/adapter/common/bus_center/wlan/lnn_wifiservice_monitor_virtual.cpp +++ b/adapter/common/bus_center/wlan/lnn_wifiservice_monitor_virtual.cpp @@ -17,8 +17,7 @@ #include "softbus_errcode.h" -int32_t LnnInitWifiServiceMonitorImpl(LnnMonitorEventHandler handler) +int32_t LnnInitWifiServiceMonitorImpl(void) { - (void)handler; return SOFTBUS_OK; } \ No newline at end of file diff --git a/adapter/common/kernel/liteos_a/lnn_ip_utils_adapter.c b/adapter/common/kernel/liteos_a/lnn_ip_utils_adapter.c index 2512f0ec0ccdba9dbeaacddd6773c0f0f2c2fba4..3db9f2de6c3f9eab4011343ac3a4c15c4f7843c5 100755 --- a/adapter/common/kernel/liteos_a/lnn_ip_utils_adapter.c +++ b/adapter/common/kernel/liteos_a/lnn_ip_utils_adapter.c @@ -70,12 +70,12 @@ int32_t GetNetworkIpByIfName(const char *ifName, char *ip, char *netmask, uint32 } struct ifreq ifr; if (strncpy_s(ifr.ifr_name, sizeof(ifr.ifr_name), ifName, strlen(ifName)) != EOK) { - HILOG_ERROR(SOFTBUS_HILOG_ID, "copy netIfName:%s fail", ifName); + HILOG_ERROR(SOFTBUS_HILOG_ID, "copy netIfName:%{public}s fail", ifName); close(fd); return SOFTBUS_ERR; } if (GetNetworkIfIp(fd, &ifr, ip, netmask, len) != SOFTBUS_OK) { - HILOG_ERROR(SOFTBUS_HILOG_ID, "GetNetworkIfIp ifName:%s fail", ifName); + HILOG_ERROR(SOFTBUS_HILOG_ID, "GetNetworkIfIp ifName:%{public}s fail", ifName); close(fd); return SOFTBUS_ERR; } diff --git a/core/bus_center/interface/bus_center_info_key.h b/core/bus_center/interface/bus_center_info_key.h index 5868b9fac75c8f66b5a1041a8ac5fa9b819cea81..a46eb3ce79e0531061ffea7742e64f85f9870a90 100644 --- a/core/bus_center/interface/bus_center_info_key.h +++ b/core/bus_center/interface/bus_center_info_key.h @@ -51,6 +51,7 @@ typedef enum { NUM_KEY_MASTER_NODE_WEIGHT, NUM_KEY_P2P_ROLE, NUM_KEY_DISCOVERY_TYPE, + NUM_KEY_TRANS_PROTOCOLS, NUM_KEY_END, } InfoKey; diff --git a/core/bus_center/interface/bus_center_manager.h b/core/bus_center/interface/bus_center_manager.h index e14b1b95e13ba6cfddd3957b96b08d1668550bba..3111d7ca27c0818c45af511baace70ff1acfd531 100644 --- a/core/bus_center/interface/bus_center_manager.h +++ b/core/bus_center/interface/bus_center_manager.h @@ -58,10 +58,13 @@ int32_t LnnSetLocalStrInfo(InfoKey key, const char *info); int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info); int32_t LnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len); int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info); +int32_t LnnGetLocalNum64Info(InfoKey key, int64_t *info); +int32_t LnnSetLocalNum64Info(InfoKey key, int64_t info); int32_t LnnGetAllOnlineNodeInfo(NodeBasicInfo **info, int32_t *infoNum); int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info); int32_t LnnGetNodeKeyInfo(const char *networkId, int key, uint8_t *info, uint32_t infoLen); int32_t LnnGetNetworkIdByUuid(const char *uuid, char *buf, uint32_t len); +bool LnnIsMasterNode(void); int32_t LnnServerJoin(ConnectionAddr *addr); int32_t LnnServerLeave(const char *networkId); diff --git a/core/bus_center/lnn/lane_hub/heartbeat/include/lnn_heartbeat_strategy.h b/core/bus_center/lnn/lane_hub/heartbeat/include/lnn_heartbeat_strategy.h index cb535829960d810158794752714d4f6fa8d310aa..0333bdec4701c23123ef3d5bfc4dbafd47048882 100644 --- a/core/bus_center/lnn/lane_hub/heartbeat/include/lnn_heartbeat_strategy.h +++ b/core/bus_center/lnn/lane_hub/heartbeat/include/lnn_heartbeat_strategy.h @@ -73,7 +73,6 @@ int32_t ShiftLNNGear(const char *pkgName, int32_t callingUid, const char *target int32_t LnnGetHeartbeatGearMode(GearMode *mode); int32_t LnnGetHeartbeatImplPolicy(LnnHeartbeatImplType type, HeartbeatImplPolicy *implPolicy); int32_t LnnOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType addrType); -int32_t LnnNotifyMasterNodeChanged(const char *masterUdid, int32_t weight); int32_t LnnStartHeartbeatDelay(void); void LnnStopHeartbeatNow(void); diff --git a/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy.c b/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy.c index 7aec3cdddd38c32d691b2de48c436bdac3d14fdb..4ead9acc602206309de70db14531818afd468bab 100644 --- a/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy.c +++ b/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy.c @@ -18,6 +18,7 @@ #include #include +#include "bus_center_event.h" #include "bus_center_manager.h" #include "lnn_distributed_net_ledger.h" #include "lnn_heartbeat_fsm.h" @@ -37,9 +38,7 @@ typedef struct { } LnnHeartbeatStrategy; static LnnHeartbeatStrategy g_strategy = { - .policy[HB_IMPL_TYPE_BLE] = { - .implPolicy = NULL, - }, + .policy[HB_IMPL_TYPE_BLE] = {.implPolicy = NULL}, }; static int32_t HbMonitorInit(void) @@ -101,8 +100,8 @@ static int32_t ResetHeartbeatParam(int32_t callingUid, GearMode mode, const Hear return SOFTBUS_OK; } -int32_t ShiftLNNGear(const char *pkgName, int32_t callingUid, const char *targetNetworkId, - GearMode mode, const HeartbeatImplPolicy *implPolicy) +int32_t ShiftLNNGear(const char *pkgName, int32_t callingUid, const char *targetNetworkId, GearMode mode, + const HeartbeatImplPolicy *implPolicy) { if (pkgName == NULL || callingUid <= HB_INVALID_UID) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "HB shift gear get invalid param"); @@ -175,22 +174,20 @@ int32_t LnnOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType ad return SOFTBUS_OK; } -int32_t LnnNotifyMasterNodeChanged(const char *masterUdid, int32_t weight) +static void LnnHeartbeatMasterNodeChangeEventHandler(const LnnEventBasicInfo *info) { - (void)weight; - char localUdid[UDID_BUF_LEN] = {0}; - - if (masterUdid == NULL) { - return SOFTBUS_INVALID_PARAM; - } - if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "HB notify master node changed get local udid err"); - return SOFTBUS_ERR; + if (info == NULL || info->event != LNN_EVENT_NODE_MASTER_STATE_CHANGED) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "bad input"); + return; } - if (strcmp(masterUdid, localUdid) == 0) { - return LnnPostMsgToHbFsm(EVENT_HB_AS_MASTER_NODE, NULL); + LnnMasterNodeChangedEvent *masterNodeChangeEvent = (LnnMasterNodeChangedEvent *)info; + + int32_t ret = LnnPostMsgToHbFsm( + masterNodeChangeEvent->isMasterNode ? EVENT_HB_AS_MASTER_NODE : EVENT_HB_AS_NORMAL_NODE, NULL); + if (ret != SOFTBUS_OK) { + SoftBusLog( + SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "notify master node change to heartbeat module failed. ret=%d", ret); } - return LnnPostMsgToHbFsm(EVENT_HB_AS_NORMAL_NODE, NULL); } int32_t LnnStartHeartbeatDelay(void) @@ -234,6 +231,11 @@ int32_t LnnInitHeartbeat(void) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "HB monitor init fail!"); return SOFTBUS_ERR; } + if (LnnRegisterEventHandler(LNN_EVENT_NODE_MASTER_STATE_CHANGED, LnnHeartbeatMasterNodeChangeEventHandler) != + SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "HB monitor regist event fail!"); + return SOFTBUS_ERR; + } SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "heartbeat(HB) init success"); return SOFTBUS_OK; } @@ -243,4 +245,5 @@ void LnnDeinitHeartbeat(void) LnnHbFsmDeinit(); HbMonitorDeinit(); LnnHbMgrDeinit(); + LnnUnregisterEventHandler(LNN_EVENT_NODE_MASTER_STATE_CHANGED, LnnHeartbeatMasterNodeChangeEventHandler); } diff --git a/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy_virtual.c b/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy_virtual.c index aaeb5fd155fc53272f2f08c0336e986db7d5bb00..3d43a18b67804fb005f66dcc637c0121ca9f3288 100644 --- a/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy_virtual.c +++ b/core/bus_center/lnn/lane_hub/heartbeat/src/lnn_heartbeat_strategy_virtual.c @@ -50,13 +50,6 @@ int32_t LnnOfflineTimingByHeartbeat(const char *networkId, ConnectionAddrType ad return SOFTBUS_NOT_IMPLEMENT; } -int32_t LnnNotifyMasterNodeChanged(const char *masterUdid, int32_t weight) -{ - (void)masterUdid; - (void)weight; - return SOFTBUS_NOT_IMPLEMENT; -} - int32_t LnnStartHeartbeatDelay(void) { return SOFTBUS_OK; diff --git a/core/bus_center/lnn/net_builder/include/lnn_exchange_device_info.h b/core/bus_center/lnn/net_builder/include/lnn_exchange_device_info.h index 845e90f72facae2df595927a1a47289a0f162982..07e986748a700b12d62edf62cea0e7717abaa918 100644 --- a/core/bus_center/lnn/net_builder/include/lnn_exchange_device_info.h +++ b/core/bus_center/lnn/net_builder/include/lnn_exchange_device_info.h @@ -45,6 +45,7 @@ extern "C" { #define BLE_P2P "BLE_P2P" #define P2P_MAC_ADDR "P2P_MAC_ADDR" #define P2P_ROLE "P2P_ROLE" +#define TRANSPORT_PROTOCOL "TRANSPORT_PROTOCOL" #define CODE_VERIFY_IP 1 #define CODE_VERIFY_BT 5 diff --git a/core/bus_center/lnn/net_builder/src/lnn_exchange_device_info.c b/core/bus_center/lnn/net_builder/src/lnn_exchange_device_info.c index 99fc8b70a9e661a3c98311891d7221a75c317531..7a32ee346b362c998fab3c1f4ef7b566c17f317a 100644 --- a/core/bus_center/lnn/net_builder/src/lnn_exchange_device_info.c +++ b/core/bus_center/lnn/net_builder/src/lnn_exchange_device_info.c @@ -21,6 +21,7 @@ #include "bus_center_manager.h" #include "lnn_distributed_net_ledger.h" #include "lnn_local_net_ledger.h" +#include "lnn_network_manager.h" #include "lnn_node_info.h" #include "lnn_settingdata_event_monitor.h" #include "softbus_adapter_mem.h" @@ -56,14 +57,15 @@ static int32_t PackCommon(cJSON *json, const NodeInfo *info, SoftBusVersion vers !AddNumberToJsonObject(json, CONN_CAP, info->netCapacity) || !AddNumberToJsonObject(json, P2P_ROLE, LnnGetP2pRole(info)) || !AddBoolToJsonObject(json, BLE_P2P, info->isBleP2p) || - !AddStringToJsonObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info))) { + !AddStringToJsonObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info)) || + !AddNumber64ToJsonObject(json, TRANSPORT_PROTOCOL, (int64_t)info->supportedProtocols)) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AddStringToJsonObject Fail."); return SOFTBUS_ERR; } return SOFTBUS_OK; } -static void UnPackCommon(const cJSON* json, NodeInfo *info, SoftBusVersion version) +static void UnPackCommon(const cJSON *json, NodeInfo *info, SoftBusVersion version) { char deviceType[DEVICE_TYPE_BUF_LEN] = {0}; uint16_t typeId; @@ -106,14 +108,13 @@ static char *PackBt(const NodeInfo *info, SoftBusVersion version) return NULL; } SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "PackBt enter!"); - cJSON* json = cJSON_CreateObject(); + cJSON *json = cJSON_CreateObject(); if (json == NULL) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "create cjson object error!"); return NULL; } - if (!AddNumberToJsonObject(json, CODE, CODE_VERIFY_BT) || - !AddStringToJsonObject(json, BT_MAC, LnnGetBtMac(info))) { + if (!AddNumberToJsonObject(json, CODE, CODE_VERIFY_BT) || !AddStringToJsonObject(json, BT_MAC, LnnGetBtMac(info))) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AddToJsonObject error!"); cJSON_Delete(json); return NULL; @@ -140,11 +141,14 @@ static int32_t UnPackBt(const cJSON *json, NodeInfo *info, SoftBusVersion versio return SOFTBUS_INVALID_PARAM; } (void)GetJsonObjectStringItem(json, BT_MAC, info->connectInfo.macAddr, MAC_LEN); + if (!GetJsonObjectNumber64Item(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) { + info->supportedProtocols = LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE; + } UnPackCommon(json, info, version); return SOFTBUS_OK; } -static int32_t UnPackWifi(const cJSON* json, NodeInfo *info, SoftBusVersion version) +static int32_t UnPackWifi(const cJSON *json, NodeInfo *info, SoftBusVersion version) { if (info == NULL || json == NULL) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!"); @@ -153,6 +157,9 @@ static int32_t UnPackWifi(const cJSON* json, NodeInfo *info, SoftBusVersion vers (void)GetJsonObjectNumberItem(json, AUTH_PORT, &info->connectInfo.authPort); (void)GetJsonObjectNumberItem(json, SESSION_PORT, &info->connectInfo.sessionPort); (void)GetJsonObjectNumberItem(json, PROXY_PORT, &info->connectInfo.proxyPort); + if (!GetJsonObjectNumber64Item(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) { + info->supportedProtocols = LNN_PROTOCOL_IP; + } UnPackCommon(json, info, version); return SOFTBUS_OK; } @@ -164,14 +171,13 @@ static char *PackWifi(const NodeInfo *info, SoftBusVersion version) return NULL; } SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "PackWifi enter!"); - cJSON* json = cJSON_CreateObject(); + cJSON *json = cJSON_CreateObject(); if (json == NULL) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "create cjson object error!"); return NULL; } - if (!AddNumberToJsonObject(json, CODE, CODE_VERIFY_IP) || - !AddNumberToJsonObject(json, BUS_MAX_VERSION, BUS_V2) || + if (!AddNumberToJsonObject(json, CODE, CODE_VERIFY_IP) || !AddNumberToJsonObject(json, BUS_MAX_VERSION, BUS_V2) || !AddNumberToJsonObject(json, BUS_MIN_VERSION, BUS_V1) || !AddNumberToJsonObject(json, AUTH_PORT, LnnGetAuthPort(info)) || !AddNumberToJsonObject(json, SESSION_PORT, LnnGetSessionPort(info)) || @@ -217,7 +223,7 @@ static void UpdateDeviceNameFromSetting(void) } static ProcessLedgerInfo g_processFuncs[] = { - {AUTH_BT, PackBt, UnPackBt}, + {AUTH_BT, PackBt, UnPackBt }, {AUTH_WIFI, PackWifi, UnPackWifi}, }; @@ -246,8 +252,7 @@ char *PackLedgerInfo(SoftBusVersion version, AuthType type) return NULL; } -static int32_t UnPackLedgerInfo(const cJSON *json, NodeInfo *info, - SoftBusVersion version, AuthType type) +static int32_t UnPackLedgerInfo(const cJSON *json, NodeInfo *info, SoftBusVersion version, AuthType type) { uint32_t i; if (info == NULL || json == NULL) { @@ -262,8 +267,8 @@ static int32_t UnPackLedgerInfo(const cJSON *json, NodeInfo *info, return SOFTBUS_ERR; } -uint8_t *LnnGetExchangeNodeInfo(int32_t seq, AuthType authType, SoftBusVersion version, - uint32_t *outSize, int32_t *side) +uint8_t *LnnGetExchangeNodeInfo( + int32_t seq, AuthType authType, SoftBusVersion version, uint32_t *outSize, int32_t *side) { char *data = NULL; uint8_t *encryptData = NULL; @@ -301,8 +306,8 @@ uint8_t *LnnGetExchangeNodeInfo(int32_t seq, AuthType authType, SoftBusVersion v return encryptData; } -int32_t LnnParsePeerNodeInfo(ConnectOption *option, AuthType authType, NodeInfo *info, - const ParseBuf *bufInfo, AuthSideFlag side, SoftBusVersion version) +int32_t LnnParsePeerNodeInfo(ConnectOption *option, AuthType authType, NodeInfo *info, const ParseBuf *bufInfo, + AuthSideFlag side, SoftBusVersion version) { cJSON *json = NULL; int ret = SOFTBUS_OK; diff --git a/core/bus_center/lnn/net_builder/src/lnn_net_builder.c b/core/bus_center/lnn/net_builder/src/lnn_net_builder.c index f02ec7516dde4dfde2ea7f0583baf9f33809c927..eee736fb0914b8a82824b92c62d2c4e272b8e22a 100644 --- a/core/bus_center/lnn/net_builder/src/lnn_net_builder.c +++ b/core/bus_center/lnn/net_builder/src/lnn_net_builder.c @@ -28,10 +28,10 @@ #include "lnn_distributed_net_ledger.h" #include "lnn_exchange_device_info.h" #include "lnn_heartbeat_strategy.h" -#include "lnn_ip_utils.h" #include "lnn_local_net_ledger.h" #include "lnn_network_id.h" #include "lnn_network_manager.h" +#include "lnn_ip_network_impl.h" #include "lnn_node_weight.h" #include "lnn_p2p_info.h" #include "lnn_sync_info_manager.h" @@ -269,7 +269,7 @@ static bool IsNodeOnline(const char *networkId) return false; } -static void UpdateLocalMasterNode(const char *masterUdid, int32_t weight) +static void UpdateLocalMasterNode(bool isCurrentNode, const char *masterUdid, int32_t weight) { if (LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, masterUdid) != SOFTBUS_OK) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local master udid failed"); @@ -278,9 +278,7 @@ static void UpdateLocalMasterNode(const char *masterUdid, int32_t weight) if (LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, weight) != SOFTBUS_OK) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local master weight failed"); } - if (LnnNotifyMasterNodeChanged(masterUdid, weight) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "notify master node change to heartbeat module failed"); - } + LnnNotifyMasterNodeChanged(isCurrentNode, masterUdid, weight); SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "update local master weight=%d", weight); } @@ -906,7 +904,7 @@ static int32_t TryElectMasterNodeOnline(const LnnConnectionFsm *connFsm) connFsm->id, rc); return SOFTBUS_OK; } - UpdateLocalMasterNode(peerMasterUdid, peerMasterWeight); + UpdateLocalMasterNode(false, peerMasterUdid, peerMasterWeight); SendElectMessageToAll(connFsm->connInfo.peerNetworkId); return SOFTBUS_OK; } @@ -925,7 +923,7 @@ static int32_t TryElectMasterNodeOffline(const LnnConnectionFsm *connFsm) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "local is master node(%u), no need elect again", connFsm->id); } else { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "maybe master node(%u) offline, elect again", connFsm->id); - UpdateLocalMasterNode(localUdid, LnnGetLocalWeight()); + UpdateLocalMasterNode(true, localUdid, LnnGetLocalWeight()); SendElectMessageToAll(connFsm->connInfo.peerNetworkId); } return SOFTBUS_OK; @@ -997,7 +995,7 @@ static int32_t ProcessMasterElect(const void *para) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "[id=%u]weight compare result: %d", connFsm->id, compareRet); if (compareRet != 0) { if (compareRet < 0) { - UpdateLocalMasterNode(msgPara->masterUdid, msgPara->masterWeight); + UpdateLocalMasterNode(false, msgPara->masterUdid, msgPara->masterWeight); SendElectMessageToAll(connFsm->connInfo.peerNetworkId); } else { rc = SyncElectMessage(connFsm->connInfo.peerNetworkId); @@ -1115,7 +1113,7 @@ static int32_t GetCurrentConnectType(ConnectionAddrType *type) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnGetLocalStrInfo getCurrentConnectType failed"); return SOFTBUS_ERR; } - if (LnnGetAddrTypeByIfName(ifCurrentName, strlen(ifCurrentName), type) != SOFTBUS_OK) { + if (LnnGetAddrTypeByIfName(ifCurrentName, type) != SOFTBUS_OK) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "getCurrentConnectType unknown connect type"); return SOFTBUS_ERR; } @@ -1643,7 +1641,7 @@ int32_t LnnRequestLeaveByAddrType(const bool *type, uint32_t typeLen) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid typeLen"); return SOFTBUS_ERR; } - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "LnnRequestLeaveByAddrType"); + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "LnnRequestLeaveByAddrType"); if (g_netBuilder.isInit == false) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "no init"); return SOFTBUS_ERR; diff --git a/core/bus_center/lnn/net_buscenter/include/lnn_ip_network_impl.h b/core/bus_center/lnn/net_buscenter/include/lnn_ip_network_impl.h index ac9ad7f2cbc240f1a7221f192a37d86fa0068d2e..503a04c72fabfe692bda56b7dc07a6f86e2a64c6 100755 --- a/core/bus_center/lnn/net_buscenter/include/lnn_ip_network_impl.h +++ b/core/bus_center/lnn/net_buscenter/include/lnn_ip_network_impl.h @@ -17,6 +17,9 @@ #define LNN_IP_NETWORK_IMPL_H #include +#include "softbus_common.h" + +#define LNN_LOOPBACK_IP "127.0.0.1" #ifdef __cplusplus #if __cplusplus @@ -24,13 +27,7 @@ extern "C" { #endif #endif -int32_t LnnInitIpNetwork(void); - -int32_t LnnDeinitIpNetwork(void); - -int32_t LnnInitIpNetworkDelay(void); - -void LnnNotifyOfflineMsg(void); +void LnnNotifyAllTypeOffline(ConnectionAddrType type); #ifdef __cplusplus #if __cplusplus diff --git a/core/bus_center/lnn/net_buscenter/include/lnn_network_manager.h b/core/bus_center/lnn/net_buscenter/include/lnn_network_manager.h index 8f9b33b61f418e1b739c82293d96166f5ab4861f..b0b1614120c1713ded7a75194e2176cbb589fe21 100755 --- a/core/bus_center/lnn/net_buscenter/include/lnn_network_manager.h +++ b/core/bus_center/lnn/net_buscenter/include/lnn_network_manager.h @@ -16,9 +16,10 @@ #ifndef LNN_NETWORK_MANAGER_H #define LNN_NETWORK_MANAGER_H -#include #include - +#include +#include "bus_center_info_key.h" +#include "common_list.h" #include "softbus_bus_center.h" #ifdef __cplusplus @@ -27,11 +28,76 @@ extern "C" { #endif #endif +#define LNN_LOOPBACK_IFNAME "lo" + +// protocol ability +#define PROTOCOL_ABILITY_MESSAGE 0x1 +#define PROTOCOL_ABILITY_BYTES (0x1 << 1) +#define PROTOCOL_ABILITY_STREAM (0x1 << 2) +#define PROTOCOL_ABILITY_FILE (0x1 << 3) +typedef uint32_t LnnProtocolAbility; + +// netif type +#define LNN_NETIF_TYPE_ETH (0x1) +#define LNN_NETIF_TYPE_WLAN (0x1 << 1) +#define LNN_NETIF_TYPE_BR (0x1 << 2) +#define LNN_NETIF_TYPE_BLE (0x1 << 3) +typedef uint16_t LnnNetIfType; + +// protocol type +#define LNN_PROTOCOL_BR (0x1) +#define LNN_PROTOCOL_BLE (1L << 1) +#define LNN_PROTOCOL_IP (1L << 2) +#define LNN_PROTOCOL_DFILE (1L << 3) +#define LNN_PROTOCOL_COAP (1L << 4) +#define LNN_PROTOCOL_DMSG (1L << 5) +#define LNN_PROTOCOL_VTP (1L << 6) +#define LNN_PROTOCOL_NIP (1L << 7) + +typedef uint32_t ProtocolType; + +#define LNN_NETWORK_MAX_PROTOCOL_COUNT 3 + +typedef struct { + ListNode node; + LnnNetIfType type; + char ifName[NET_IF_NAME_LEN]; +} LnnNetIfMgr; + +typedef LnnNetIfMgr *(*LnnNetIfManagerBuilder)(const char *ifName); + +typedef enum { + CHOICE_VISIT_NEXT, + CHOICE_FINISH_VISITING +} VisitNextChoice; + +typedef VisitNextChoice (*VisitNetifCallback)(const LnnNetIfMgr *, void *); + +typedef struct LnnProtocolManager { + int32_t (*Init)(struct LnnProtocolManager *self); + void (*Deinit)(struct LnnProtocolManager *self); + int32_t (*Enable)(struct LnnProtocolManager *self, LnnNetIfMgr *netifMgr); + int32_t (*Disable)(struct LnnProtocolManager *self, LnnNetIfMgr *netifMgr); + ProtocolType id; + const ProtocolType supportedNetif; + uint8_t pri; +} LnnProtocolManager; + +typedef VisitNextChoice (*VisitProtocolCallback)(const LnnProtocolManager *, void *); + +int32_t LnnRegistProtocol(LnnProtocolManager *impl); + int32_t LnnInitNetworkManager(void); int32_t LnnInitNetworkManagerDelay(void); void LnnDeinitNetworkManager(void); -void LnnNotifyAllTypeOffline(ConnectionAddrType type); +int32_t LnnGetNetIfTypeByName(const char *ifName, LnnNetIfType *type); +int32_t LnnGetAddrTypeByIfName(const char *ifName, ConnectionAddrType *type); + +bool LnnIsAutoNetWorkingEnabled(void); + +bool LnnVisitNetif(VisitNetifCallback callback, void *data); +bool LnnVisitProtocol(VisitProtocolCallback callback, void *data); #ifdef __cplusplus #if __cplusplus diff --git a/core/bus_center/utils/include/lnn_ip_utils.h b/core/bus_center/lnn/net_buscenter/include/lnn_physical_subnet_manager.h similarity index 33% rename from core/bus_center/utils/include/lnn_ip_utils.h rename to core/bus_center/lnn/net_buscenter/include/lnn_physical_subnet_manager.h index b7e5f37c1a27aaaeedea03566272c59b2cb0f1b7..091bf33a1053d550975bc10f000bf4cdc9e393f0 100644 --- a/core/bus_center/utils/include/lnn_ip_utils.h +++ b/core/bus_center/lnn/net_buscenter/include/lnn_physical_subnet_manager.h @@ -1,49 +1,67 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef LNN_IP_UTILS_H -#define LNN_IP_UTILS_H - -#include - -#include "softbus_bus_center.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define LNN_LOOPBACK_IP "127.0.0.1" -#define LNN_LOOPBACK_IFNAME "lo" -#define LNN_IF_NAME_WLAN "wlan0" -#define LNN_IF_NAME_ETH "eth0" - -typedef enum { - LNN_ETH_TYPE = 0, - LNN_WLAN_TYPE, - LNN_MAX_NUM_TYPE, -} LnnNetIfNameType; - -int32_t LnnReadNetConfigList(void); - -int32_t LnnClearNetConfigList(void); - -int32_t LnnGetLocalIp(char *ip, uint32_t len, char *ifName, uint32_t ifNameLen); - -int32_t LnnGetAddrTypeByIfName(const char *ifName, uint32_t ifNameLen, ConnectionAddrType *type); - -#ifdef __cplusplus -} -#endif -#endif /* LNN_IP_UTILS_H */ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LNN_SUBNET_MANAGER_H +#define LNN_SUBNET_MANAGER_H + +#include "lnn_network_manager.h" +#include "stdint.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +typedef enum { + LNN_SUBNET_IDLE, // can be enable + LNN_SUBNET_RUNNING, + LNN_SUBNET_SHUTDOWN, // will not be auto Enable + LNN_SUBNET_RESETTING, // Will be auto Enable in high pri + LNN_SUBNET_STATUS_MAX +} LnnPhysicalSubnetStatus; + +typedef struct LnnPhysicalSubnet { + char ifName[NET_IF_NAME_LEN]; + ProtocolType protocolType; + LnnPhysicalSubnetStatus status; + void (*Destroy)(struct LnnPhysicalSubnet *); + void (*OnNetifStatusChanged)(struct LnnPhysicalSubnet *); + void (*OnSoftbusNetworkDisconnected)(struct LnnPhysicalSubnet *); +} LnnPhysicalSubnet; + +typedef int16_t PhysicalSubnetId; +#define PHYSICAL_SUBNET_ID_NOT_EXIST (-1) + +int32_t LnnInitPhysicalSubnetManager(void); + +void LnnDeinitPhysicalSubnetManager(void); + +int32_t LnnRegistPhysicalSubnet(LnnPhysicalSubnet *manager); + +int32_t LnnUnregistPhysicalSubnetByType(ProtocolType type); + +void LnnNotifyPhysicalSubnetAddressChanged(const char *ifName, ProtocolType type); + +typedef VisitNextChoice (*LnnVisitPhysicalSubnetCallback)(const LnnPhysicalSubnet *, void *); +bool LnnVisitPhysicalSubnet(LnnVisitPhysicalSubnetCallback callback, void *data); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif + +#endif \ No newline at end of file diff --git a/core/bus_center/lnn/net_buscenter/net_manager.gni b/core/bus_center/lnn/net_buscenter/net_manager.gni index caa712a0be2ff55d329415ca6d16adf4c46e2a06..51341b051714e8f6f17ab7382fe0c1cc64906aae 100644 --- a/core/bus_center/lnn/net_buscenter/net_manager.gni +++ b/core/bus_center/lnn/net_buscenter/net_manager.gni @@ -17,6 +17,7 @@ if (dsoftbus_standard_feature_lnn_net) { bus_center_net_mgr_src = [ "$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/src/lnn_network_manager.c", "$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/src/lnn_ip_network_impl.c", + "$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/src/lnn_physical_subnet_manager.c", ] } else { bus_center_net_mgr_src = [ "$dsoftbus_root_path/core/bus_center/lnn/net_buscenter/src/lnn_network_manager_virtual.c" ] diff --git a/core/bus_center/lnn/net_buscenter/src/lnn_ip_network_impl.c b/core/bus_center/lnn/net_buscenter/src/lnn_ip_network_impl.c index 2cb24988d2cfbd7781fb92275b54099775108139..462cfa0419f92e757d4af9594eb7ca4c67b31f32 100755 --- a/core/bus_center/lnn/net_buscenter/src/lnn_ip_network_impl.c +++ b/core/bus_center/lnn/net_buscenter/src/lnn_ip_network_impl.c @@ -13,12 +13,11 @@ * limitations under the License. */ -#include "lnn_network_manager.h" +#include "lnn_ip_network_impl.h" #include -#include - #include +#include #include #include "auth_interface.h" @@ -26,9 +25,13 @@ #include "bus_center_info_key.h" #include "bus_center_manager.h" #include "disc_interface.h" -#include "lnn_net_builder.h" #include "lnn_discovery_manager.h" -#include "lnn_ip_utils.h" +#include "lnn_ip_utils_adapter.h" +#include "lnn_linkwatch.h" +#include "lnn_net_builder.h" +#include "lnn_network_manager.h" +#include "lnn_physical_subnet_manager.h" +#include "softbus_adapter_mem.h" #include "softbus_adapter_thread.h" #include "softbus_def.h" #include "softbus_errcode.h" @@ -38,16 +41,23 @@ #define IP_DEFAULT_PORT 0 -typedef struct { - bool isIpLinkClosed; - bool autoNetworkingSwitch; - SoftBusMutex lock; -} LNNIpNetworkInfo; +static int32_t GetAvailableIpAddr(const char *ifName, char *ip, uint32_t size) +{ + if (!LnnIsLinkReady(ifName)) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ifName %s link not ready", ifName); + return SOFTBUS_ERR; + } -static LNNIpNetworkInfo g_lnnIpNetworkInfo = { - .isIpLinkClosed = true, - .autoNetworkingSwitch = true, -}; + if (GetNetworkIpByIfName(ifName, ip, NULL, size) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:get network IP by ifName failed!", __func__); + return SOFTBUS_ERR; + } + + if (strcmp(ip, LNN_LOOPBACK_IP) == 0) { + return SOFTBUS_ERR; + } + return SOFTBUS_OK; +} static int32_t OpenAuthPort(void) { @@ -148,19 +158,6 @@ static void CloseIpLink(void) CloseProxyPort(); } -static int32_t SetLocalIpInfo(char *ipAddr, char *ifName) -{ - if (LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, ipAddr) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local ip error!\n"); - return SOFTBUS_ERR; - } - if (LnnSetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local ifname error!\n"); - return SOFTBUS_ERR; - } - return SOFTBUS_OK; -} - static int32_t GetLocalIpInfo(char *ipAddr, uint32_t ipAddrLen, char *ifName, uint32_t ifNameLen) { if (LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, ipAddr, ipAddrLen) != SOFTBUS_OK) { @@ -168,27 +165,22 @@ static int32_t GetLocalIpInfo(char *ipAddr, uint32_t ipAddrLen, char *ifName, ui return SOFTBUS_ERR; } if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName, ifNameLen) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ifname error!\n"); + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ifName error!\n"); return SOFTBUS_ERR; } return SOFTBUS_OK; } -static int32_t GetUpdateLocalIp(char *ipAddr, uint32_t ipAddrLen, char *ifName, uint32_t ifNameLen) +static int32_t SetLocalIpInfo(const char *ipAddr, const char *ifName) { - if (LnnGetLocalIp(ipAddr, ipAddrLen, ifName, ifNameLen) == SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "get ip success\n"); - return SOFTBUS_OK; - } - if (strncpy_s(ipAddr, ipAddrLen, LNN_LOOPBACK_IP, strlen(LNN_LOOPBACK_IP)) != EOK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy loopback ip addr failed\n"); + if (LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, ipAddr) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local ip error!\n"); return SOFTBUS_ERR; } - if (strncpy_s(ifName, ifNameLen, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) != EOK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy loopback ifname failed\n"); + if (LnnSetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local ifName error!\n"); return SOFTBUS_ERR; } - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set loopback ip as default\n"); return SOFTBUS_OK; } @@ -197,8 +189,9 @@ static void LeaveOldIpNetwork(const char *ifCurrentName) ConnectionAddrType type = CONNECTION_ADDR_MAX; bool addrType[CONNECTION_ADDR_MAX] = {0}; - if (LnnGetAddrTypeByIfName(ifCurrentName, strlen(ifCurrentName), &type) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LeaveOldIpNetwork LnnGetAddrTypeByIfName error"); + if (LnnGetAddrTypeByIfName(ifCurrentName, &type) != SOFTBUS_OK) { + SoftBusLog( + SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:LnnGetAddrTypeByIfName failed! ifName=%s", __func__, ifCurrentName); return; } @@ -214,281 +207,349 @@ static void LeaveOldIpNetwork(const char *ifCurrentName) } } -static int32_t UpdateLocalIp(char *ipAddr, uint32_t ipAddrLen, char *ifName, uint32_t ifNameLen) +static int32_t ReleaseMainPort(const char *ifName) { - char ipNewAddr[IP_LEN] = {0}; - char ifNewName[NET_IF_NAME_LEN] = {0}; + char oldMainIf[NET_IF_NAME_LEN] = {0}; + do { + if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, oldMainIf, sizeof(oldMainIf)) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:get local ifName error!\n", __func__); + break; + } + + if (strcmp(ifName, oldMainIf) != 0) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ifName %s is not main port!\n", ifName); + return SOFTBUS_ERR; + } + } while (false); + + if (SetLocalIpInfo(LNN_LOOPBACK_IP, LNN_LOOPBACK_IFNAME) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:set local ip info failed\n", __func__); + return SOFTBUS_ERR; + } + return SOFTBUS_OK; +} - if (GetLocalIpInfo(ipAddr, ipAddrLen, ifName, ifNameLen) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get current ip info failed\n"); +static int32_t RequestMainPort(const char *ifName, const char *address) +{ + if (strcmp(ifName, LNN_LOOPBACK_IFNAME) == 0) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "loopback ifName not allowed!\n"); return SOFTBUS_ERR; } - if (GetUpdateLocalIp(ipNewAddr, IP_LEN, ifNewName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get new ip info failed\n"); + if (strcmp(address, LNN_LOOPBACK_IP) == 0) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "loopback ip not allowed!\n"); return SOFTBUS_ERR; } - if (strcmp(ipAddr, ipNewAddr) == 0 && strcmp(ifName, ifNewName) == 0) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "ip info not changed\n"); + + char oldMainIf[NET_IF_NAME_LEN] = {0}; + if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, oldMainIf, sizeof(oldMainIf)) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ifName error!\n"); return SOFTBUS_ERR; } - if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) != 0) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "close previous ip link and stop previous discovery\n"); - CloseIpLink(); - LnnStopPublish(); - LnnStopDiscovery(); - DiscLinkStatusChanged(LINK_STATUS_DOWN, COAP); + + if (strcmp(oldMainIf, ifName) != 0 && strcmp(oldMainIf, LNN_LOOPBACK_IFNAME) != 0) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Only 1 local subnet is allowed!\n"); + return SOFTBUS_ERR; } - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "update local ledger\n"); - if (SetLocalIpInfo(ipNewAddr, ifNewName) != SOFTBUS_OK) { + + if (SetLocalIpInfo(address, ifName) != SOFTBUS_OK) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local ip info failed\n"); return SOFTBUS_ERR; } + return SOFTBUS_OK; } -static void IpAddrChangeEventHandler(const LnnEventBasicInfo *info) +static int32_t EnableIpSubnet(LnnPhysicalSubnet *subnet) { - char ipCurrentAddr[IP_LEN] = {0}; - char ifCurrentName[NET_IF_NAME_LEN] = {0}; + char address[IP_LEN] = {0}; - if (info == NULL || info->event != LNN_EVENT_IP_ADDR_CHANGED) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "not interest event"); - return; - } - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != 0) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); - return; - } - if (UpdateLocalIp(ipCurrentAddr, IP_LEN, ifCurrentName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return; + int32_t ret = GetAvailableIpAddr(subnet->ifName, address, sizeof(address)); + if (ret != SOFTBUS_OK) { + SoftBusLog( + SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get available Ip failed!ifName=%s, ret=%d", subnet->ifName, ret); + return ret; } - LeaveOldIpNetwork(ifCurrentName); - g_lnnIpNetworkInfo.isIpLinkClosed = true; - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); -} -static void WifiStateChangeEventHandler(const LnnEventBasicInfo *info) -{ - char ipCurrentAddr[IP_LEN] = {0}; - char ifCurrentName[NET_IF_NAME_LEN] = {0}; + if (RequestMainPort(subnet->ifName, address)) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "request main port failed!ifName=%s", subnet->ifName); + return SOFTBUS_ERR; + } - if (info == NULL || info->event != LNN_EVENT_WIFI_STATE_CHANGED) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "not interest event"); - return; + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "open ip link and start discovery\n"); + if (OpenIpLink() != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open ip link failed\n"); } - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != 0) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); - return; + DiscLinkStatusChanged(LINK_STATUS_UP, COAP); + if (LnnStartPublish() != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start publish failed\n"); } - if (UpdateLocalIp(ipCurrentAddr, IP_LEN, ifCurrentName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return; + if (LnnIsAutoNetWorkingEnabled() && LnnStartDiscovery() != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start discovery failed\n"); } - LeaveOldIpNetwork(ifCurrentName); - g_lnnIpNetworkInfo.isIpLinkClosed = true; - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); + SetCallLnnStatus(true); + return SOFTBUS_OK; } -static int32_t UpdateLocalLedgerIp(char *ipAddr, uint32_t ipAddrLen, char *ifName, uint32_t ifNameLen) +static int32_t DisableIpSubnet(LnnPhysicalSubnet *subnet) { - if (GetUpdateLocalIp(ipAddr, ipAddrLen, ifName, ifNameLen) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get new ip info failed\n"); - return SOFTBUS_ERR; - } - if (SetLocalIpInfo(ipAddr, ifName) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "set local ip info failed\n"); - return SOFTBUS_ERR; + if (subnet->status == LNN_SUBNET_RUNNING) { + CloseIpLink(); + LnnStopPublish(); + LnnStopDiscovery(); + DiscLinkStatusChanged(LINK_STATUS_DOWN, COAP); + LeaveOldIpNetwork(subnet->ifName); + ReleaseMainPort(subnet->ifName); } return SOFTBUS_OK; } -static int32_t LnnInitAutoNetworking(void) +static int32_t ChangeIpSubnetAddress(LnnPhysicalSubnet *subnet) { - char ipAddr[IP_LEN] = {0}; - char ifName[NET_IF_NAME_LEN] = {0}; - if (LnnRegisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, IpAddrChangeEventHandler) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register ip addr change event handler failed\n"); - return SOFTBUS_ERR; - } - if (LnnRegisterEventHandler(LNN_EVENT_WIFI_STATE_CHANGED, WifiStateChangeEventHandler) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register wifi state change event handler failed\n"); - return SOFTBUS_ERR; - } - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != 0) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); - return SOFTBUS_ERR; - } - if (UpdateLocalLedgerIp(ipAddr, IP_LEN, ifName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "update local ledger ipaddr error!"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return SOFTBUS_ERR; + CloseIpLink(); + LnnStopPublish(); + LnnStopDiscovery(); + DiscLinkStatusChanged(LINK_STATUS_DOWN, COAP); + LeaveOldIpNetwork(subnet->ifName); + return SOFTBUS_OK; +} + +static void DestroyIpSubnetManager(LnnPhysicalSubnet *subnet) +{ + if (subnet->status == LNN_SUBNET_RUNNING) { + DisableIpSubnet(subnet); } - if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) != 0) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "open ip link and start discovery\n"); - if (OpenIpLink() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open ip link failed\n"); - } - DiscLinkStatusChanged(LINK_STATUS_UP, COAP); - if (LnnStartPublish() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start publish failed\n"); - } - if (g_lnnIpNetworkInfo.autoNetworkingSwitch && LnnStartDiscovery() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start discovery failed\n"); - } - SetCallLnnStatus(true); - g_lnnIpNetworkInfo.isIpLinkClosed = false; + SoftBusFree(subnet); +} + +typedef enum { + SUBNET_MANAGER_EVENT_IF_READY, + SUBNET_MANAGER_EVENT_IF_DOWN, // addr change from avaliable to + SUBNET_MANAGER_EVENT_IF_CHANGED, // addr changed + SUBNET_MANAGER_EVENT_MAX +} SubnetManagerEvent; + +typedef enum { + EVENT_RESULT_ACCEPTED = 0, + EVENT_RESULT_REJECTED, + EVENT_RESULT_OPTION_COUNT +} SubnetManagerEventResultOptions; + +static void TransactIpSubnetState(LnnPhysicalSubnet *subnet, SubnetManagerEvent event, bool isAccepted) +{ + LnnPhysicalSubnetStatus transactMap[][EVENT_RESULT_OPTION_COUNT] = { + [SUBNET_MANAGER_EVENT_IF_READY] = {LNN_SUBNET_RUNNING, LNN_SUBNET_IDLE}, + [SUBNET_MANAGER_EVENT_IF_DOWN] = {LNN_SUBNET_SHUTDOWN, subnet->status }, + [SUBNET_MANAGER_EVENT_IF_CHANGED] = {LNN_SUBNET_RESETTING, subnet->status } + }; + subnet->status = transactMap[event][isAccepted ? EVENT_RESULT_ACCEPTED : EVENT_RESULT_REJECTED]; + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "subnet [%s, %d] state change to %d", subnet->ifName, + subnet->protocolType, subnet->status); +} + +static SubnetManagerEvent GetEventInOther(LnnPhysicalSubnet *subnet) +{ + char currentIfAddress[IP_LEN] = {0}; + int32_t ret = GetAvailableIpAddr(subnet->ifName, currentIfAddress, sizeof(currentIfAddress)); + if (ret == SOFTBUS_OK) { + return SUBNET_MANAGER_EVENT_IF_READY; } else { - DiscLinkStatusChanged(LINK_STATUS_DOWN, COAP); + return subnet->status != LNN_SUBNET_SHUTDOWN ? SUBNET_MANAGER_EVENT_IF_DOWN : SUBNET_MANAGER_EVENT_MAX; } - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return SOFTBUS_OK; } -static void OnGroupCreated(const char *groupId) +static SubnetManagerEvent GetEventInRunning(LnnPhysicalSubnet *subnet) { - (void)groupId; - char ifName[NET_IF_NAME_LEN] = {0}; - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != 0) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); - return; - } - if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ifname error!\n"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return; + char currentIfAddress[IP_LEN] = {0}; + int32_t ret = GetAvailableIpAddr(subnet->ifName, currentIfAddress, sizeof(currentIfAddress)); + if (ret != SOFTBUS_OK) { + return SUBNET_MANAGER_EVENT_IF_DOWN; } - if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) == 0) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "ip invaild now, stop group create"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return; + + char localIpAddr[IP_LEN] = {0}; + char localNetifName[NET_IF_NAME_LEN] = {0}; + if (GetLocalIpInfo(localIpAddr, sizeof(localIpAddr), localNetifName, sizeof(localNetifName)) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get main ip info failed\n"); + return SUBNET_MANAGER_EVENT_IF_READY; } - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "open previous discovery again"); - LnnStopPublish(); - LnnStopDiscovery(); - if (LnnStartPublish() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start publish failed\n"); + + if (strcmp(localNetifName, subnet->ifName) != 0) { + return SUBNET_MANAGER_EVENT_IF_READY; } - if (g_lnnIpNetworkInfo.autoNetworkingSwitch && LnnStartDiscovery() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start discovery failed\n"); + + if (strcmp(localIpAddr, currentIfAddress) == 0) { + return SUBNET_MANAGER_EVENT_MAX; + } else { + return SUBNET_MANAGER_EVENT_IF_CHANGED; } - SetCallLnnStatus(true); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); } -static void OnGroupDeleted(const char *groupId) +static void OnSoftbusNetworkDisconnected(LnnPhysicalSubnet *subnet) { - (void)groupId; + if (subnet->status == LNN_SUBNET_RESETTING || subnet->status == LNN_SUBNET_IDLE) { + int32_t ret = EnableIpSubnet(subnet); + TransactIpSubnetState(subnet, SUBNET_MANAGER_EVENT_IF_READY, (ret == SOFTBUS_OK)); + } } -static VerifyCallback g_verifyCb = { - .onGroupCreated = OnGroupCreated, - .onGroupDeleted = OnGroupDeleted, -}; - -int32_t LnnInitIpNetwork(void) +static void OnNetifStatusChanged(LnnPhysicalSubnet *subnet) { - char ipAddr[IP_LEN] = {0}; - char ifName[NET_IF_NAME_LEN] = {0}; + SubnetManagerEvent event = SUBNET_MANAGER_EVENT_MAX; - if (SoftBusMutexInit(&g_lnnIpNetworkInfo.lock, NULL) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock init failed"); - return SOFTBUS_ERR; + if (subnet->status == LNN_SUBNET_RUNNING) { + event = GetEventInRunning(subnet); + } else { + event = GetEventInOther(subnet); } - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); - return SOFTBUS_ERR; + int32_t ret = SOFTBUS_ERR; + switch (event) { + case SUBNET_MANAGER_EVENT_IF_READY: { + ret = EnableIpSubnet(subnet); + break; + } + case SUBNET_MANAGER_EVENT_IF_DOWN: { + ret = DisableIpSubnet(subnet); + break; + } + case SUBNET_MANAGER_EVENT_IF_CHANGED: { + ret = ChangeIpSubnetAddress(subnet); + break; + } + + default: + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "discard unexpected event %d\n", event); + return; } - if (LnnReadNetConfigList() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "read net config list error!"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return SOFTBUS_ERR; + + TransactIpSubnetState(subnet, event, (ret == SOFTBUS_OK)); +} + +static LnnPhysicalSubnet *CreateIpSubnetManager(const char *ifName) +{ + LnnPhysicalSubnet *subnet = (LnnPhysicalSubnet *)SoftBusCalloc(sizeof(LnnPhysicalSubnet)); + if (subnet == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:oom\n", __func__); + return NULL; + } + + do { + subnet->Destroy = DestroyIpSubnetManager; + subnet->protocolType = LNN_PROTOCOL_IP; + subnet->status = LNN_SUBNET_IDLE; + subnet->OnNetifStatusChanged = OnNetifStatusChanged; + subnet->OnSoftbusNetworkDisconnected = OnSoftbusNetworkDisconnected; + + int32_t ret = strcpy_s(subnet->ifName, sizeof(subnet->ifName), ifName); + if (ret != EOK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:copy ifName failed!ret=%d\n", __func__, ret); + break; + } + return subnet; + } while (false); + + subnet->Destroy((LnnPhysicalSubnet *)subnet); + return NULL; +} + +static VisitNextChoice NotifyIpAddressChanged(const LnnPhysicalSubnet *subnet, void *data) +{ + (void)data; + if (subnet->protocolType == LNN_PROTOCOL_IP) { + LnnNotifyPhysicalSubnetAddressChanged(subnet->ifName, LNN_PROTOCOL_IP); + } + return CHOICE_VISIT_NEXT; +} + +static void IpAddrChangeEventHandler(const LnnEventBasicInfo *info) +{ + if (info == NULL || info->event != LNN_EVENT_IP_ADDR_CHANGED) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "not interest event"); + return; } - if (SoftbusGetConfig(SOFTBUS_INT_AUTO_NETWORKING_SWITCH, (unsigned char*)&g_lnnIpNetworkInfo.autoNetworkingSwitch, - sizeof(g_lnnIpNetworkInfo.autoNetworkingSwitch)) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Cannot get autoNetworkingSwitch from config file"); - g_lnnIpNetworkInfo.autoNetworkingSwitch = true; + const LnnMonitorAddressChangedEvent *event = (const LnnMonitorAddressChangedEvent *)info; + if (strlen(event->ifName) != 0) { + LnnNotifyPhysicalSubnetAddressChanged(event->ifName, LNN_PROTOCOL_IP); + } else { + (void)LnnVisitPhysicalSubnet(NotifyIpAddressChanged, NULL); } +} - if (AuthRegCallback(BUSCENTER_MONITOR, &g_verifyCb) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register auth callback fail"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return SOFTBUS_ERR; +static VisitNextChoice NotifyWlanAddressChanged(const LnnNetIfMgr *netifManager, void *data) +{ + if (netifManager->type == LNN_NETIF_TYPE_WLAN) { + LnnNotifyPhysicalSubnetAddressChanged(netifManager->ifName, LNN_PROTOCOL_IP); } + return CHOICE_VISIT_NEXT; +} - if (UpdateLocalLedgerIp(ipAddr, IP_LEN, ifName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "update local ledger ipaddr error!"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return SOFTBUS_ERR; +static void WifiStateChangeEventHandler(const LnnEventBasicInfo *info) +{ + if (info == NULL || info->event != LNN_EVENT_WIFI_STATE_CHANGED) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:not interest event", __func__); + return; } - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return SOFTBUS_OK; + (void)LnnVisitNetif(NotifyWlanAddressChanged, NULL); } -int32_t LnnInitIpNetworkDelay(void) +int32_t LnnInitIpProtocol(struct LnnProtocolManager *self) { - char udid[UDID_BUF_LEN] = {0}; - if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid error!\n"); + int32_t ret = SOFTBUS_OK; + if (LnnRegisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, IpAddrChangeEventHandler) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register ip addr change event handler failed\n"); return SOFTBUS_ERR; } - if (LnnInitAutoNetworking() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "LnnInitAutoNetworking error!\n"); + if (LnnRegisterEventHandler(LNN_EVENT_WIFI_STATE_CHANGED, WifiStateChangeEventHandler) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register wifi state change event handler failed\n"); + return SOFTBUS_ERR; } - return SOFTBUS_OK; + if (SetLocalIpInfo(LNN_LOOPBACK_IP, LNN_LOOPBACK_IFNAME) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init local ip as loopback failed!\n"); + return SOFTBUS_ERR; + } + DiscLinkStatusChanged(LINK_STATUS_DOWN, COAP); + return ret; } -int32_t LnnDeinitIpNetwork(void) +int32_t LnnEnableIpProtocol(struct LnnProtocolManager *self, LnnNetIfMgr *netifMgr) { - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != 0) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); + if (netifMgr == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:null ptr!\n", __func__); return SOFTBUS_ERR; } - - if (LnnClearNetConfigList() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "clear net config list error!"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); + LnnPhysicalSubnet *manager = CreateIpSubnetManager(netifMgr->ifName); + if (manager == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:oom!\n", __func__); return SOFTBUS_ERR; } - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); + int ret = LnnRegistPhysicalSubnet(manager); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:regist subnet manager failed!ret=%d\n", __func__, ret); + manager->Destroy(manager); + return ret; + } return SOFTBUS_OK; } -void LnnNotifyOfflineMsg(void) +void LnnDeinitIpNetwork(struct LnnProtocolManager *self) { - char ipCurrentAddr[IP_LEN] = {0}; - char ifCurrentName[NET_IF_NAME_LEN] = {0}; - - if (SoftBusMutexLock(&g_lnnIpNetworkInfo.lock) != 0) { - SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "lock failed"); - return; - } - if (!g_lnnIpNetworkInfo.isIpLinkClosed) { - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return; - } - if (GetLocalIpInfo(ipCurrentAddr, IP_LEN, ifCurrentName, NET_IF_NAME_LEN) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get current ip info failed\n"); - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); - return; - } - if (strncmp(ifCurrentName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) != 0) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "open ip link and start discovery\n"); - if (OpenIpLink() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open ip link failed\n"); - } - DiscLinkStatusChanged(LINK_STATUS_UP, COAP); - if (LnnStartPublish() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start publish failed\n"); - } - if (g_lnnIpNetworkInfo.autoNetworkingSwitch && LnnStartDiscovery() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start discovery failed\n"); - } - SetCallLnnStatus(true); - g_lnnIpNetworkInfo.isIpLinkClosed = false; - } - (void)SoftBusMutexUnlock(&g_lnnIpNetworkInfo.lock); + LnnUnregisterEventHandler(LNN_EVENT_IP_ADDR_CHANGED, IpAddrChangeEventHandler); + LnnUnregisterEventHandler(LNN_EVENT_WIFI_STATE_CHANGED, WifiStateChangeEventHandler); + LnnUnregistPhysicalSubnetByType(LNN_PROTOCOL_IP); + SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_WARN, "%s:ip network deinited", __func__); } +static LnnProtocolManager g_ipProtocol = { + .id = 0, + .pri = 0, + .supportedNetif = LNN_NETIF_TYPE_ETH | LNN_NETIF_TYPE_WLAN, + .Init = LnnInitIpProtocol, + .Deinit = LnnDeinitIpNetwork, + .Enable = LnnEnableIpProtocol, + .Disable = NULL, +}; + +int32_t RegistIPProtocolManager(void) +{ + return LnnRegistProtocol(&g_ipProtocol); +} diff --git a/core/bus_center/lnn/net_buscenter/src/lnn_network_manager.c b/core/bus_center/lnn/net_buscenter/src/lnn_network_manager.c index d8f333c1a008f156c1f1e9c9a27998834df4001f..0ffb184216bcf2f52c8868f534a0b00f22e4660a 100755 --- a/core/bus_center/lnn/net_buscenter/src/lnn_network_manager.c +++ b/core/bus_center/lnn/net_buscenter/src/lnn_network_manager.c @@ -15,85 +15,413 @@ #include "lnn_network_manager.h" -#include "lnn_ip_network_impl.h" +#include + +#include "auth_interface.h" +#include "bus_center_manager.h" +#include "disc_interface.h" +#include "lnn_discovery_manager.h" +#include "lnn_physical_subnet_manager.h" +#include "softbus_adapter_mem.h" #include "softbus_errcode.h" +#include "softbus_feature_config.h" #include "softbus_log.h" +#define LNN_MAX_IF_NAME_LEN 256 +#define LNN_DELIMITER_OUTSIDE "," +#define LNN_DELIMITER_INSIDE ":" + +#define LNN_DEFAULT_IF_NAME_WLAN "wlan0" +#define LNN_DEFAULT_IF_NAME_ETH "eth0" + typedef enum { - LNN_NETWORK_IMPL_TYPE_IP, - LNN_NETWORK_IMPL_TYPE_MAX, -} LnnNetworkImplType; - -typedef struct { - int32_t (*InitNetworkImpl)(void); - int32_t (*InitNetworkDelayImpl)(void); - int32_t (*DeinitNetworkImpl)(void); - void (*NotifyOfflineMsg)(void); -} NetworkImpl; - -static NetworkImpl g_networkImpl[LNN_NETWORK_IMPL_TYPE_MAX] = { - [LNN_NETWORK_IMPL_TYPE_IP] = { - .InitNetworkImpl = LnnInitIpNetwork, - .InitNetworkDelayImpl = LnnInitIpNetworkDelay, - .DeinitNetworkImpl = LnnDeinitIpNetwork, - .NotifyOfflineMsg = LnnNotifyOfflineMsg, - }, + LNN_ETH_TYPE = 0, + LNN_WLAN_TYPE, + LNN_MAX_NUM_TYPE, +} LnnNetIfNameType; + +static ListNode g_netIfNameList = { + .prev = &g_netIfNameList, + .next = &g_netIfNameList, }; -int32_t LnnInitNetworkManager(void) +int32_t RegistIPProtocolManager(void); + +static LnnNetIfManagerBuilder g_netifBuilders[LNN_MAX_NUM_TYPE] = {0}; + +static LnnProtocolManager *g_networkProtocols[LNN_NETWORK_MAX_PROTOCOL_COUNT] = {0}; + +static LnnNetIfMgr *CreateEthNetifMgr(const char *netIfName) { - uint32_t i; + if (netIfName == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters invalid!"); + return NULL; + } + LnnNetIfMgr *netIfMgr = (LnnNetIfMgr *)SoftBusCalloc(sizeof(LnnNetIfMgr)); + if (netIfMgr == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail: malloc LnnNetIfMgr"); + return NULL; + } + do { + ListInit(&netIfMgr->node); + if (strncpy_s(netIfMgr->ifName, NET_IF_NAME_LEN, netIfName, strlen(netIfName)) != EOK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy netIfName fail"); + break; + } + return netIfMgr; + } while (false); - for (i = 0; i < LNN_NETWORK_IMPL_TYPE_MAX; ++i) { - if (g_networkImpl[i].InitNetworkImpl == NULL) { - continue; + SoftBusFree(netIfMgr); + return NULL; +} + +static int32_t RegistNetIfMgr(LnnNetIfNameType type, LnnNetIfManagerBuilder builder) +{ + if (type >= LNN_MAX_NUM_TYPE) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:type too big!", __func__); + return SOFTBUS_ERR; + } + + if (g_netifBuilders[type] != NULL && g_netifBuilders[type] != builder) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:type already registed!", __func__); + return SOFTBUS_ERR; + } + g_netifBuilders[type] = builder; + return SOFTBUS_OK; +} + +static LnnNetIfType ConvertToNetIfType(LnnNetIfNameType nameType) +{ + return nameType >= LNN_MAX_NUM_TYPE ? 0 : (0x1 << nameType); +} + +static LnnNetIfMgr *NetifMgrFactory(LnnNetIfNameType type, const char *ifName) +{ + if (type >= LNN_MAX_NUM_TYPE) { + return NULL; + } + if (g_netifBuilders[type] == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "netif type %d not supportted!"); + return NULL; + } + LnnNetIfMgr *netifMgr = g_netifBuilders[type](ifName); + if (netifMgr != NULL) { + netifMgr->type = ConvertToNetIfType(type); + } + return netifMgr; +} + +static int32_t ParseIfNameConfig(char *buf) +{ + char *outerPtr = NULL; + char *innerPtr = NULL; + char *value1 = NULL; + char *value2 = NULL; + char *key = strtok_r(buf, LNN_DELIMITER_OUTSIDE, &outerPtr); + while (key != NULL) { + value1 = strtok_r(key, LNN_DELIMITER_INSIDE, &innerPtr); + value2 = strtok_r(NULL, LNN_DELIMITER_INSIDE, &innerPtr); + + LnnNetIfMgr *netIfMgr = NetifMgrFactory(atoi(value1), value2); + if (netIfMgr != NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "Create netif mgr [%s],[%s]", value1, value2); + ListTailInsert(&g_netIfNameList, &netIfMgr->node); + } else { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Create netif mgr failed!,[%s],[%s]", value1, value2); } - if (g_networkImpl[i].InitNetworkImpl() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init network impl(%d) failed\n", i); + key = strtok_r(NULL, LNN_DELIMITER_OUTSIDE, &outerPtr); + } + return SOFTBUS_OK; +} + +static int32_t SetIfNameDefaultVal(void) +{ + LnnNetIfMgr *netIfMgr = NetifMgrFactory(LNN_ETH_TYPE, LNN_DEFAULT_IF_NAME_ETH); + if (netIfMgr == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add default ETH port failed!"); + return SOFTBUS_ERR; + } + ListTailInsert(&g_netIfNameList, &netIfMgr->node); + + netIfMgr = NetifMgrFactory(LNN_WLAN_TYPE, LNN_DEFAULT_IF_NAME_WLAN); + if (netIfMgr == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add default ETH port failed!"); + return SOFTBUS_ERR; + } + ListTailInsert(&g_netIfNameList, &netIfMgr->node); + return SOFTBUS_OK; +} + +static int32_t LnnInitManagerByConfig(void) +{ + char netIfName[LNN_MAX_IF_NAME_LEN] = {0}; + if (SoftbusGetConfig(SOFTBUS_STR_LNN_NET_IF_NAME, (unsigned char *)netIfName, sizeof(netIfName)) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get lnn net ifName fail, use default value"); + if (SetIfNameDefaultVal() != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "default value set fail"); return SOFTBUS_ERR; } + return SOFTBUS_OK; + } + if (ParseIfNameConfig(netIfName) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ifName str parse fail!"); + return SOFTBUS_ERR; } return SOFTBUS_OK; } -int32_t LnnInitNetworkManagerDelay(void) +int32_t LnnClearNetConfigList(void) { - uint32_t i; + LnnNetIfMgr *item = NULL; + LnnNetIfMgr *next = NULL; - for (i = 0; i < LNN_NETWORK_IMPL_TYPE_MAX; ++i) { - if (g_networkImpl[i].InitNetworkDelayImpl == NULL) { + LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netIfNameList, LnnNetIfMgr, node) + { + ListDelete(&item->node); + SoftBusFree(item); + } + return SOFTBUS_OK; +} + +int32_t LnnRegistProtocol(LnnProtocolManager *protocolMgr) +{ + int32_t ret = SOFTBUS_OK; + + if (protocolMgr == NULL) { + return SOFTBUS_ERR; + } + + for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) { + if (g_networkProtocols[i] != NULL) { continue; } - if (g_networkImpl[i].InitNetworkDelayImpl() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init network delay impl(%d) failed\n", i); - return SOFTBUS_ERR; + if (protocolMgr->Init != NULL) { + ret = protocolMgr->Init(protocolMgr); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init network protocol failed!ret=%d\n", ret); + break; + } + } else { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "network protocol have no init\n"); } + protocolMgr->id = i; + g_networkProtocols[i] = protocolMgr; + break; } - return SOFTBUS_OK; + return ret; } -void LnnDeinitNetworkManager(void) +int32_t UnregistProtocol(LnnProtocolManager *protocolMgr) { - uint32_t i; + uint8_t i; + + if (protocolMgr == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:null ptr!\n", __func__); + return SOFTBUS_ERR; + } + + for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) { + if (g_networkProtocols[i] == protocolMgr) { + g_networkProtocols[i] = NULL; + if (protocolMgr->Deinit != NULL) { + protocolMgr->Deinit(protocolMgr); + } + return SOFTBUS_OK; + } + } + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:no such protocol!\n", __func__); + return SOFTBUS_ERR; +} + +bool LnnVisitNetif(VisitNetifCallback callback, void *data) +{ + LnnNetIfMgr *item = NULL; + VisitNextChoice result = CHOICE_VISIT_NEXT; + LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node) + { + result = callback(item, data); + if (result == CHOICE_FINISH_VISITING) { + return false; + } + } + return true; +} - for (i = 0; i < LNN_NETWORK_IMPL_TYPE_MAX; ++i) { - if (g_networkImpl[i].DeinitNetworkImpl == NULL) { +bool LnnVisitProtocol(VisitProtocolCallback callback, void *data) +{ + VisitNextChoice result = CHOICE_VISIT_NEXT; + for (uint8_t i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; i++) { + if (g_networkProtocols[i] != NULL) { continue; } - if (g_networkImpl[i].DeinitNetworkImpl() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "deinit network impl(%d) failed\n", i); + result = callback(g_networkProtocols[i], data); + if (result == CHOICE_FINISH_VISITING) { + return false; + } + } + return true; +} + +static void OnGroupCreated(const char *groupId) +{ + (void)groupId; + char ifName[NET_IF_NAME_LEN] = {0}; + if (LnnGetLocalStrInfo(STRING_KEY_NET_IF_NAME, ifName, NET_IF_NAME_LEN) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local ifName error!\n"); + return; + } + if (strncmp(ifName, LNN_LOOPBACK_IFNAME, strlen(LNN_LOOPBACK_IFNAME)) == 0) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "ip invalid now, stop group create"); + return; + } + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "open previous discovery again"); + LnnStopDiscovery(); + if (LnnStartDiscovery() != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "start discovery failed\n"); + } + SetCallLnnStatus(true); +} + +static void OnGroupDeleted(const char *groupId) +{ + (void)groupId; +} + +static VerifyCallback g_verifyCb = { + .onGroupCreated = OnGroupCreated, + .onGroupDeleted = OnGroupDeleted, +}; + +int32_t LnnInitNetworkManager(void) +{ + RegistNetIfMgr(LNN_ETH_TYPE, CreateEthNetifMgr); + RegistNetIfMgr(LNN_WLAN_TYPE, CreateEthNetifMgr); + + int32_t ret = LnnInitManagerByConfig(); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Read net config failed!ret=%d\n", ret); + return ret; + } + + // Regist default protocols + ret = RegistIPProtocolManager(); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "regist ip protocol manager failed,ret=%d\n", ret); + return ret; + } + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "IP protocol registed.\n"); + + ret = AuthRegCallback(BUSCENTER_MONITOR, &g_verifyCb); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "register auth callback fail"); + return ret; + } + + ret = LnnInitPhysicalSubnetManager(); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init subnet manager failed!,ret=%d\n", ret); + return ret; + } + + return SOFTBUS_OK; +} + +int32_t LnnInitNetworkManagerDelay(void) +{ + uint32_t i; + + char udid[UDID_BUF_LEN] = {0}; + if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid error!\n"); + return SOFTBUS_ERR; + } + + LnnNetIfMgr *item = NULL; + LIST_FOR_EACH_ENTRY(item, &g_netIfNameList, LnnNetIfMgr, node) + { + for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) { + if (g_networkProtocols[i] == NULL) { + continue; + } + if ((g_networkProtocols[i]->supportedNetif & item->type) != 0) { + int32_t ret = g_networkProtocols[i]->Enable(g_networkProtocols[i], item); + if (ret != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "enable protocol (%d) for netif %s failed\n", i, + item->ifName); + } + SoftBusLog( + SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "enable protocol (%d) for netif %s success\n", i, item->ifName); + } } } + return SOFTBUS_OK; +} + +bool LnnIsAutoNetWorkingEnabled(void) +{ + bool isEnabled = false; + if (SoftbusGetConfig(SOFTBUS_INT_AUTO_NETWORKING_SWITCH, (unsigned char *)&isEnabled, + sizeof(LnnIsAutoNetWorkingEnabled())) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "Cannot get autoNetworkingSwitch from config file"); + return true; + } + return isEnabled; } -void LnnNotifyAllTypeOffline(ConnectionAddrType type) +void LnnDeinitNetworkManager(void) { - (void)type; uint32_t i; - for (i = 0; i < LNN_NETWORK_IMPL_TYPE_MAX; ++i) { - if (g_networkImpl[i].NotifyOfflineMsg == NULL) { + if (LnnClearNetConfigList() != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "deinit network manager failed\n"); + } + + for (i = 0; i < LNN_NETWORK_MAX_PROTOCOL_COUNT; ++i) { + if (g_networkProtocols[i] == NULL || g_networkProtocols[i]->Deinit == NULL) { continue; } - g_networkImpl[i].NotifyOfflineMsg(); + g_networkProtocols[i]->Deinit(g_networkProtocols[i]); + g_networkProtocols[i] = NULL; + } + + LnnDeinitPhysicalSubnetManager(); +} + +int32_t LnnGetNetIfTypeByName(const char *ifName, LnnNetIfType *type) +{ + if (ifName == NULL || type == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters are NULL!"); + return SOFTBUS_ERR; + } + LnnNetIfMgr *netif = NULL; + LIST_FOR_EACH_ENTRY(netif, &g_netIfNameList, LnnNetIfMgr, node) + { + if (strncmp(ifName, netif->ifName, sizeof(netif->ifName)) == 0) { + *type = netif->type; + return SOFTBUS_OK; + } + } + return SOFTBUS_ERR; +} +int32_t LnnGetAddrTypeByIfName(const char *ifName, ConnectionAddrType *type) +{ + if (type == NULL || ifName == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters are NULL!"); + return SOFTBUS_ERR; + } + LnnNetIfType netifType; + int32_t ret = LnnGetNetIfTypeByName(ifName, &netifType); + if (ret != SOFTBUS_OK) { + return ret; } -} \ No newline at end of file + switch (netifType) { + case LNN_NETIF_TYPE_ETH: + *type = CONNECTION_ADDR_ETH; + break; + case LNN_NETIF_TYPE_WLAN: + *type = CONNECTION_ADDR_WLAN; + break; + default: + ret = SOFTBUS_ERR; + } + return ret; +} diff --git a/core/bus_center/lnn/net_buscenter/src/lnn_physical_subnet_manager.c b/core/bus_center/lnn/net_buscenter/src/lnn_physical_subnet_manager.c new file mode 100644 index 0000000000000000000000000000000000000000..0064e39d7161ebc10eb994a0e93616d2c5a37706 --- /dev/null +++ b/core/bus_center/lnn/net_buscenter/src/lnn_physical_subnet_manager.c @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "lnn_physical_subnet_manager.h" + +#include +#include + +#include "lnn_network_manager.h" +#include "softbus_adapter_thread.h" +#include "softbus_errcode.h" +#include "softbus_log.h" + +#define MAX_SUPPORTED_PHYSICAL_SUBNET 4 + +static SoftBusMutex g_physicalSubnetsLock; +static LnnPhysicalSubnet *g_physicalSubnets[MAX_SUPPORTED_PHYSICAL_SUBNET]; + +#define CALL_WITH_LOCK(RET, LOCK, ACTION) \ + do { \ + ret = SoftBusMutexLock(LOCK); \ + if (ret != SOFTBUS_OK) { \ + HILOG_ERROR(SOFTBUS_HILOG_ID, "%s:lock mutex failed", __func__); \ + break; \ + } \ + (RET) = (ACTION); \ + SoftBusMutexUnlock(LOCK); \ + } while (false) + +#define CALL_VOID_FUNC_WITH_LOCK(LOCK, ACTION) \ + do { \ + if (SoftBusMutexLock(LOCK) != 0) { \ + HILOG_ERROR(SOFTBUS_HILOG_ID, "%s:lock mutex failed", __func__); \ + break; \ + } \ + (ACTION); \ + SoftBusMutexUnlock(LOCK); \ + } while (false) + +int32_t LnnInitPhysicalSubnetManager(void) +{ + return SoftBusMutexInit(&g_physicalSubnetsLock, NULL); +} + +static void ClearSubnetManager(void) +{ + for (uint8_t i = 0; i < MAX_SUPPORTED_PHYSICAL_SUBNET; i++) { + if (g_physicalSubnets[i] != NULL) { + if (g_physicalSubnets[i]->Destroy != NULL) { + g_physicalSubnets[i]->Destroy(g_physicalSubnets[i]); + } + g_physicalSubnets[i] = NULL; + } + } +} + +void LnnDeinitPhysicalSubnetManager(void) +{ + CALL_VOID_FUNC_WITH_LOCK(&g_physicalSubnetsLock, ClearSubnetManager()); + if (SoftBusMutexDestroy(&g_physicalSubnetsLock) != SOFTBUS_OK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s: destroy mutex failed!", __func__); + } +} + +static int32_t DoRegistSubnet(LnnPhysicalSubnet *subnet) +{ + for (uint8_t i = 0; i < MAX_SUPPORTED_PHYSICAL_SUBNET; i++) { + if (g_physicalSubnets[i] == NULL) { + g_physicalSubnets[i] = subnet; + g_physicalSubnets[i]->OnNetifStatusChanged(g_physicalSubnets[i]); + return SOFTBUS_OK; + } + } + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s: subnet list is full", __func__); + return SOFTBUS_ERR; +} + +int32_t LnnRegistPhysicalSubnet(LnnPhysicalSubnet *subnet) +{ + int32_t ret = SOFTBUS_OK; + CALL_WITH_LOCK(ret, &g_physicalSubnetsLock, DoRegistSubnet(subnet)); + return ret; +} + +static int32_t DoUnregistSubnetByType(ProtocolType type) +{ + for (uint8_t i = 0; i < MAX_SUPPORTED_PHYSICAL_SUBNET; i++) { + if (g_physicalSubnets[i] != NULL && g_physicalSubnets[i]->protocolType == type) { + if (g_physicalSubnets[i]->Destroy != NULL) { + g_physicalSubnets[i]->Destroy(g_physicalSubnets[i]); + } + g_physicalSubnets[i] = NULL; + } + } + return SOFTBUS_OK; +} + +int32_t LnnUnregistPhysicalSubnetByType(ProtocolType type) +{ + int32_t ret = SOFTBUS_OK; + CALL_WITH_LOCK(ret, &g_physicalSubnetsLock, DoUnregistSubnetByType(type)); + return ret; +} + +void DoNotifyAddressChange(const char *ifName, ProtocolType protocolType) +{ + for (uint16_t i = 0; i < MAX_SUPPORTED_PHYSICAL_SUBNET; i++) { + if (g_physicalSubnets[i] == NULL || g_physicalSubnets[i]->protocolType != protocolType) { + continue; + } + + if (strcmp(g_physicalSubnets[i]->ifName, ifName) != 0) { + continue; + } + + if (g_physicalSubnets[i]->OnNetifStatusChanged != NULL) { + g_physicalSubnets[i]->OnNetifStatusChanged(g_physicalSubnets[i]); + } + } +} + +void LnnNotifyPhysicalSubnetAddressChanged(const char *ifName, ProtocolType protocolType) +{ + CALL_VOID_FUNC_WITH_LOCK(&g_physicalSubnetsLock, DoNotifyAddressChange(ifName, protocolType)); +} + +static void EnableResetingSubnetByType(ProtocolType protocolType) +{ + for (uint16_t i = 0; i < MAX_SUPPORTED_PHYSICAL_SUBNET; i++) { + if (g_physicalSubnets[i] == NULL || g_physicalSubnets[i]->protocolType != protocolType) { + continue; + } + if (g_physicalSubnets[i]->OnSoftbusNetworkDisconnected != NULL) { + g_physicalSubnets[i]->OnSoftbusNetworkDisconnected(g_physicalSubnets[i]); + } + } +} + +void LnnNotifyAllTypeOffline(ConnectionAddrType type) +{ + if (type == CONNECTION_ADDR_ETH || type == CONNECTION_ADDR_WLAN || type == CONNECTION_ADDR_MAX) { + CALL_VOID_FUNC_WITH_LOCK(&g_physicalSubnetsLock, EnableResetingSubnetByType(LNN_PROTOCOL_IP)); + } +} + +static bool DoVisitSubnet(LnnVisitPhysicalSubnetCallback callback, void *data) +{ + VisitNextChoice result = CHOICE_VISIT_NEXT; + for (uint16_t i = 0; i < MAX_SUPPORTED_PHYSICAL_SUBNET; i++) { + if (g_physicalSubnets[i] == NULL) { + continue; + } + result = callback(g_physicalSubnets[i], data); + if (result == CHOICE_FINISH_VISITING) { + return false; + } + } + return true; +} + +bool LnnVisitPhysicalSubnet(LnnVisitPhysicalSubnetCallback callback, void *data) +{ + bool ret = false; + CALL_WITH_LOCK(ret, &g_physicalSubnetsLock, DoVisitSubnet(callback, data)); + return ret; +} diff --git a/core/bus_center/lnn/net_ledger/common/include/lnn_node_info.h b/core/bus_center/lnn/net_ledger/common/include/lnn_node_info.h index 1cda023f9251730b329cef70dedc3daae137d439..8c5f9abf104802dc4680e8f1d5e74949b98fd26f 100755 --- a/core/bus_center/lnn/net_ledger/common/include/lnn_node_info.h +++ b/core/bus_center/lnn/net_ledger/common/include/lnn_node_info.h @@ -84,6 +84,7 @@ typedef struct { BssTransInfo bssTransInfo; bool isBleP2p; // true: this device support connect p2p via ble connection P2pInfo p2pInfo; + uint64_t supportedProtocols; } NodeInfo; const char *LnnGetDeviceUdid(const NodeInfo *info); @@ -112,6 +113,8 @@ int32_t LnnSetP2pMac(NodeInfo *info, const char *p2pMac); const char *LnnGetP2pMac(const NodeInfo *info); int32_t LnnSetP2pGoMac(NodeInfo *info, const char *goMac); const char *LnnGetP2pGoMac(const NodeInfo *info); +uint64_t LnnGetSupportedProtocols(NodeInfo *info); +int32_t LnnSetSupportedProtocols(NodeInfo *info, uint64_t protocols); #ifdef __cplusplus } diff --git a/core/bus_center/lnn/net_ledger/common/src/lnn_node_info.c b/core/bus_center/lnn/net_ledger/common/src/lnn_node_info.c index 6b35792bd94dd49cdad164952c064ab407be19e5..2e46c51eb2c4767bf22af311e0feb43186fd8905 100644 --- a/core/bus_center/lnn/net_ledger/common/src/lnn_node_info.c +++ b/core/bus_center/lnn/net_ledger/common/src/lnn_node_info.c @@ -287,3 +287,22 @@ const char *LnnGetP2pGoMac(const NodeInfo *info) } return info->p2pInfo.goMac; } + +uint64_t LnnGetSupportedProtocols(NodeInfo *info) +{ + if (info == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid param."); + return 0; + } + return info->supportedProtocols; +} + +int32_t LnnSetSupportedProtocols(NodeInfo *info, uint64_t protocols) +{ + if (info == NULL) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!"); + return SOFTBUS_OK; + } + info->supportedProtocols = protocols; + return SOFTBUS_OK; +} diff --git a/core/bus_center/lnn/net_ledger/local_ledger/src/lnn_local_net_ledger.c b/core/bus_center/lnn/net_ledger/local_ledger/src/lnn_local_net_ledger.c index c39e20e37190b589e71cbbde527ee22971952b70..40a3e2f121697490e8d21729a73aed23dabe6958 100644 --- a/core/bus_center/lnn/net_ledger/local_ledger/src/lnn_local_net_ledger.c +++ b/core/bus_center/lnn/net_ledger/local_ledger/src/lnn_local_net_ledger.c @@ -68,7 +68,7 @@ static int32_t LlGetDeviceUdid(void *buf, uint32_t len) return SOFTBUS_ERR; } if (strlen(udid) <= 0) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid invaild!\n"); + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local udid invalid!\n"); return SOFTBUS_ERR; } if (strncpy_s(buf, len, udid, strlen(udid)) != EOK) { @@ -586,6 +586,20 @@ static int32_t UpdateP2pRole(const void *p2pRole) return LnnSetP2pRole(&g_localNetLedger.localInfo, *(int32_t *)p2pRole); } +static int32_t LlUpdateSupportedProtocols(const void *transProtos) +{ + return LnnSetSupportedProtocols(&g_localNetLedger.localInfo, *((uint64_t*)transProtos)); +} + +static int32_t LlGetSupportedProtocols(void *buf, uint32_t len) +{ + if (buf == NULL || len != sizeof(uint64_t)) { + return SOFTBUS_INVALID_PARAM; + } + *((uint64_t *)buf) = LnnGetSupportedProtocols(&g_localNetLedger.localInfo); + return SOFTBUS_OK; +} + static LocalLedgerKey g_localKeyTable[] = { {STRING_KEY_HICE_VERSION, VERSION_MAX_LEN, LlGetNodeSoftBusVersion, NULL}, {STRING_KEY_DEV_UDID, UDID_BUF_LEN, LlGetDeviceUdid, UpdateLocalDeviceUdid}, @@ -606,6 +620,7 @@ static LocalLedgerKey g_localKeyTable[] = { {NUM_KEY_DEV_TYPE_ID, -1, LlGetDeviceTypeId, NULL}, {NUM_KEY_MASTER_NODE_WEIGHT, -1, L1GetMasterNodeWeight, UpdateMasgerNodeWeight}, {NUM_KEY_P2P_ROLE, -1, L1GetP2pRole, UpdateP2pRole}, + {NUM_KEY_TRANS_PROTOCOLS, sizeof(int64_t), LlGetSupportedProtocols, LlUpdateSupportedProtocols} }; int32_t LnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len) @@ -638,7 +653,7 @@ int32_t LnnGetLocalStrInfo(InfoKey key, char *info, uint32_t len) return SOFTBUS_ERR; } -int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info) +static int32_t LnnGetLocalInfo(InfoKey key, void* info, uint32_t infoSize) { uint32_t i; int32_t ret; @@ -657,7 +672,7 @@ int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info) for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) { if (key == g_localKeyTable[i].key) { if (g_localKeyTable[i].getInfo != NULL) { - ret = g_localKeyTable[i].getInfo((void *)info, NUM_BUF_SIZE); + ret = g_localKeyTable[i].getInfo(info, infoSize); SoftBusMutexUnlock(&g_localNetLedger.lock); return ret; } @@ -706,7 +721,7 @@ int32_t LnnSetLocalStrInfo(InfoKey key, const char *info) return SOFTBUS_ERR; } -int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info) +static int32_t LnnSetLocalInfo(InfoKey key, void* info) { uint32_t i; int32_t ret; @@ -721,7 +736,7 @@ int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info) for (i = 0; i < sizeof(g_localKeyTable) / sizeof(LocalLedgerKey); i++) { if (key == g_localKeyTable[i].key) { if (g_localKeyTable[i].setInfo != NULL) { - ret = g_localKeyTable[i].setInfo((void *)&info); + ret = g_localKeyTable[i].setInfo(info); SoftBusMutexUnlock(&g_localNetLedger.lock); return ret; } @@ -735,6 +750,26 @@ int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info) return SOFTBUS_ERR; } +int32_t LnnGetLocalNumInfo(InfoKey key, int32_t *info) +{ + return LnnGetLocalInfo(key, (void*)info, sizeof(int32_t)); +} + +int32_t LnnGetLocalNum64Info(InfoKey key, int64_t *info) +{ + return LnnGetLocalInfo(key, (void*)info, sizeof(int64_t)); +} + +int32_t LnnSetLocalNum64Info(InfoKey key, int64_t info) +{ + return LnnSetLocalInfo(key, (void*)&info); +} + +int32_t LnnSetLocalNumInfo(InfoKey key, int32_t info) +{ + return LnnSetLocalInfo(key, (void*)&info); +} + int32_t LnnGetLocalDeviceInfo(NodeBasicInfo *info) { int32_t rc; @@ -825,3 +860,17 @@ void LnnDeinitLocalLedger(void) } g_localNetLedger.status = LL_INIT_UNKNOWN; } + +bool LnnIsMasterNode(void) +{ + bool ret = false; + if (SoftBusMutexLock(&g_localNetLedger.lock) != 0) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock mutex fail!"); + return ret; + } + const char* masterUdid = g_localNetLedger.localInfo.masterUdid; + const char* deviceUdid = g_localNetLedger.localInfo.deviceInfo.deviceUdid; + ret = strncmp(masterUdid, deviceUdid, strlen(deviceUdid)) == 0; + SoftBusMutexUnlock(&g_localNetLedger.lock); + return ret; +} diff --git a/core/bus_center/monitor/src/lnn_event_monitor.c b/core/bus_center/monitor/src/lnn_event_monitor.c index 91e9db7ec539efc38c46b49f0dd446708668b99f..b79211cf95c5e09f7af5f390b501d0fffae0685d 100644 --- a/core/bus_center/monitor/src/lnn_event_monitor.c +++ b/core/bus_center/monitor/src/lnn_event_monitor.c @@ -16,11 +16,13 @@ #include "lnn_event_monitor.h" #include +#include #include "bus_center_event.h" #include "lnn_event_monitor_impl.h" #include "softbus_errcode.h" #include "softbus_log.h" +#include "softbus_adapter_mem.h" typedef enum { MONITOR_IMPL_NETLINK_TYPE = 0, @@ -39,28 +41,13 @@ static LnnInitEventMonitorImpl g_monitorImplInit[MONITOR_IMPL_MAX_TYPE] = { LnnInitDriverMonitorImpl, }; -static void EventMonitorHandler(LnnMonitorEventType event, const LnnMoniterData *para) -{ - LnnMonitorEventInfo info; - - if (event == LNN_MONITOR_EVENT_TYPE_MAX) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid event"); - return; - } - info.basic.event = (LnnEventType)event; - info.data = para; - LnnNotifyMonitorEvent(&info); -} - int32_t LnnInitEventMonitor(void) { - uint32_t i; - - for (i = 0; i < MONITOR_IMPL_MAX_TYPE; ++i) { + for (uint32_t i = 0; i < MONITOR_IMPL_MAX_TYPE; ++i) { if (g_monitorImplInit[i] == NULL) { continue; } - if (g_monitorImplInit[i](EventMonitorHandler) != SOFTBUS_OK) { + if (g_monitorImplInit[i]() != SOFTBUS_OK) { SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "init event monitor impl(%u) failed", i); return SOFTBUS_ERR; } diff --git a/core/bus_center/service/include/bus_center_event.h b/core/bus_center/service/include/bus_center_event.h index 71d578ec863694bf36912ee18e1266731d274237..b0b3bb4fac8de8f8d1ecba2c2a59014789195561 100644 --- a/core/bus_center/service/include/bus_center_event.h +++ b/core/bus_center/service/include/bus_center_event.h @@ -19,8 +19,8 @@ #include #include -#include "lnn_event_monitor_impl.h" #include "softbus_bus_center.h" +#include "bus_center_info_key.h" #ifdef __cplusplus extern "C" { @@ -34,6 +34,7 @@ typedef enum { /* event from internal lnn */ LNN_EVENT_NODE_ONLINE_STATE_CHANGED, LNN_EVENT_RELATION_CHANGED, + LNN_EVENT_NODE_MASTER_STATE_CHANGED, LNN_EVENT_TYPE_MAX, } LnnEventType; @@ -43,8 +44,20 @@ typedef struct { typedef struct { LnnEventBasicInfo basic; - const LnnMoniterData *data; -} LnnMonitorEventInfo; + char ifName[NET_IF_NAME_LEN]; +} LnnMonitorAddressChangedEvent; + +typedef enum { + SOFTBUS_WIFI_CONNECTED, + SOFTBUS_WIFI_DISCONNECTED, + SOFTBUS_WIFI_DISABLED, + SOFTBUS_UNKNOWN, +} SoftBusWifiState; + +typedef struct { + LnnEventBasicInfo basic; + uint8_t status; +} LnnMonitorWlanStateChangedEvent; typedef struct { LnnEventBasicInfo basic; @@ -60,6 +73,13 @@ typedef struct { const char *udid; } LnnRelationChanedEventInfo; +typedef struct { + LnnEventBasicInfo basic; + const char* masterNodeUDID; + int32_t weight; + bool isMasterNode; +} LnnMasterNodeChangedEvent; + typedef void (*LnnEventHandler)(const LnnEventBasicInfo *info); int32_t LnnInitBusCenterEvent(void); @@ -74,11 +94,15 @@ void LnnNotifyLeaveResult(const char *networkId, int32_t retCode); void LnnNotifyOnlineState(bool isOnline, NodeBasicInfo *info); void LnnNotifyBasicInfoChanged(NodeBasicInfo *info, NodeBasicInfoType type); -void LnnNotifyMonitorEvent(const LnnMonitorEventInfo *info); + +void LnnNotifyWlanStateChangeEvent(SoftBusWifiState state); +void LnnNotifyAddressChangedEvent(const char* ifName); void LnnNotifyLnnRelationChanged(const char *udid, ConnectionAddrType type, uint8_t relation, bool isJoin); void LnnNotifyTimeSyncResult(const char *pkgName, const TimeSyncResultInfo *info, int32_t retCode); +void LnnNotifyMasterNodeChanged(bool isMaster, const char* masterNodeUdid, int32_t weight); + #ifdef __cplusplus } #endif diff --git a/core/bus_center/service/src/bus_center_event.c b/core/bus_center/service/src/bus_center_event.c index 7619025233b6721379f7d72a280d7aff5072bc96..d36619e095e5e85f7f2a65b20f91cb7e86b33126 100644 --- a/core/bus_center/service/src/bus_center_event.c +++ b/core/bus_center/service/src/bus_center_event.c @@ -15,11 +15,11 @@ #include "bus_center_event.h" -#include #include +#include -#include "message_handler.h" #include "lnn_bus_center_ipc.h" +#include "message_handler.h" #include "softbus_adapter_mem.h" #include "softbus_adapter_thread.h" #include "softbus_errcode.h" @@ -42,7 +42,7 @@ typedef enum { } NotifyType; static BusCenterEventCtrl g_eventCtrl; -static SoftBusHandler g_notifyHandler = { "NotifyHandler", NULL, NULL }; +static SoftBusHandler g_notifyHandler = {"NotifyHandler", NULL, NULL}; static int32_t PostMessageToHandler(SoftBusMessage *msg) { @@ -153,7 +153,8 @@ static bool IsRepeatEventHandler(LnnEventType event, LnnEventHandler handler) { LnnEventHandlerItem *item = NULL; - LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[event], LnnEventHandlerItem, node) { + LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[event], LnnEventHandlerItem, node) + { if (item->handler == handler) { return true; } @@ -181,7 +182,8 @@ static void NotifyEvent(const LnnEventBasicInfo *info) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "lock failed in notify event"); return; } - LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[info->event], LnnEventHandlerItem, node) { + LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[info->event], LnnEventHandlerItem, node) + { item->handler(info); } (void)SoftBusMutexUnlock(&g_eventCtrl.lock); @@ -259,13 +261,37 @@ void LnnNotifyTimeSyncResult(const char *pkgName, const TimeSyncResultInfo *info LnnIpcNotifyTimeSyncResult(pkgName, info, sizeof(TimeSyncResultInfo), retCode); } -void LnnNotifyMonitorEvent(const LnnMonitorEventInfo *info) +void LnnNotifyWlanStateChangeEvent(SoftBusWifiState state) { - if (info == NULL || info->basic.event == LNN_EVENT_TYPE_MAX) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid monitr event paramter"); + if (state < SOFTBUS_WIFI_CONNECTED || state > SOFTBUS_UNKNOWN) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "bad state %d", state); return; } - NotifyEvent((const LnnEventBasicInfo *)info); + LnnMonitorWlanStateChangedEvent event = {.basic.event = LNN_EVENT_WIFI_STATE_CHANGED, .status = state}; + NotifyEvent((const LnnEventBasicInfo *)&event); +} + +void LnnNotifyAddressChangedEvent(const char *ifName) +{ + LnnMonitorAddressChangedEvent event = {.basic.event = LNN_EVENT_IP_ADDR_CHANGED, .ifName = {0}}; + if (ifName != NULL) { + int32_t ret = strcpy_s(event.ifName, sizeof(event.ifName), ifName); + if (ret != EOK) { + SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy ifName failed!ret=%d", ret); + return; + } + } + NotifyEvent((const LnnEventBasicInfo *)&event); +} + +void LnnNotifyMasterNodeChanged(bool isMaster, const char *masterNodeUdid, int32_t weight) +{ + LnnMasterNodeChangedEvent event = {.basic.event = LNN_EVENT_NODE_MASTER_STATE_CHANGED, + .isMasterNode = isMaster, + .masterNodeUDID = masterNodeUdid, + .weight = weight}; + + NotifyEvent((const LnnEventBasicInfo *)&event); } int32_t LnnInitBusCenterEvent(void) @@ -336,7 +362,8 @@ void LnnUnregisterEventHandler(LnnEventType event, LnnEventHandler handler) SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "hold lock failed in unregister event handler"); return; } - LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[event], LnnEventHandlerItem, node) { + LIST_FOR_EACH_ENTRY(item, &g_eventCtrl.handlers[event], LnnEventHandlerItem, node) + { if (item->handler == handler) { ListDelete(&item->node); SoftBusFree(item); diff --git a/core/bus_center/utils/bus_center_utils.gni b/core/bus_center/utils/bus_center_utils.gni index 8eeb48467a6716df934be7aee4ce94a577b44e59..a5a55a90cfe75c2e069272471a289dcfc411ef5e 100644 --- a/core/bus_center/utils/bus_center_utils.gni +++ b/core/bus_center/utils/bus_center_utils.gni @@ -22,10 +22,8 @@ bus_center_utils_src = [ "$dsoftbus_root_path/core/bus_center/utils/src/lnn_ipc_utils.c", ] if (dsoftbus_standard_feature_lnn_net) { - bus_center_utils_src += [ - "$core_bus_center_utils_path/src/lnn_ip_utils.c", - "$core_bus_center_utils_path/src/lnn_state_machine.c", - ] + bus_center_utils_src += + [ "$core_bus_center_utils_path/src/lnn_state_machine.c" ] } if (dsoftbus_standard_feature_lnn_net || dsoftbus_standard_feature_lnn_meta_node) { diff --git a/core/bus_center/utils/src/lnn_ip_utils.c b/core/bus_center/utils/src/lnn_ip_utils.c deleted file mode 100644 index ae5240ec82a1ddf75db090819de416dc2584a900..0000000000000000000000000000000000000000 --- a/core/bus_center/utils/src/lnn_ip_utils.c +++ /dev/null @@ -1,185 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "lnn_ip_utils.h" -#include "lnn_ip_utils_adapter.h" - -#ifndef _GNU_SOURCE -#define _GNU_SOURCE -#endif - -#include -#include -#include -#include -#include - -#include "bus_center_info_key.h" -#include "common_list.h" -#include "lnn_linkwatch.h" -#include "softbus_adapter_mem.h" -#include "softbus_def.h" -#include "softbus_errcode.h" -#include "softbus_feature_config.h" -#include "softbus_log.h" - -#define LNN_MAX_IF_NAME_LEN 256 -#define LNN_DELIMITER_OUTSIDE "," -#define LNN_DELIMITER_INSIDE ":" - -typedef struct { - ListNode node; - LnnNetIfNameType type; - char ifName[NET_IF_NAME_LEN]; -} LnnNetIfNameConfig; - -static ListNode g_netIfNameList = { - .prev = &g_netIfNameList, - .next = &g_netIfNameList, -}; - -static int32_t AddNetConfigInfo(LnnNetIfNameType type, const char *netIfName, uint32_t netIfNameLen) -{ - if (netIfName == NULL || type < LNN_ETH_TYPE || type >= LNN_MAX_NUM_TYPE) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters invaild!"); - return SOFTBUS_ERR; - } - LnnNetIfNameConfig *info = (LnnNetIfNameConfig *)SoftBusMalloc(sizeof(LnnNetIfNameConfig)); - if (info == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "fail: malloc LnnNetIfNameConfig"); - return SOFTBUS_MALLOC_ERR; - } - ListInit(&info->node); - if (strncpy_s(info->ifName, NET_IF_NAME_LEN, netIfName, netIfNameLen) != EOK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy netIfName fail"); - SoftBusFree(info); - return SOFTBUS_ERR; - } - info->type = type; - ListTailInsert(&g_netIfNameList, &info->node); - return SOFTBUS_OK; -} - -static int32_t ParseIfNameConfig(char *buf) -{ - char *outerPtr = NULL; - char *innerPtr = NULL; - char *value1 = NULL; - char *value2 = NULL; - char *key = strtok_r(buf, LNN_DELIMITER_OUTSIDE, &outerPtr); - while (key != NULL) { - value1 = strtok_r(key, LNN_DELIMITER_INSIDE, &innerPtr); - value2 = strtok_r(NULL, LNN_DELIMITER_INSIDE, &innerPtr); - if (AddNetConfigInfo((uint32_t)atoi(value1), value2, strlen(value2)) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AddNetConfigInfo fail"); - return SOFTBUS_ERR; - } - key = strtok_r(NULL, LNN_DELIMITER_OUTSIDE, &outerPtr); - } - return SOFTBUS_OK; -} - -static int32_t SetIfNameDefaultVal(void) -{ - if (AddNetConfigInfo(LNN_ETH_TYPE, LNN_IF_NAME_ETH, strlen(LNN_IF_NAME_ETH)) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AddNetConfigInfo fail"); - return SOFTBUS_ERR; - } - if (AddNetConfigInfo(LNN_WLAN_TYPE, LNN_IF_NAME_WLAN, strlen(LNN_IF_NAME_WLAN)) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "AddNetConfigInfo fail"); - return SOFTBUS_ERR; - } - return SOFTBUS_OK; -} - -int32_t LnnReadNetConfigList(void) -{ - char netIfName[LNN_MAX_IF_NAME_LEN] = {0}; - if (SoftbusGetConfig(SOFTBUS_STR_LNN_NET_IF_NAME, - (unsigned char*)netIfName, sizeof(netIfName)) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get lnn net ifname fail, use default value"); - if (SetIfNameDefaultVal() != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "default value set fail"); - return SOFTBUS_ERR; - } - return SOFTBUS_OK; - } - if (ParseIfNameConfig(netIfName) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ifname str parse fail!"); - return SOFTBUS_ERR; - } - return SOFTBUS_OK; -} - -int32_t LnnClearNetConfigList(void) -{ - LnnNetIfNameConfig *item = NULL; - LnnNetIfNameConfig *next = NULL; - - LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_netIfNameList, LnnNetIfNameConfig, node) { - ListDelete(&item->node); - SoftBusFree(item); - } - return SOFTBUS_OK; -} - -int32_t LnnGetAddrTypeByIfName(const char *ifName, uint32_t ifNameLen, ConnectionAddrType *type) -{ - if (ifName == NULL || type == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "parameters are NULL!"); - return SOFTBUS_ERR; - } - LnnNetIfNameConfig *info = NULL; - LIST_FOR_EACH_ENTRY(info, &g_netIfNameList, LnnNetIfNameConfig, node) { - if (strncmp(ifName, info->ifName, ifNameLen) == 0) { - if (info->type == LNN_ETH_TYPE) { - *type = CONNECTION_ADDR_ETH; - } - if (info->type == LNN_WLAN_TYPE) { - *type = CONNECTION_ADDR_WLAN; - } - break; - } - } - return SOFTBUS_OK; -} - -int32_t LnnGetLocalIp(char *ip, uint32_t len, char *ifName, uint32_t ifNameLen) -{ - if (ip == NULL || ifName == NULL) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "ip or ifName buffer is NULL"); - return SOFTBUS_INVALID_PARAM; - } - LnnNetIfNameConfig *info = NULL; - int32_t ret = SOFTBUS_ERR; - LIST_FOR_EACH_ENTRY(info, &g_netIfNameList, LnnNetIfNameConfig, node) { - if (GetNetworkIpByIfName(info->ifName, ip, NULL, len) != SOFTBUS_OK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get network IP by ifName failed!"); - continue; - } - if (!LnnIsLinkReady(info->ifName, strlen(info->ifName))) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "GetNetworkIfIp ifName:%s link not ready", info->ifName); - continue; - } - if (strncpy_s(ifName, ifNameLen, info->ifName, strlen(info->ifName)) != EOK) { - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy ifname failed!"); - continue; - } - SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "GetNetworkIfIp ifName:%s ok!", info->ifName); - ret = SOFTBUS_OK; - break; - } - return ret; -}