connection/manager/softbus_conn_manager.c

/*
 * 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 "softbus_conn_manager.h"

#include <securec.h>

#include "common_list.h"
#include "softbus_adapter_mem.h"
#include "softbus_adapter_thread.h"
#include "softbus_base_listener.h"
#include "softbus_conn_ble_manager.h"
#include "softbus_conn_br_manager.h"
#include "softbus_conn_interface.h"
#include "softbus_datahead_transform.h"
#include "softbus_def.h"
#include "softbus_errcode.h"
#include "softbus_feature_config.h"
#include "softbus_hisysevt_connreporter.h"
#include "softbus_log.h"
#include "softbus_socket.h"
#include "softbus_tcp_connect_manager.h"
#include "softbus_utils.h"

ConnectFuncInterface *g_connManager[CONNECT_TYPE_MAX] = { 0 };
static SoftBusList *g_listenerList = NULL;
static bool g_isInited = false;
static SoftBusList *g_connTimeList = NULL;
#define SEC_TIME 1000LL

typedef struct TagConnListenerNode {
    ListNode node;
    ConnModule moduleId;
    ConnectCallback callback;
} ConnListenerNode;

typedef struct TagConnTimeNode {
    ListNode node;
    ConnectionInfo info;
    uint32_t startTime;
} ConnTimeNode;

static int32_t AddConnTimeNode(const ConnectionInfo *info, ConnTimeNode *timeNode)
{
    if (g_connTimeList == NULL) {
        CLOGE("g_connTimeList is null");
        return SOFTBUS_ERR;
    }
    SoftBusSysTime now = { 0 };
    SoftBusGetTime(&now);
    timeNode->startTime = (uint32_t)now.sec * SEC_TIME + (uint32_t)now.usec / SEC_TIME;
    if (memcpy_s(&(timeNode->info), sizeof(ConnectionInfo), info, sizeof(ConnectionInfo)) != EOK) {
        CLOGE("AddConnTimeNode:memcpy timenode failed");
        return SOFTBUS_ERR;
    }
    if (SoftBusMutexLock(&g_connTimeList->lock) != 0) {
        CLOGE("AddConnTimeNode:lock mutex failed");
        return SOFTBUS_ERR;
    }
    ListAdd(&(g_connTimeList->list), &(timeNode->node));
    (void)SoftBusMutexUnlock(&g_connTimeList->lock);
    return SOFTBUS_OK;
}

static int32_t CompareConnectInfo(const ConnectionInfo *src, const ConnectionInfo *dst)
{
    if (src->type != dst->type) {
        return SOFTBUS_ERR;
    }
    switch (src->type) {
        case CONNECT_BLE:
            if (strcasecmp(src->bleInfo.bleMac, dst->bleInfo.bleMac) != 0) {
                return SOFTBUS_ERR;
            }
            break;
        case CONNECT_BR:
            if (strcasecmp(src->brInfo.brMac, dst->brInfo.brMac) != 0) {
                return SOFTBUS_ERR;
            }
            break;
        case CONNECT_TCP:
            if (strcasecmp(src->socketInfo.addr, dst->socketInfo.addr) != 0) {
                return SOFTBUS_ERR;
            }
            break;
        default:
            return SOFTBUS_ERR;
    }
    return SOFTBUS_OK;
}

static ConnTimeNode *GetConnTimeNode(const ConnectionInfo *info)
{
    ConnTimeNode *listNode = NULL;
    if (SoftBusMutexLock(&g_connTimeList->lock) != 0) {
        CLOGE("GetConnTimeNode lock mutex failed");
        return NULL;
    }
    LIST_FOR_EACH_ENTRY(listNode, &g_connTimeList->list, ConnTimeNode, node) {
        if (listNode != NULL) {
            if (CompareConnectInfo(&listNode->info, info) == SOFTBUS_OK) {
                CLOGD("find connect info success, ConnectType=%d", listNode->info.type);
                (void)SoftBusMutexUnlock(&g_connTimeList->lock);
                return listNode;
            }
        }
    }
    (void)SoftBusMutexUnlock(&g_connTimeList->lock);
    return NULL;
}

static void FreeConnTimeNode(ConnTimeNode *timeNode)
{
    ConnTimeNode *removeNode = NULL;
    ConnTimeNode *next = NULL;
    if (g_connTimeList == NULL) {
        CLOGE("connTimeList is null");
        return;
    }

    if (SoftBusMutexLock(&g_connTimeList->lock) != 0) {
        CLOGE("lock mutex failed");
        return;
    }

    LIST_FOR_EACH_ENTRY_SAFE(removeNode, next, &g_connTimeList->list, ConnTimeNode, node) {
        if (removeNode->info.type == timeNode->info.type) {
            if (CompareConnectInfo(&removeNode->info, &timeNode->info) == SOFTBUS_OK) {
                CLOGD("find connect info success, ConnectType=%d", removeNode->info.type);
                ListDelete(&(removeNode->node));
                break;
            }
        }
    }
    (void)SoftBusMutexUnlock(&g_connTimeList->lock);
    SoftBusFree(removeNode);
    return;
}

static int32_t ModuleCheck(ConnModule moduleId)
{
    ConnModule id[] = { MODULE_TRUST_ENGINE, MODULE_HICHAIN, MODULE_AUTH_SDK, MODULE_AUTH_CONNECTION,
        MODULE_MESSAGE_SERVICE, MODULE_AUTH_CHANNEL, MODULE_AUTH_MSG, MODULE_BLUETOOTH_MANAGER, MODULE_CONNECTION,
        MODULE_DIRECT_CHANNEL, MODULE_PROXY_CHANNEL, MODULE_DEVICE_AUTH, MODULE_P2P_LINK, MODULE_UDP_INFO,
        MODULE_PKG_VERIFY, MODULE_META_AUTH, MODULE_BLE_NET, MODULE_BLE_CONN };
    int32_t i;
    int32_t idNum = sizeof(id) / sizeof(ConnModule);

    for (i = 0; i < idNum; i++) {
        if (moduleId == id[i]) {
            return SOFTBUS_OK;
        }
    }
    CLOGE("check module fail %d", moduleId);
    return SOFTBUS_ERR;
}

static int32_t ConnTypeCheck(ConnectType type)
{
    if (type >= CONNECT_TYPE_MAX) {
        CLOGE("type is over max %d", type);
        return SOFTBUS_CONN_INVALID_CONN_TYPE;
    }

    if (g_connManager[type] == NULL) {
        CLOGE("type is %d", type);
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }
    return SOFTBUS_OK;
}

static int32_t GetAllListener(ConnListenerNode **node)
{
    ConnListenerNode *listenerNode = NULL;
    int32_t cnt = 0;

    if (g_listenerList == NULL) {
        CLOGE("listener list is null");
        return cnt;
    }

    if (g_listenerList->cnt == 0) {
        CLOGE("listener cnt is null");
        return cnt;
    }

    if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
        CLOGE("lock mutex failed");
        return 0;
    }
    *node = SoftBusCalloc(g_listenerList->cnt * sizeof(ConnListenerNode));
    if (*node == NULL) {
        (void)SoftBusMutexUnlock(&g_listenerList->lock);
        return cnt;
    }
    LIST_FOR_EACH_ENTRY(listenerNode, &g_listenerList->list, ConnListenerNode, node) {
        if (memcpy_s(*node + cnt, sizeof(ConnListenerNode), listenerNode, sizeof(ConnListenerNode)) != EOK) {
            CLOGE("mem error");
            continue;
        }
        cnt++;
    }
    (void)SoftBusMutexUnlock(&g_listenerList->lock);
    return cnt;
}

static int32_t GetListenerByModuleId(ConnModule moduleId, ConnListenerNode *node)
{
    ConnListenerNode *listenerNode = NULL;

    if (g_listenerList == NULL) {
        return SOFTBUS_ERR;
    }
    int ret = SOFTBUS_OK;
    if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
        CLOGE("lock mutex failed");
        return SOFTBUS_ERR;
    }
    LIST_FOR_EACH_ENTRY(listenerNode, &g_listenerList->list, ConnListenerNode, node) {
        if (listenerNode->moduleId == moduleId) {
            if (memcpy_s(node, sizeof(ConnListenerNode), listenerNode, sizeof(ConnListenerNode)) != EOK) {
                ret = SOFTBUS_ERR;
            }
            (void)SoftBusMutexUnlock(&g_listenerList->lock);
            return ret;
        }
    }
    (void)SoftBusMutexUnlock(&g_listenerList->lock);
    return SOFTBUS_ERR;
}

static int32_t AddListener(ConnModule moduleId, const ConnectCallback *callback)
{
    ConnListenerNode *item = NULL;
    ConnListenerNode *listNode = NULL;

    if (g_listenerList == NULL) {
        return SOFTBUS_ERR;
    }
    if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
        CLOGE("lock mutex failed");
        return SOFTBUS_ERR;
    }
    LIST_FOR_EACH_ENTRY(listNode, &g_listenerList->list, ConnListenerNode, node) {
        if (listNode->moduleId == moduleId) {
            (void)SoftBusMutexUnlock(&g_listenerList->lock);
            return SOFTBUS_ERR;
        }
    }
    item = (ConnListenerNode *)SoftBusCalloc(sizeof(ConnListenerNode));
    if (item == NULL) {
        CLOGE("malloc failed");
        (void)SoftBusMutexUnlock(&g_listenerList->lock);
        return SOFTBUS_ERR;
    }
    item->moduleId = moduleId;
    item->callback = *callback;

    ListAdd(&(g_listenerList->list), &(item->node));
    g_listenerList->cnt++;
    (void)SoftBusMutexUnlock(&g_listenerList->lock);
    return SOFTBUS_OK;
}

static void DelListener(ConnModule moduleId)
{
    ConnListenerNode *removeNode = NULL;
    if (g_listenerList == NULL) {
        CLOGE("listenerList is null");
        return;
    }

    if (SoftBusMutexLock(&g_listenerList->lock) != 0) {
        CLOGE("lock mutex failed");
        return;
    }

    LIST_FOR_EACH_ENTRY(removeNode, &g_listenerList->list, ConnListenerNode, node) {
        if (removeNode->moduleId == moduleId) {
            ListDelete(&(removeNode->node));
            SoftBusFree(removeNode);
            g_listenerList->cnt--;
            break;
        }
    }
    (void)SoftBusMutexUnlock(&g_listenerList->lock);
    return;
}

NO_SANITIZE("cfi") uint32_t ConnGetHeadSize(void)
{
    return sizeof(ConnPktHead);
}

NO_SANITIZE("cfi") uint32_t ConnGetNewRequestId(ConnModule moduleId)
{
#define REQID_MAX 1000000
    (void)moduleId;
    static uint32_t reqId = 1;
    reqId++;
    reqId = reqId % REQID_MAX + 1;
    return reqId;
}

NO_SANITIZE("cfi")
void ConnManagerRecvData(uint32_t connectionId, ConnModule moduleId, int64_t seq, char *data, int32_t len)
{
    CONN_CHECK_AND_RETURN_LOG(
        data != NULL, "dispatch data failed: data is null, connection id=%u, module=%d", connectionId, moduleId);
    CONN_CHECK_AND_RETURN_LOG(len > (int32_t)sizeof(ConnPktHead),
        "dispatch data failed: data length less than connection header size, connection id=%u, module=%d, dataLen=%d",
        connectionId, moduleId, len);

    ConnListenerNode listener = { 0 };
    int32_t status = GetListenerByModuleId(moduleId, &listener);
    CONN_CHECK_AND_RETURN_LOG(status == SOFTBUS_OK,
        "dispatch data failed: get module listener failed or not register, connection id=%u, module=%d, dataLen=%d, "
        "err=%d", connectionId, moduleId, len, status);

    int32_t pktLen = len - sizeof(ConnPktHead);
    char *pkt = data + sizeof(ConnPktHead);
    listener.callback.OnDataReceived(connectionId, moduleId, seq, pkt, pktLen);
}

static void ReportConnectTime(const ConnectionInfo *info)
{
    if (info == NULL) {
        CLOGE("ReportConnectTime:info is null");
        return;
    }
    ConnTimeNode *timeNode = GetConnTimeNode(info);
    if (timeNode == NULL) {
        CLOGE("ReportConnectTime:get timeNode failed");
    } else {
        FreeConnTimeNode(timeNode);
    }
}

static void RecordStartTime(const ConnectOption *info)
{
    ConnectionInfo conInfo = { 0 };
    conInfo.type = info->type;
    switch (info->type) {
        case CONNECT_BR:
            if (memcpy_s(&conInfo.brInfo.brMac, BT_MAC_LEN, info->brOption.brMac, BT_MAC_LEN) != EOK) {
                CLOGE("RecordStartTime:brMac memcpy failed");
                return;
            }
            break;
        case CONNECT_BLE:
            if (memcpy_s(&conInfo.bleInfo.bleMac, BT_MAC_LEN, info->bleOption.bleMac, BT_MAC_LEN) != EOK) {
                CLOGE("RecordStartTime:bleMac memcpy failed");
                return;
            }
            conInfo.bleInfo.protocol = info->bleOption.protocol;
            conInfo.bleInfo.psm = info->bleDirectOption.psm;
            break;
        case CONNECT_TCP:
            if (memcpy_s(&conInfo.socketInfo.addr, MAX_SOCKET_ADDR_LEN, info->socketOption.addr, MAX_SOCKET_ADDR_LEN) !=
                EOK) {
                CLOGE("RecordStartTime:addr memcpy failed");
                return;
            }
            break;
        default:
            CLOGE("RecordStartTime:do nothing");
            break;
    }
    ConnTimeNode *timeNode = GetConnTimeNode(&conInfo);
    if (timeNode == NULL) {
        timeNode = (ConnTimeNode *)SoftBusCalloc(sizeof(ConnTimeNode));
        if (timeNode == NULL) {
            CLOGE("malloc node failed");
        } else if (AddConnTimeNode(&conInfo, timeNode) != SOFTBUS_OK) {
            SoftBusFree(timeNode);
            CLOGE("AddConnTimeNode failed");
        }
    }
}
static int32_t InitTimeNodeList()
{
    if (g_connTimeList == NULL) {
        g_connTimeList = CreateSoftBusList();
        if (g_connTimeList == NULL) {
            CLOGE("create list failed");
            return SOFTBUS_ERR;
        }
    }
    return SOFTBUS_OK;
}

NO_SANITIZE("cfi") void ConnManagerConnected(uint32_t connectionId, const ConnectionInfo *info)
{
    ConnListenerNode *node = NULL;
    ConnListenerNode *listener = NULL;

    int32_t num = GetAllListener(&node);
    if (num == 0 || node == NULL) {
        CLOGE("get node failed connId %u", connectionId);
        return;
    }

    for (int32_t i = 0; i < num; i++) {
        listener = node + i;
        listener->callback.OnConnected(connectionId, info);
    }
    SoftBusFree(node);
    ReportConnectTime(info);
    return;
}

NO_SANITIZE("cfi") void ConnManagerDisconnected(uint32_t connectionId, const ConnectionInfo *info)
{
    ConnListenerNode *node = NULL;
    ConnListenerNode *listener = NULL;

    int32_t num = GetAllListener(&node);
    if (num == 0 || node == NULL) {
        return;
    }
    for (int32_t i = 0; i < num; i++) {
        listener = node + i;
        listener->callback.OnDisconnected(connectionId, info);
    }
    SoftBusFree(node);
    return;
}

NO_SANITIZE("cfi") int32_t ConnSetConnectCallback(ConnModule moduleId, const ConnectCallback *callback)
{
    if (ModuleCheck(moduleId) != SOFTBUS_OK) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (callback == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if ((callback->OnConnected == NULL) || (callback->OnDisconnected == NULL) || (callback->OnDataReceived == NULL)) {
        return SOFTBUS_INVALID_PARAM;
    }
    return AddListener(moduleId, callback);
}

NO_SANITIZE("cfi") void ConnUnSetConnectCallback(ConnModule moduleId)
{
    DelListener(moduleId);
    return;
}

NO_SANITIZE("cfi") int32_t ConnTypeIsSupport(ConnectType type)
{
    return ConnTypeCheck(type);
}

NO_SANITIZE("cfi") int32_t ConnConnectDevice(const ConnectOption *info, uint32_t requestId, const ConnectResult *result)
{
    if (info == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
        CLOGE("connect type is err %d", info->type);
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[info->type]->ConnectDevice == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }
    RecordStartTime(info);
    return g_connManager[info->type]->ConnectDevice(info, requestId, result);
}

NO_SANITIZE("cfi") int32_t ConnGetTypeByConnectionId(uint32_t connectionId, ConnectType *type)
{
    CONN_CHECK_AND_RETURN_RET_LOG(type != NULL, SOFTBUS_INVALID_PARAM, "param error");

    ConnectType temp;
    temp = (connectionId >> CONNECT_TYPE_SHIFT);
    if (ConnTypeCheck(temp) != SOFTBUS_OK) {
        CLOGE("connectionId type is err %u", temp);
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }
    *type = temp;
    return SOFTBUS_OK;
}

NO_SANITIZE("cfi") int32_t ConnPostBytes(uint32_t connectionId, ConnPostData *data)
{
    ConnectType type;
    ConnPktHead *head = NULL;

    if (data == NULL || data->buf == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (data->len <= sizeof(ConnPktHead) || data->len > INT32_MAX) {
        SoftBusFree(data->buf);
        return SOFTBUS_CONN_MANAGER_PKT_LEN_INVALID;
    }

    if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
        SoftBusFree(data->buf);
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[type]->PostBytes == NULL) {
        SoftBusFree(data->buf);
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }

    head = (ConnPktHead *)data->buf;
    head->magic = MAGIC_NUMBER;
    head->flag = data->flag;
    head->module = data->module;
    head->len = data->len - sizeof(ConnPktHead);
    head->seq = data->seq;
    PackConnPktHead(head);
    return g_connManager[type]->PostBytes(
        connectionId, (uint8_t *)data->buf, data->len, data->pid, data->flag, data->module, data->seq);
}

NO_SANITIZE("cfi") int32_t ConnDisconnectDevice(uint32_t connectionId)
{
    ConnectType type;
    if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[type]->DisconnectDevice == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }
    return g_connManager[type]->DisconnectDevice(connectionId);
}

NO_SANITIZE("cfi") int32_t ConnDisconnectDeviceAllConn(const ConnectOption *option)
{
    if (option == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (ConnTypeCheck(option->type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[option->type]->DisconnectDeviceNow == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }
    return g_connManager[option->type]->DisconnectDeviceNow(option);
}

NO_SANITIZE("cfi") int32_t ConnGetConnectionInfo(uint32_t connectionId, ConnectionInfo *info)
{
    ConnectType type;
    if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[type]->GetConnectionInfo == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }

    return g_connManager[type]->GetConnectionInfo(connectionId, info);
}

NO_SANITIZE("cfi") int32_t ConnStartLocalListening(const LocalListenerInfo *info)
{
    if (info == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[info->type]->StartLocalListening == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }

    return g_connManager[info->type]->StartLocalListening(info);
}

NO_SANITIZE("cfi") int32_t ConnStopLocalListening(const LocalListenerInfo *info)
{
    if (info == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[info->type]->StopLocalListening == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }

    return g_connManager[info->type]->StopLocalListening(info);
}

ConnectCallback g_connManagerCb = { 0 };

NO_SANITIZE("cfi") int32_t ConnServerInit(void)
{
    ConnectFuncInterface *connectObj = NULL;

    if (g_isInited) {
        return SOFTBUS_ERR;
    }

    int32_t ret = ConnInitSockets();
    if (ret != SOFTBUS_OK) {
        SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "ConnInitSockets failed!ret=%" PRId32 " \r\n", ret);
        return ret;
    }

    ret = InitBaseListener();
    if (ret != SOFTBUS_OK) {
        SoftBusLog(SOFTBUS_LOG_CONN, SOFTBUS_LOG_ERROR, "InitBaseListener failed!ret=%" PRId32 " \r\n", ret);
        return ret;
    }

    g_connManagerCb.OnConnected = ConnManagerConnected;
    g_connManagerCb.OnDisconnected = ConnManagerDisconnected;
    g_connManagerCb.OnDataReceived = ConnManagerRecvData;

    int isSupportTcp = 0;
    (void)SoftbusGetConfig(SOFTBUS_INT_SUPPORT_TCP_PROXY, (unsigned char *)&isSupportTcp, sizeof(isSupportTcp));
    if (isSupportTcp) {
        connectObj = ConnInitTcp(&g_connManagerCb);
        if (connectObj != NULL) {
            g_connManager[CONNECT_TCP] = connectObj;
            CLOGI("init tcp ok");
        }
    }

    connectObj = ConnInitBr(&g_connManagerCb);
    if (connectObj != NULL) {
        g_connManager[CONNECT_BR] = connectObj;
        CLOGI("init br ok");
    }

    connectObj = ConnInitBle(&g_connManagerCb);
    if (connectObj != NULL) {
        g_connManager[CONNECT_BLE] = connectObj;
        CLOGI("init ble ok");
    }

    if (g_listenerList == NULL) {
        g_listenerList = CreateSoftBusList();
        if (g_listenerList == NULL) {
            CLOGE("create list failed");
            return SOFTBUS_ERR;
        }
    }
    InitTimeNodeList();

    g_isInited = true;
    CLOGI("connect manager init success.");
    return SOFTBUS_OK;
}

NO_SANITIZE("cfi") void ConnServerDeinit(void)
{
    if (!g_isInited) {
        return;
    }

    ConnListenerNode *item = NULL;
    if (g_listenerList != NULL) {
        while (!IsListEmpty(&g_listenerList->list)) {
            item = LIST_ENTRY((&g_listenerList->list)->next, ConnListenerNode, node);
            ListDelete(&item->node);
            SoftBusFree(item);
        }
        DestroySoftBusList(g_listenerList);
        g_listenerList = NULL;
    }

    DeinitBaseListener();

    g_isInited = false;
}

NO_SANITIZE("cfi") bool CheckActiveConnection(const ConnectOption *info)
{
    if (info == NULL) {
        return false;
    }

    if (ConnTypeCheck(info->type) != SOFTBUS_OK) {
        CLOGE("connect type is err %d", info->type);
        return false;
    }

    if (g_connManager[info->type]->CheckActiveConnection == NULL) {
        return false;
    }

    return g_connManager[info->type]->CheckActiveConnection(info);
}

int32_t ConnUpdateConnection(uint32_t connectionId, UpdateOption *option)
{
    if (option == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    ConnectType type;
    if (ConnGetTypeByConnectionId(connectionId, &type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }
    if (g_connManager[type]->UpdateConnection == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }
    return g_connManager[type]->UpdateConnection(connectionId, option);
}

int32_t ConnPreventConnection(const ConnectOption *option, uint32_t time)
{
    if (option == NULL) {
        return SOFTBUS_INVALID_PARAM;
    }

    if (ConnTypeCheck(option->type) != SOFTBUS_OK) {
        return SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT;
    }

    if (g_connManager[option->type]->PreventConnection == NULL) {
        return SOFTBUS_CONN_MANAGER_OP_NOT_SUPPORT;
    }
    return g_connManager[option->type]->PreventConnection(option, time);
}