From dbbcd21005e157e37078aafafbe6e0eb8d6dae49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=99=88=E6=9A=84=E7=BF=8A?= <764088276@qq.com> Date: Mon, 8 Sep 2025 15:51:12 +0800 Subject: [PATCH] first MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 陈暄翊 <764088276@qq.com> --- .../netconnclient/src/net_conn_client.cpp | 336 ++++++++++++--- interfaces/innerkits/netconnclient/BUILD.gn | 67 +++ .../netconnclient/include/net_conn_client.h | 34 ++ .../netconnclient/libnetconn_kits.map | 4 - .../src/net_conn_service_iface.cpp | 4 +- .../include/stub/net_policy_service_stub.h | 2 +- .../src/stub/net_policy_service_stub.cpp | 4 +- test/fuzztest/netbasebranch_fuzzer/BUILD.gn | 2 +- test/fuzztest/netconnclient_fuzzer/BUILD.gn | 2 +- test/fuzztest/netstatsclient_fuzzer/BUILD.gn | 2 +- .../mock/net_conn_service_stub_test.h | 2 +- .../unittest/net_conn_manager_test/BUILD.gn | 2 +- .../unittest/net_conn_multi_test/BUILD.gn | 5 +- .../net_conn_client_test.cpp | 383 +++++++++++++++++- .../net_conn_service_regional_test/BUILD.gn | 2 +- .../unittest/net_conn_service_test/BUILD.gn | 2 +- .../net_factoryreset_callback_test/BUILD.gn | 2 +- .../unittest/net_info_test/BUILD.gn | 2 +- .../unittest/net_supplier_test/BUILD.gn | 2 +- .../unittest/netmgr_distributed_test/BUILD.gn | 2 +- .../unittest/netsys_distributed_test/BUILD.gn | 2 +- .../unittest/netsys_manager_test/BUILD.gn | 5 +- .../net_access_policy_database_test/BUILD.gn | 1 - .../unittest/net_policy_manager_test/BUILD.gn | 1 - .../net_policy_service_nocfi_test/BUILD.gn | 1 - .../unittest/net_policy_service_test/BUILD.gn | 1 - .../unittest/net_stats_manager_test/BUILD.gn | 2 +- 27 files changed, 768 insertions(+), 106 deletions(-) diff --git a/frameworks/native/netconnclient/src/net_conn_client.cpp b/frameworks/native/netconnclient/src/net_conn_client.cpp index 09e832954..61608a8bc 100755 --- a/frameworks/native/netconnclient/src/net_conn_client.cpp +++ b/frameworks/native/netconnclient/src/net_conn_client.cpp @@ -28,6 +28,10 @@ #include "net_supplier_callback_stub.h" #include "netsys_sock_client.h" #include "system_ability_status_change_stub.h" +#include "netmanager_base_permission.h" +#ifndef NETMANAGER_TEST +#include "ffrt.h" +#endif static constexpr const int32_t MIN_VALID_NETID = 100; static constexpr const int32_t MIN_VALID_INTERNAL_NETID = 1; @@ -46,6 +50,8 @@ private: NetConnClient::NetConnClient() : NetConnService_(nullptr), deathRecipient_(nullptr), saStatusListener_(nullptr) { buffer_[RESERVED_BUFFER_SIZE-1] = '\0'; + defaultNetSpecifier_ = sptr::MakeSptr(); + defaultNetSpecifier_->SetCapabilities({NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN}); } NetConnClient::~NetConnClient() @@ -264,20 +270,23 @@ int32_t NetConnClient::RegisterNetSupplierCallback(uint32_t supplierId, const sp int32_t NetConnClient::RegisterNetConnCallback(const sptr callback) { - NETMGR_LOG_D("RegisterNetConnCallback client in."); - sptr proxy = GetProxy(); - if (proxy == nullptr) { - NETMGR_LOG_E("The parameter of proxy is nullptr"); - return NETMANAGER_ERR_GET_PROXY_FAIL; - } - int32_t ret = proxy->RegisterNetConnCallback(callback); - if (ret == NETMANAGER_SUCCESS) { - NETMGR_LOG_D("RegisterNetConnCallback success, save callback."); - std::lock_guard locker(registerConnTupleListMutex_); - registerConnTupleList_.push_back(std::make_tuple(nullptr, callback, 0)); - } + return RegisterNetConnCallback(defaultNetSpecifier_, callback, 0); +} - return ret; +sptr NetConnClient::FindConnCallbackManager( + NetConnCallbackManagerMap &managerMap, const sptr &netSpecifier) +{ + for (const auto& pair : managerMap) { + std::string ident_ = pair.first->ident_; + sptr connCallbackManager = pair.second; + NetAllCapabilities netAllCapabilities = pair.first->netCapabilities_; + if (ident_ == netSpecifier->ident_ && + netAllCapabilities.bearerTypes_ == netSpecifier->netCapabilities_.bearerTypes_ && + netAllCapabilities.netCaps_ == netSpecifier->netCapabilities_.netCaps_) { + return connCallbackManager; + } + } + return nullptr; } int32_t NetConnClient::RegisterNetConnCallback(const sptr &netSpecifier, @@ -293,11 +302,20 @@ int32_t NetConnClient::RegisterNetConnCallback(const sptr &netSpec NETMGR_LOG_E("The parameter of proxy is nullptr"); return NETMANAGER_ERR_GET_PROXY_FAIL; } - int32_t ret = proxy->RegisterNetConnCallback(netSpecifier, callback, timeoutMS); - if (ret == NETMANAGER_SUCCESS) { - NETMGR_LOG_D("RegisterNetConnCallback success, save netSpecifier and callback and timeoutMS."); - std::lock_guard locker(registerConnTupleListMutex_); - registerConnTupleList_.push_back(std::make_tuple(netSpecifier, callback, timeoutMS)); + int32_t ret = NETMANAGER_SUCCESS; + std::unique_lock locker(netConnCallbackManagerMapMutex_); + sptr connCallbackManager = + FindConnCallbackManager(netConnCallbackManagerMap_, netSpecifier); + if (connCallbackManager != nullptr) { + ret = connCallbackManager->AddNetConnCallback(callback); + } else { + auto cb = sptr::MakeSptr(); + cb->AddNetConnCallback(callback); + ret = proxy->RegisterNetConnCallback(netSpecifier, cb, timeoutMS); + if (ret == NETMANAGER_SUCCESS) { + netConnCallbackManagerMap_.emplace(netSpecifier, cb); + NETMGR_LOG_D("RegisterNetConnCallback success, save callback."); + } } return ret; @@ -316,37 +334,63 @@ int32_t NetConnClient::RequestNetConnection(const sptr netSpecifie NETMGR_LOG_E("The parameter of proxy is nullptr"); return NETMANAGER_ERR_GET_PROXY_FAIL; } - int32_t ret = proxy->RequestNetConnection(netSpecifier, callback, timeoutMS); - if (ret == NETMANAGER_SUCCESS) { - NETMGR_LOG_D("RequestNetConnection success, save netSpecifier and callback and timeoutMS."); - std::lock_guard locker(registerConnTupleListMutex_); - registerConnTupleList_.push_back(std::make_tuple(netSpecifier, callback, timeoutMS)); + int32_t ret = NETMANAGER_SUCCESS; + std::unique_lock locker(netConnCallbackManagerMapMutex_); + sptr connCallbackManager = + FindConnCallbackManager(systemNetConnCallbackManagerMap_, netSpecifier); + if (connCallbackManager != nullptr) { + ret = connCallbackManager->AddNetConnCallback(callback); + } else { + auto cb = sptr::MakeSptr(); + cb->AddNetConnCallback(callback); + ret = proxy->RequestNetConnection(netSpecifier, cb, timeoutMS); + if (ret == NETMANAGER_SUCCESS) { + systemNetConnCallbackManagerMap_.emplace(netSpecifier, cb); + NETMGR_LOG_D("RequestNetConnection success, save callback."); + } } - return ret; } +bool NetConnClient::IsCallbackExist(const sptr &callback) +{ + for (const auto& pair : netConnCallbackManagerMap_) { + if (pair.second->HasExistCallback(callback)) { + return true; + } + } + for (const auto& pair : systemNetConnCallbackManagerMap_) { + if (pair.second->HasExistCallback(callback)) { + return true; + } + } + return false; +} + int32_t NetConnClient::UnregisterNetConnCallback(const sptr &callback) { NETMGR_LOG_D("UnregisterNetConnCallback client in."); +#ifndef NETMANAGER_TEST + if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) { + NETMGR_LOG_I("Permission deny: Request with INTERNAL_DEFAULT But not has CONNECTIVITY_INTERNAL"); + return NETMANAGER_ERR_PERMISSION_DENIED; + } +#endif sptr proxy = GetProxy(); if (proxy == nullptr) { NETMGR_LOG_E("proxy is nullptr"); return NETMANAGER_ERR_GET_PROXY_FAIL; } - int32_t ret = proxy->UnregisterNetConnCallback(callback); - if (ret == NETMANAGER_SUCCESS) { - NETMGR_LOG_D("UnregisterNetConnCallback success, delete callback."); - std::lock_guard locker(registerConnTupleListMutex_); - for (auto it = registerConnTupleList_.begin(); it != registerConnTupleList_.end(); ++it) { - if (std::get<1>(*it)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) { - registerConnTupleList_.erase(it); - break; - } - } + std::unique_lock locker(netConnCallbackManagerMapMutex_); + if (!IsCallbackExist(callback)) { + NETMGR_LOG_E("UnregisterNetConnCallback NET_CONN_ERR_CALLBACK_NOT_FOUND"); + return NET_CONN_ERR_CALLBACK_NOT_FOUND; } - - return ret; + int32_t ret1 = UnRegisterNetConnCallbackManager(callback, netConnCallbackManagerMap_); + int32_t ret2 = UnRegisterNetConnCallbackManager(callback, systemNetConnCallbackManagerMap_); + + return (ret1 == NETMANAGER_SUCCESS && ret2 == NETMANAGER_SUCCESS) ? NETMANAGER_SUCCESS : + (ret1 == NETMANAGER_SUCCESS ? ret2 : ret1); } int32_t NetConnClient::RegisterNetDetectionCallback(int32_t netId, const sptr &callback) @@ -577,46 +621,26 @@ int32_t NetConnClient::SetAirplaneMode(bool state) void NetConnClient::RecoverCallbackAndGlobalProxy() { - std::list, sptr, uint32_t>> registerConnTupleListTmp; - { - std::lock_guard locker(registerConnTupleListMutex_); - registerConnTupleListTmp = registerConnTupleList_; - } - if (registerConnTupleListTmp.empty() && globalHttpProxy_.GetHost().empty() && - preAirplaneCallback_ == nullptr) { + if (globalHttpProxy_.GetHost().empty() && preAirplaneCallback_ == nullptr) { NETMGR_LOG_W("no need recovery"); return; } + std::shared_lock locker(netConnCallbackManagerMapMutex_); + RecoverCallbackAndGlobalProxy(netConnCallbackManagerMap_); + RecoverCallbackAndGlobalProxy(systemNetConnCallbackManagerMap_); + locker.unlock(); auto proxy = GetProxy(); NETMGR_LOG_W("Get proxy %{public}s", proxy == nullptr ? "failed" : "success"); - if (proxy != nullptr) { - for (auto mem : registerConnTupleListTmp) { - sptr specifier = std::get<0>(mem); - sptr callback = std::get<1>(mem); - uint32_t timeoutMS = std::get<2>(mem); - bool isInternalDefault = specifier != nullptr && - specifier->netCapabilities_.netCaps_.count(NetManagerStandard::NET_CAPABILITY_INTERNAL_DEFAULT) > 0; - int32_t ret = NETMANAGER_SUCCESS; - if (specifier != nullptr && timeoutMS != 0) { - ret = isInternalDefault ? proxy->RequestNetConnection(specifier, callback, timeoutMS) : - proxy->RegisterNetConnCallback(specifier, callback, timeoutMS); - NETMGR_LOG_D("Register result hasNetSpecifier_ and timeoutMS_ %{public}d", ret); - } else if (specifier != nullptr) { - ret = isInternalDefault ? proxy->RequestNetConnection(specifier, callback, 0) : - proxy->RegisterNetConnCallback(specifier, callback, 0); - NETMGR_LOG_D("Register result hasNetSpecifier_ %{public}d", ret); - } else if (callback != nullptr) { - int32_t ret = proxy->RegisterNetConnCallback(callback); - NETMGR_LOG_D("Register netconn result %{public}d", ret); - } - } + if (proxy == nullptr) { + NETMGR_LOG_E("proxy is nullptr"); + return; } - if (proxy != nullptr && preAirplaneCallback_ != nullptr) { + if (preAirplaneCallback_ != nullptr) { int32_t ret = proxy->RegisterPreAirplaneCallback(preAirplaneCallback_); NETMGR_LOG_D("Register pre airplane result %{public}d", ret); } - if (proxy != nullptr && !globalHttpProxy_.GetHost().empty()) { + if (!globalHttpProxy_.GetHost().empty()) { int32_t ret = proxy->SetGlobalHttpProxy(globalHttpProxy_); NETMGR_LOG_D("globalHttpProxy_ Register result %{public}d", ret); } @@ -1304,5 +1328,185 @@ int32_t NetConnClient::SetNetExtAttribute(const NetHandle &netHandle, const std: return proxy->SetNetExtAttribute(netHandle.GetNetId(), netExtAttribute); } +int32_t NetConnClient::NetConnCallbackManager::NetAvailable(sptr &netHandle) +{ + if (netHandle == nullptr) { + netHandle_ = nullptr; + } else { + netHandle_ = sptr::MakeSptr(netHandle->GetNetId()); + } + std::shared_lock lock(netConnCallbackListMutex_); + std::list> tmpList(netConnCallbackList_); + lock.unlock(); + for (auto& cb : tmpList) { + cb->NetAvailable(netHandle); + } + return NETMANAGER_SUCCESS; +} + +int32_t NetConnClient::NetConnCallbackManager::NetCapabilitiesChange(sptr &netHandle, + const sptr &netAllCap) +{ + if (netHandle_ != nullptr && netHandle->GetNetId() == netHandle_->GetNetId()) { + netAllCap_ = netAllCap; + } + std::shared_lock lock(netConnCallbackListMutex_); + std::list> tmpList(netConnCallbackList_); + lock.unlock(); + for (auto& cb : tmpList) { + cb->NetCapabilitiesChange(netHandle, netAllCap); + } + return NETMANAGER_SUCCESS; +} + +int32_t NetConnClient::NetConnCallbackManager::NetConnectionPropertiesChange(sptr &netHandle, + const sptr &info) +{ + if (netHandle_ != nullptr && netHandle->GetNetId() == netHandle_->GetNetId()) { + netLinkInfo_ = info; + } + std::shared_lock lock(netConnCallbackListMutex_); + std::list> tmpList(netConnCallbackList_); + lock.unlock(); + for (auto& cb : tmpList) { + cb->NetConnectionPropertiesChange(netHandle, info); + } + return NETMANAGER_SUCCESS; +} + +int32_t NetConnClient::NetConnCallbackManager::NetLost(sptr &netHandle) +{ + if (netHandle_ != nullptr && netHandle->GetNetId() == netHandle_->GetNetId()) { + netHandle_ = nullptr; + netAllCap_ = nullptr; + netLinkInfo_ = nullptr; + } + std::shared_lock lock(netConnCallbackListMutex_); + std::list> tmpList(netConnCallbackList_); + lock.unlock(); + for (auto& cb : tmpList) { + cb->NetLost(netHandle); + } + return NETMANAGER_SUCCESS; +} + +int32_t NetConnClient::NetConnCallbackManager::NetUnavailable() +{ + netHandle_ = nullptr; + std::shared_lock lock(netConnCallbackListMutex_); + std::list> tmpList(netConnCallbackList_); + lock.unlock(); + for (auto& cb : tmpList) { + cb->NetUnavailable(); + } + return NETMANAGER_SUCCESS; +} + +int32_t NetConnClient::NetConnCallbackManager::NetBlockStatusChange(sptr &netHandle, bool blocked) +{ + std::shared_lock lock(netConnCallbackListMutex_); + std::list> tmpList(netConnCallbackList_); + lock.unlock(); + for (auto& cb : tmpList) { + cb->NetBlockStatusChange(netHandle, blocked); + } + return NETMANAGER_SUCCESS; +} + +int32_t NetConnClient::NetConnCallbackManager::AddNetConnCallback(const sptr& callback) +{ + std::unique_lock lock(netConnCallbackListMutex_); + for (auto& cb : netConnCallbackList_) { + if (cb == callback) { + return NET_CONN_ERR_SAME_CALLBACK; + } + } + netConnCallbackList_.push_back(callback); + lock.unlock(); +#ifndef NETMANAGER_TEST + ffrt::submit([this, callback] () { +#endif + if (netHandle_ != nullptr) { + callback->NetAvailable(netHandle_); + if (netAllCap_ != nullptr) { + callback->NetCapabilitiesChange(netHandle_, netAllCap_); + } + if (netLinkInfo_ != nullptr) { + callback->NetConnectionPropertiesChange(netHandle_, netLinkInfo_); + } + } +#ifndef NETMANAGER_TEST + }, + {}, {}, ffrt::task_attr().name("AddNetConnCallback")); +#endif + return NETMANAGER_SUCCESS; +} + +void NetConnClient::NetConnCallbackManager::RemoveNetConnCallback(const sptr& callback) +{ + std::unique_lock lock(netConnCallbackListMutex_); + netConnCallbackList_.remove(callback); +} + +bool NetConnClient::NetConnCallbackManager::HasExistCallback(const sptr& callback) +{ + std::unique_lock lock(netConnCallbackListMutex_); + for (auto& cb : netConnCallbackList_) { + if (cb == callback) { + return true; + } + } + return false; +} + +int32_t NetConnClient::UnRegisterNetConnCallbackManager(const sptr& callback, + NetConnCallbackManagerMap& netConnCallbackManagerMap) +{ +#ifndef NETMANAGER_TEST + if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) { + NETMGR_LOG_I("Permission deny: Request with INTERNAL_DEFAULT But not has CONNECTIVITY_INTERNAL"); + return NETMANAGER_ERR_PERMISSION_DENIED; + } +#endif + sptr proxy = GetProxy(); + if (proxy == nullptr) { + NETMGR_LOG_E("The parameter of proxy is nullptr"); + return NETMANAGER_ERR_GET_PROXY_FAIL; + } + int ret = NETMANAGER_SUCCESS; + for (auto itMap = netConnCallbackManagerMap.begin(); itMap != netConnCallbackManagerMap.end();) { + auto& netConnCallbackManager = itMap->second; + netConnCallbackManager->RemoveNetConnCallback(callback); + if (netConnCallbackManager->netConnCallbackList_.empty()) { + ret = proxy->UnregisterNetConnCallback(netConnCallbackManager); + if (ret == NETMANAGER_SUCCESS) { + itMap = netConnCallbackManagerMap.erase(itMap); + continue; + } + } + itMap++; + } + return ret; +} + +void NetConnClient::RecoverCallbackAndGlobalProxy(NetConnCallbackManagerMap& netConnCallbackManagerMap) +{ + auto proxy = GetProxy(); + if (proxy == nullptr) { + NETMGR_LOG_E("proxy is nullptr"); + return; + } + for (auto& it : netConnCallbackManagerMap) { + bool isInternalDefault = it.first->netCapabilities_.netCaps_. + count(NetManagerStandard::NET_CAPABILITY_INTERNAL_DEFAULT) > 0; + int32_t ret = NETMANAGER_SUCCESS; + if (isInternalDefault) { + ret = proxy->RequestNetConnection(it.first, it.second, 0); + } else { + ret = proxy->RegisterNetConnCallback(it.first, it.second, 0); + } + NETMGR_LOG_D("Register result hasNetSpecifier_ %{public}d", ret); + } +} } // namespace NetManagerStandard } // namespace OHOS diff --git a/interfaces/innerkits/netconnclient/BUILD.gn b/interfaces/innerkits/netconnclient/BUILD.gn index fc0835176..1a7285a0b 100644 --- a/interfaces/innerkits/netconnclient/BUILD.gn +++ b/interfaces/innerkits/netconnclient/BUILD.gn @@ -101,6 +101,7 @@ ohos_shared_library("net_conn_manager_if") { "$NETMANAGERNATIVE_ROOT/fwmarkclient/include", "$NETMANAGER_BASE_ROOT/utils/bundle_utils/include", "$NETMANAGER_BASE_ROOT/utils/common_utils/include", + "$INNERKITS_ROOT/netconnclient/include/proxy", ] version_script = "libnetconn_kits.map" @@ -116,6 +117,7 @@ ohos_shared_library("net_conn_manager_if") { "bounds_checking_function:libsec_shared", "c_utils:utils", "samgr:samgr_proxy", + "ffrt:libffrt", ] public_external_deps = [ "ipc:ipc_core" ] @@ -209,6 +211,71 @@ ohos_shared_library("net_security_config_if") { if (enable_netmgr_debug) { defines += [ "NETMGR_DEBUG" ] } + part_name = "netmanager_base" + subsystem_name = "communication" +} + +ohos_static_library("net_conn_manager_if_static") { + testonly = true + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + cflags = common_cflags + + cflags_cc = common_cflags + + branch_protector_ret = "pac_ret" + + sources = [ + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/net_conn_client.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/net_handle.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/net_supplier_callback_base.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_conn_callback_stub.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_conn_service_proxy.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_detection_callback_stub.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_conn_service_pac_proxy_helper.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_factoryreset_callback_stub.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_interface_callback_stub.cpp", + "$NETCONNMANAGER_INNERKITS_SOURCE_DIR/src/proxy/net_supplier_callback_stub.cpp", + ] + + include_dirs = [ + "$INNERKITS_ROOT/netmanagernative/include", + "$NETMANAGERNATIVE_ROOT/fwmarkclient/include", + "$NETMANAGER_BASE_ROOT/utils/bundle_utils/include", + "$NETMANAGER_BASE_ROOT/utils/common_utils/include", + ] + + public_configs = [ ":net_conn_manager_if_config" ] + + deps = [ + ":net_conn_parcel", + "$NETMANAGER_BASE_ROOT/services/netmanagernative/fwmarkclient:fwmark_client", + ] + + external_deps = [ + "bounds_checking_function:libsec_shared", + "c_utils:utils", + "samgr:samgr_proxy", + ] + + defines = [ + "NETMGR_LOG_TAG = \"NetConnManager\"", + "LOG_DOMAIN = 0xD0015B0", + "NETMANAGER_TEST", + ] + + if (netmanager_base_enable_feature_wearable_distributed_net) { + defines += [ "FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE" ] + } + if (enable_netmgr_debug) { + defines += [ "NETMGR_DEBUG" ] + } + + external_deps += [ "hilog:libhilog" ] + part_name = "netmanager_base" subsystem_name = "communication" } \ No newline at end of file diff --git a/interfaces/innerkits/netconnclient/include/net_conn_client.h b/interfaces/innerkits/netconnclient/include/net_conn_client.h index 585056753..92df6798f 100644 --- a/interfaces/innerkits/netconnclient/include/net_conn_client.h +++ b/interfaces/innerkits/netconnclient/include/net_conn_client.h @@ -32,6 +32,8 @@ #include "net_supplier_callback_base.h" #include "i_net_factoryreset_callback.h" #include "safe_map.h" +#include +#include "net_conn_callback_stub.h" namespace OHOS { class ISystemAbilityStatusChange; @@ -525,6 +527,27 @@ private: NetConnClient &client_; }; + class NetConnCallbackManager : public NetConnCallbackStub { + friend NetConnClient; + public: + int32_t NetAvailable(sptr &netHandle) override; + int32_t NetCapabilitiesChange(sptr &netHandle, const sptr &netAllCap) override; + int32_t NetConnectionPropertiesChange(sptr &netHandle, const sptr &info) override; + int32_t NetLost(sptr &netHandle) override; + int32_t NetUnavailable() override; + int32_t NetBlockStatusChange(sptr &netHandle, bool blocked) override; + + int32_t AddNetConnCallback(const sptr& callback); + void RemoveNetConnCallback(const sptr& callback); + bool HasExistCallback(const sptr& callback); + private: + sptr netHandle_ = nullptr; + sptr netAllCap_ = nullptr; + sptr netLinkInfo_ = nullptr; + std::shared_mutex netConnCallbackListMutex_; + std::list> netConnCallbackList_; + }; + private: NetConnClient& operator=(const NetConnClient&) = delete; NetConnClient(const NetConnClient&) = delete; @@ -535,6 +558,13 @@ private: static std::optional ObtainTargetApiVersionForSelf(); static std::optional ObtainBundleNameFromBundleMgr(); void SubscribeSystemAbility(); + using NetConnCallbackManagerMap = std::map, sptr>; + int32_t UnRegisterNetConnCallbackManager(const sptr& callback, + NetConnCallbackManagerMap& netConnCallbackManagerMap); + void RecoverCallbackAndGlobalProxy(NetConnCallbackManagerMap& netConnCallbackManagerMap); + sptr FindConnCallbackManager(NetConnCallbackManagerMap &managerMap, + const sptr &netSpecifier); + bool IsCallbackExist(const sptr &callback); private: std::mutex appHttpProxyCbMapMutex_; @@ -548,6 +578,10 @@ private: sptr deathRecipient_; std::map> netSupplierCallback_; std::list, sptr, uint32_t>> registerConnTupleList_; + sptr defaultNetSpecifier_ = nullptr; + std::shared_mutex netConnCallbackManagerMapMutex_; + NetConnCallbackManagerMap netConnCallbackManagerMap_; + NetConnCallbackManagerMap systemNetConnCallbackManagerMap_; SafeMap netPermissionMap_; sptr preAirplaneCallback_; std::mutex registerConnTupleListMutex_; diff --git a/interfaces/innerkits/netconnclient/libnetconn_kits.map b/interfaces/innerkits/netconnclient/libnetconn_kits.map index b31174774..d5f793ae9 100644 --- a/interfaces/innerkits/netconnclient/libnetconn_kits.map +++ b/interfaces/innerkits/netconnclient/libnetconn_kits.map @@ -56,9 +56,6 @@ "OHOS::NetManagerStandard::NetConnClient::GetDefaultNet(OHOS::NetManagerStandard::NetHandle&)"; "OHOS::NetManagerStandard::NetConnClient::GetNetCapabilities(OHOS::NetManagerStandard::NetHandle const&, OHOS::NetManagerStandard::NetAllCapabilities&)"; "OHOS::NetManagerStandard::NetConnClient::BindSocket(int, int)"; - "OHOS::NetManagerStandard::NetConnClient::OnRemoteDied(OHOS::wptr const&)"; - "OHOS::NetManagerStandard::NetConnClient::NetConnClient()"; - "OHOS::NetManagerStandard::NetConnClient::~NetConnClient()"; "OHOS::NetManagerStandard::NetConnClient::RequestNetConnection(OHOS::sptr, OHOS::sptr, unsigned int)"; "OHOS::NetManagerStandard::NetConnClient::RegisterNetConnCallback(OHOS::sptr const&, OHOS::sptr, unsigned int const&)"; "OHOS::NetManagerStandard::NetConnClient::RegisterNetConnCallback(OHOS::sptr)"; @@ -214,7 +211,6 @@ "VTT?for?OHOS::NetManagerStandard::PreAirplaneCallbackStub"; "OHOS::NetManagerStandard::NetConnClient::UnregisterPreAirplaneCallback(OHOS::sptr)"; "OHOS::NetManagerStandard::NetConnClient::CloseSocketsUid(int, unsigned int)"; - "OHOS::NetManagerStandard::NetConnClient::DlCloseRemoveDeathRecipient()"; "OHOS::NetManagerStandard::NetConnClient::GetSpecificNet(OHOS::NetManagerStandard::NetBearType, std::__h::list>&)"; "OHOS::NetManagerStandard::NetConnClient::SetAppIsFrozened(unsigned int, bool)"; "OHOS::NetManagerStandard::NetConnClient::EnableAppFrozenedCallbackLimitation(bool)"; diff --git a/services/netconnmanager/src/net_conn_service_iface.cpp b/services/netconnmanager/src/net_conn_service_iface.cpp index 17a6bb7a3..0d0a33c7c 100644 --- a/services/netconnmanager/src/net_conn_service_iface.cpp +++ b/services/netconnmanager/src/net_conn_service_iface.cpp @@ -84,7 +84,9 @@ int32_t NetConnServiceIface::RestrictBackgroundChanged(bool isRestrictBackground int32_t NetConnServiceIface::RegisterNetConnCallback(const sptr &callback) { - return NetConnService::GetInstance()->RegisterNetConnCallback(callback); + auto netSpecifier = sptr::MakeSptr(); + netSpecifier->SetCapabilities({NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN}); + return NetConnService::GetInstance()->RegisterNetConnCallback(netSpecifier, callback, 0); } int32_t NetConnServiceIface::RegisterNetFactoryResetCallback(const sptr &callback) diff --git a/services/netpolicymanager/include/stub/net_policy_service_stub.h b/services/netpolicymanager/include/stub/net_policy_service_stub.h index 4a87357e6..ca40f7791 100755 --- a/services/netpolicymanager/include/stub/net_policy_service_stub.h +++ b/services/netpolicymanager/include/stub/net_policy_service_stub.h @@ -89,7 +89,7 @@ private: private: std::map memberFuncMap_; std::once_flag onceFlag; - std::mutex setNetworkPolicyMutex_; + ffrt::mutex setNetworkPolicyMutex_; bool isPostDelaySetNetworkPolicy_ = false; std::map> appNetworkPolicyMap_; }; diff --git a/services/netpolicymanager/src/stub/net_policy_service_stub.cpp b/services/netpolicymanager/src/stub/net_policy_service_stub.cpp index 434e7cb88..36cd38b9d 100644 --- a/services/netpolicymanager/src/stub/net_policy_service_stub.cpp +++ b/services/netpolicymanager/src/stub/net_policy_service_stub.cpp @@ -686,7 +686,7 @@ int32_t NetPolicyServiceStub::OnFactoryResetPolicies(MessageParcel &data, Messag void NetPolicyServiceStub::HandleReportNetworkPolicy() { #ifndef UNITTEST_FORBID_FFRT - std::lock_guard lock(setNetworkPolicyMutex_); + std::lock_guard lock(setNetworkPolicyMutex_); #endif if (appNetworkPolicyMap_.empty()) { return; @@ -719,7 +719,7 @@ void NetPolicyServiceStub::HandleReportNetworkPolicy() void NetPolicyServiceStub::HandleStoreNetworkPolicy(uint32_t uid, NetworkAccessPolicy &policy, uint32_t callingUid) { - std::lock_guard lock(setNetworkPolicyMutex_); + std::lock_guard lock(setNetworkPolicyMutex_); if (appNetworkPolicyMap_.find(callingUid) == appNetworkPolicyMap_.end()) { std::map policyMap; appNetworkPolicyMap_.emplace(callingUid, std::move(policyMap)); diff --git a/test/fuzztest/netbasebranch_fuzzer/BUILD.gn b/test/fuzztest/netbasebranch_fuzzer/BUILD.gn index ae090b9ee..6136ee002 100644 --- a/test/fuzztest/netbasebranch_fuzzer/BUILD.gn +++ b/test/fuzztest/netbasebranch_fuzzer/BUILD.gn @@ -50,7 +50,7 @@ ohos_fuzztest("NetBaseBranchFuzzTest") { sources = [ "net_base_branch_fuzzer.cpp" ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/services/netpolicymanager:net_policy_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/fuzztest/netconnclient_fuzzer/BUILD.gn b/test/fuzztest/netconnclient_fuzzer/BUILD.gn index a7bc72b48..d004b83d0 100644 --- a/test/fuzztest/netconnclient_fuzzer/BUILD.gn +++ b/test/fuzztest/netconnclient_fuzzer/BUILD.gn @@ -59,7 +59,7 @@ ohos_fuzztest("NetConnClientFuzzTest") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", "$NETSYSCONTROLLER_ROOT_DIR:netsys_controller", diff --git a/test/fuzztest/netstatsclient_fuzzer/BUILD.gn b/test/fuzztest/netstatsclient_fuzzer/BUILD.gn index fdcc16c34..9b648991f 100644 --- a/test/fuzztest/netstatsclient_fuzzer/BUILD.gn +++ b/test/fuzztest/netstatsclient_fuzzer/BUILD.gn @@ -52,7 +52,7 @@ ohos_fuzztest("NetStatsClientFuzzTest") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETMANAGER_BASE_ROOT/services/netstatsmanager:net_stats_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netconnmanager/mock/net_conn_service_stub_test.h b/test/netconnmanager/mock/net_conn_service_stub_test.h index fa11f7b7c..64b4b7448 100644 --- a/test/netconnmanager/mock/net_conn_service_stub_test.h +++ b/test/netconnmanager/mock/net_conn_service_stub_test.h @@ -69,7 +69,7 @@ public: return 0; } - int32_t RegisterNetConnCallback(const sptr callback) override + int32_t RegisterNetConnCallback(const sptr callback) { return 0; } diff --git a/test/netconnmanager/unittest/net_conn_manager_test/BUILD.gn b/test/netconnmanager/unittest/net_conn_manager_test/BUILD.gn index dfe05d4ab..e5b7e8594 100644 --- a/test/netconnmanager/unittest/net_conn_manager_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_conn_manager_test/BUILD.gn @@ -58,7 +58,7 @@ ohos_unittest("net_conn_manager_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netmanagernative:net_native_manager_if", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", diff --git a/test/netconnmanager/unittest/net_conn_multi_test/BUILD.gn b/test/netconnmanager/unittest/net_conn_multi_test/BUILD.gn index c4aeed59d..81dcb7bbf 100644 --- a/test/netconnmanager/unittest/net_conn_multi_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_conn_multi_test/BUILD.gn @@ -61,7 +61,7 @@ ohos_unittest("net_conn_multi_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netconnclient:net_security_config_if", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", @@ -96,6 +96,7 @@ ohos_unittest("net_conn_multi_test") { "relational_store:native_rdb", "safwk:system_ability_fwk", "samgr:samgr_proxy", + "googletest:gmock_main", ] defines = [ @@ -149,7 +150,7 @@ ohos_unittest("net_conn_multi_vnic_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netconnmanager/unittest/net_conn_multi_test/net_conn_client_test.cpp b/test/netconnmanager/unittest/net_conn_multi_test/net_conn_client_test.cpp index 57ad620bf..1273bcf2d 100644 --- a/test/netconnmanager/unittest/net_conn_multi_test/net_conn_client_test.cpp +++ b/test/netconnmanager/unittest/net_conn_multi_test/net_conn_client_test.cpp @@ -32,10 +32,12 @@ #include "netmanager_base_test_security.h" #include "network.h" #include "network_security_config.h" +#include "common_mock_net_conn_service.h" namespace OHOS { namespace NetManagerStandard { namespace { +using namespace testing; using namespace testing::ext; constexpr const char *TEST_IPV4_ADDR = "127.0.0.1"; @@ -68,6 +70,8 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); + + sptr mockNetConnService = sptr::MakeSptr(); }; void NetConnClientTest::SetUpTestCase() {} @@ -805,10 +809,14 @@ HWTEST_F(NetConnClientTest, GetAppNetTest001, TestSize.Level1) */ HWTEST_F(NetConnClientTest, RegisterNetConnCallback001, TestSize.Level1) { + EXPECT_CALL(*mockNetConnService, RegisterNetConnCallback(_, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*mockNetConnService, UnregisterNetConnCallback(_)).WillRepeatedly(Return(0)); NetManagerBaseAccessToken token; - sptr callback = new (std::nothrow) INetConnCallbackTest(); - int32_t ret = NetConnClient::GetInstance().RegisterNetConnCallback(callback); - ret = NetConnClient::GetInstance().UnregisterNetConnCallback(callback); + sptr callback = sptr::MakeSptr(); + auto netConnClient = std::make_shared(); + netConnClient->NetConnService_ = mockNetConnService; + int32_t ret = netConnClient->RegisterNetConnCallback(callback); + ret = netConnClient->UnregisterNetConnCallback(callback); EXPECT_EQ(ret, NETMANAGER_SUCCESS); } @@ -842,6 +850,28 @@ HWTEST_F(NetConnClientTest, RegisterNetConnCallback003, TestSize.Level1) EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR); } +/** + * @tc.name: RegisterNetConnCallback004 + * @tc.desc: Test NetConnClient::RegisterNetConnCallback, not applying for + * permission,return NETMANAGER_ERR_PERMISSION_DENIED + * @tc.type: FUNC + */ +HWTEST_F(NetConnClientTest, RegisterNetConnCallback004, TestSize.Level1) +{ + EXPECT_CALL(*mockNetConnService, RegisterNetConnCallback(_, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*mockNetConnService, UnregisterNetConnCallback(_)).WillRepeatedly(Return(0)); + auto netSpecifier = sptr::MakeSptr(); + netSpecifier->SetCapabilities({NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN}); + sptr callback = sptr::MakeSptr(); + uint32_t timesOut = 1; + auto netConnClient = std::make_shared(); + netConnClient->NetConnService_ = mockNetConnService; + auto ret = netConnClient->RegisterNetConnCallback(netSpecifier, callback, timesOut); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); + ret = netConnClient->RegisterNetConnCallback(netSpecifier, callback, timesOut); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); +} + /** * @tc.name: RegisterNetConnCallback001 * @tc.desc: Test NetConnClient::RegisterNetConnCallback, not applying for @@ -850,10 +880,18 @@ HWTEST_F(NetConnClientTest, RegisterNetConnCallback003, TestSize.Level1) */ HWTEST_F(NetConnClientTest, UnRegisterNetConnCallback001, TestSize.Level1) { - sptr callback = new (std::nothrow) INetConnCallbackTest(); - int32_t ret = NetConnClient::GetInstance().RegisterNetConnCallback(callback); - ret = NetConnClient::GetInstance().UnregisterNetConnCallback(callback); - EXPECT_EQ(ret, NETMANAGER_ERR_PERMISSION_DENIED); + EXPECT_CALL(*mockNetConnService, RegisterNetConnCallback(_, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*mockNetConnService, UnregisterNetConnCallback(_)).WillRepeatedly(Return(0)); + sptr callback1 = sptr::MakeSptr(); + sptr callback2 = sptr::MakeSptr(); + auto netConnClient = std::make_shared(); + netConnClient->NetConnService_ = mockNetConnService; + int32_t ret = netConnClient->UnregisterNetConnCallback(callback1); + ret = netConnClient->RegisterNetConnCallback(callback1); + ret = netConnClient->RegisterNetConnCallback(callback2); + ret = netConnClient->UnregisterNetConnCallback(callback1); + ret = netConnClient->UnregisterNetConnCallback(callback2); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); } /** @@ -864,14 +902,18 @@ HWTEST_F(NetConnClientTest, UnRegisterNetConnCallback001, TestSize.Level1) */ HWTEST_F(NetConnClientTest, RequestNetConnection001, TestSize.Level1) { + EXPECT_CALL(*mockNetConnService, RequestNetConnection(_, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*mockNetConnService, UnregisterNetConnCallback(_)).WillRepeatedly(Return(0)); NetManagerBaseAccessToken token; sptr netSpecifier = new (std::nothrow) NetSpecifier(); netSpecifier->netCapabilities_.bearerTypes_.emplace(NetManagerStandard::BEARER_CELLULAR); netSpecifier->netCapabilities_.netCaps_.emplace(NetManagerStandard::NET_CAPABILITY_INTERNAL_DEFAULT); sptr callback = new (std::nothrow) INetConnCallbackTest(); uint32_t timesOut = 0; - auto ret = NetConnClient::GetInstance().RequestNetConnection(netSpecifier, callback, timesOut); - ret = NetConnClient::GetInstance().UnregisterNetConnCallback(callback); + auto netConnClient = std::make_shared(); + netConnClient->NetConnService_ = mockNetConnService; + auto ret = netConnClient->RequestNetConnection(netSpecifier, callback, timesOut); + ret = netConnClient->UnregisterNetConnCallback(callback); EXPECT_EQ(ret, NETMANAGER_SUCCESS); } @@ -920,7 +962,29 @@ HWTEST_F(NetConnClientTest, RequestNetConnection004, TestSize.Level1) uint32_t timesOut = 0; auto ret = NetConnClient::GetInstance().RequestNetConnection(netSpecifier, callback, timesOut); ret = NetConnClient::GetInstance().UnregisterNetConnCallback(callback); - EXPECT_EQ(ret, NETMANAGER_ERR_PERMISSION_DENIED); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); +} + +/** + * @tc.name: RequestNetConnection005 + * @tc.desc: Test NetConnClient::RequestNetConnection, not applying for + * permission,return NETMANAGER_ERR_PERMISSION_DENIED + * @tc.type: FUNC + */ +HWTEST_F(NetConnClientTest, RequestNetConnection005, TestSize.Level1) +{ + EXPECT_CALL(*mockNetConnService, RequestNetConnection(_, _, _)).WillRepeatedly(Return(0)); + EXPECT_CALL(*mockNetConnService, UnregisterNetConnCallback(_)).WillRepeatedly(Return(0)); + auto netSpecifier = sptr::MakeSptr(); + netSpecifier->SetCapabilities({NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN}); + sptr callback = sptr::MakeSptr(); + uint32_t timesOut = 1; + auto netConnClient = std::make_shared(); + netConnClient->NetConnService_ = mockNetConnService; + auto ret = netConnClient->RequestNetConnection(netSpecifier, callback, timesOut); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); + ret = netConnClient->RequestNetConnection(netSpecifier, callback, timesOut); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); } /** @@ -1675,5 +1739,304 @@ HWTEST_F(NetConnClientTest, NetExtAttributeTest001, TestSize.Level1) ASSERT_EQ(ret, NETMANAGER_ERR_PERMISSION_DENIED); } +HWTEST_F(NetConnClientTest, RecoverCallbackAndGlobalProxy002, TestSize.Level1) +{ + auto netConnClient = std::make_shared(); + netConnClient->RecoverCallbackAndGlobalProxy(); + EXPECT_TRUE(netConnClient->globalHttpProxy_.GetHost().empty()); + EXPECT_EQ(netConnClient->preAirplaneCallback_, nullptr); +} + +HWTEST_F(NetConnClientTest, RecoverCallbackAndGlobalProxy003, TestSize.Level1) +{ + auto netConnClient = std::make_shared(); + HttpProxy httpProxy; + httpProxy.host_ = "127.0.0.1"; + netConnClient->SetGlobalHttpProxy(httpProxy); + netConnClient->RecoverCallbackAndGlobalProxy(); + EXPECT_FALSE(netConnClient->globalHttpProxy_.GetHost().empty()); + EXPECT_EQ(netConnClient->preAirplaneCallback_, nullptr); +} + +HWTEST_F(NetConnClientTest, RecoverCallbackAndGlobalProxy004, TestSize.Level1) +{ + auto netConnClient = std::make_shared(); + HttpProxy httpProxy; + httpProxy.host_ = "127.0.0.1"; + netConnClient->SetGlobalHttpProxy(httpProxy); + netConnClient->preAirplaneCallback_ = sptr::MakeSptr(); + netConnClient->RecoverCallbackAndGlobalProxy(); + EXPECT_FALSE(netConnClient->globalHttpProxy_.GetHost().empty()); +} + +HWTEST_F(NetConnClientTest, RecoverCallbackAndGlobalProxy005, TestSize.Level1) +{ + auto netConnClient = std::make_shared(); + netConnClient->preAirplaneCallback_ = sptr::MakeSptr(); + netConnClient->RecoverCallbackAndGlobalProxy(); + EXPECT_TRUE(netConnClient->globalHttpProxy_.GetHost().empty()); +} + +HWTEST_F(NetConnClientTest, RecoverCallbackAndGlobalProxy006, TestSize.Level1) +{ + auto netConnClient = std::make_shared(); + NetConnClient::NetConnCallbackManagerMap netConnCallbackManagerMap; + auto cb = sptr::MakeSptr(); + auto specifier1 = sptr::MakeSptr(); + specifier1->SetCapabilities({NET_CAPABILITY_INTERNET, NET_CAPABILITY_NOT_VPN}); + EXPECT_FALSE(specifier1->netCapabilities_.netCaps_.count(NetManagerStandard::NET_CAPABILITY_INTERNAL_DEFAULT) > 0); + netConnCallbackManagerMap.emplace(specifier1, cb); + auto specifier2 = sptr::MakeSptr(); + specifier2->SetCapabilities({NET_CAPABILITY_INTERNAL_DEFAULT, NET_CAPABILITY_NOT_VPN}); + EXPECT_TRUE(specifier2->netCapabilities_.netCaps_.count(NetManagerStandard::NET_CAPABILITY_INTERNAL_DEFAULT) > 0); + netConnCallbackManagerMap.emplace(specifier2, cb); + netConnClient->RecoverCallbackAndGlobalProxy(netConnCallbackManagerMap); + EXPECT_FALSE(netConnCallbackManagerMap.empty()); +} + +HWTEST_F(NetConnClientTest, NetAvailable001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetAvailable002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetCapabilitiesChange001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + auto netAllCap = sptr::MakeSptr(); + netConnCallbackManager->NetCapabilitiesChange(netHandle, netAllCap); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetCapabilitiesChange002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + auto netAllCap = sptr::MakeSptr(); + netConnCallbackManager->NetCapabilitiesChange(netHandle, netAllCap); + EXPECT_EQ(netHandle->GetNetId(), netConnCallbackManager->netHandle_->GetNetId()); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetCapabilitiesChange003, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + netConnCallbackManager->netHandle_ = sptr::MakeSptr(); + netConnCallbackManager->netHandle_->SetNetId(101); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + auto netAllCap = sptr::MakeSptr(); + netConnCallbackManager->NetCapabilitiesChange(netHandle, netAllCap); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetConnectionPropertiesChange001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + auto info = sptr::MakeSptr(); + netConnCallbackManager->NetConnectionPropertiesChange(netHandle, info); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetConnectionPropertiesChange002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + auto info = sptr::MakeSptr(); + netConnCallbackManager->NetConnectionPropertiesChange(netHandle, info); + EXPECT_EQ(netHandle->GetNetId(), netConnCallbackManager->netHandle_->GetNetId()); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetConnectionPropertiesChange003, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->netHandle_ = sptr::MakeSptr(); + netConnCallbackManager->netHandle_->SetNetId(101); + netConnCallbackManager->AddNetConnCallback(callback); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + auto info = sptr::MakeSptr(); + netConnCallbackManager->NetConnectionPropertiesChange(netHandle, info); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetLost001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + EXPECT_EQ(netConnCallbackManager->netHandle_, nullptr); + netConnCallbackManager->NetLost(netHandle); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetLost002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + EXPECT_NE(netConnCallbackManager->netHandle_, nullptr); + netConnCallbackManager->NetLost(netHandle); + EXPECT_EQ(netConnCallbackManager->netHandle_, nullptr); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetLost003, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->netHandle_ = sptr::MakeSptr(); + netConnCallbackManager->netHandle_->SetNetId(101); + netConnCallbackManager->AddNetConnCallback(callback); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + EXPECT_NE(netConnCallbackManager->netHandle_, nullptr); + netConnCallbackManager->NetLost(netHandle); + EXPECT_NE(netConnCallbackManager->netHandle_, nullptr); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetUnavailable001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + netConnCallbackManager->NetUnavailable(); + EXPECT_EQ(netConnCallbackManager->netHandle_, nullptr); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetUnavailable002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + netConnCallbackManager->NetUnavailable(); + EXPECT_EQ(netConnCallbackManager->netHandle_, nullptr); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetBlockStatusChange001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetBlockStatusChange(netHandle, true); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, NetBlockStatusChange002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetBlockStatusChange(netHandle, true); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + +HWTEST_F(NetConnClientTest, AddNetConnCallback001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + netConnCallbackManager->AddNetConnCallback(callback); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 1); + EXPECT_EQ(netConnCallbackManager->netHandle_, nullptr); +} + +HWTEST_F(NetConnClientTest, AddNetConnCallback002, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 1); + EXPECT_EQ(netConnCallbackManager->netHandle_, nullptr); +} + +HWTEST_F(NetConnClientTest, AddNetConnCallback003, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 1); + EXPECT_NE(netConnCallbackManager->netHandle_, nullptr); + EXPECT_EQ(netConnCallbackManager->netAllCap_, nullptr); + EXPECT_EQ(netConnCallbackManager->netLinkInfo_, nullptr); +} + +HWTEST_F(NetConnClientTest, AddNetConnCallback004, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + auto netAllCap = sptr::MakeSptr(); + netConnCallbackManager->NetCapabilitiesChange(netHandle, netAllCap); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 1); + EXPECT_NE(netConnCallbackManager->netHandle_, nullptr); + EXPECT_NE(netConnCallbackManager->netAllCap_, nullptr); + EXPECT_EQ(netConnCallbackManager->netLinkInfo_, nullptr); +} + +HWTEST_F(NetConnClientTest, AddNetConnCallback005, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + auto netHandle = sptr::MakeSptr(); + netHandle->SetNetId(100); + netConnCallbackManager->NetAvailable(netHandle); + auto netAllCap = sptr::MakeSptr(); + netConnCallbackManager->NetCapabilitiesChange(netHandle, netAllCap); + auto info = sptr::MakeSptr(); + netConnCallbackManager->NetConnectionPropertiesChange(netHandle, info); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 1); + EXPECT_NE(netConnCallbackManager->netHandle_, nullptr); + EXPECT_NE(netConnCallbackManager->netAllCap_, nullptr); + EXPECT_NE(netConnCallbackManager->netLinkInfo_, nullptr); +} + +HWTEST_F(NetConnClientTest, RemoveNetConnCallback001, TestSize.Level1) +{ + auto netConnCallbackManager = std::make_shared(); + sptr callback = sptr::MakeSptr(); + netConnCallbackManager->AddNetConnCallback(callback); + EXPECT_NE(netConnCallbackManager->netConnCallbackList_.size(), 0); + netConnCallbackManager->RemoveNetConnCallback(callback); + EXPECT_EQ(netConnCallbackManager->netConnCallbackList_.size(), 0); +} + } // namespace NetManagerStandard } // namespace OHOS diff --git a/test/netconnmanager/unittest/net_conn_service_regional_test/BUILD.gn b/test/netconnmanager/unittest/net_conn_service_regional_test/BUILD.gn index 320d8fb9a..ab01b0f24 100644 --- a/test/netconnmanager/unittest/net_conn_service_regional_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_conn_service_regional_test/BUILD.gn @@ -43,7 +43,7 @@ ohos_unittest("net_conn_service_regional_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netconnmanager/unittest/net_conn_service_test/BUILD.gn b/test/netconnmanager/unittest/net_conn_service_test/BUILD.gn index eb5b78a9a..498717960 100644 --- a/test/netconnmanager/unittest/net_conn_service_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_conn_service_test/BUILD.gn @@ -43,7 +43,7 @@ ohos_unittest("net_conn_service_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netconnclient:net_conn_parcel", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", diff --git a/test/netconnmanager/unittest/net_factoryreset_callback_test/BUILD.gn b/test/netconnmanager/unittest/net_factoryreset_callback_test/BUILD.gn index 5ab80690c..0ea660387 100644 --- a/test/netconnmanager/unittest/net_factoryreset_callback_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_factoryreset_callback_test/BUILD.gn @@ -48,7 +48,7 @@ ohos_unittest("net_factoryreset_callback_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netconnmanager/unittest/net_info_test/BUILD.gn b/test/netconnmanager/unittest/net_info_test/BUILD.gn index 2f1f43d7f..12425e845 100644 --- a/test/netconnmanager/unittest/net_info_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_info_test/BUILD.gn @@ -51,7 +51,7 @@ ohos_unittest("net_info_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netconnmanager/unittest/net_supplier_test/BUILD.gn b/test/netconnmanager/unittest/net_supplier_test/BUILD.gn index 25b362042..d3b6b9e04 100644 --- a/test/netconnmanager/unittest/net_supplier_test/BUILD.gn +++ b/test/netconnmanager/unittest/net_supplier_test/BUILD.gn @@ -51,7 +51,7 @@ ohos_unittest("net_supplier_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netconnmanager/unittest/netmgr_distributed_test/BUILD.gn b/test/netconnmanager/unittest/netmgr_distributed_test/BUILD.gn index 6d5eeb0e5..6d248953b 100644 --- a/test/netconnmanager/unittest/netmgr_distributed_test/BUILD.gn +++ b/test/netconnmanager/unittest/netmgr_distributed_test/BUILD.gn @@ -51,7 +51,7 @@ ohos_unittest("netmgr_distributed_test") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETCONNMANAGER_SOURCE_DIR:net_conn_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", diff --git a/test/netmanagernative/unittest/netsys_distributed_test/BUILD.gn b/test/netmanagernative/unittest/netsys_distributed_test/BUILD.gn index e4cbf718d..f3e480ad5 100644 --- a/test/netmanagernative/unittest/netsys_distributed_test/BUILD.gn +++ b/test/netmanagernative/unittest/netsys_distributed_test/BUILD.gn @@ -48,7 +48,7 @@ ohos_unittest("netsys_distributed_test") { deps = [ "$FWMARK_CLIENT_DIR:fwmark_client", - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$NETMANAGERNATIVE_ROOT:netsys_client", "$NETMANAGER_BASE_ROOT/services/netmanagernative:netsys_native_manager_static", "$NETMANAGER_BASE_ROOT/services/netmanagernative/bpf:netsys_bpf_utils", diff --git a/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn b/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn index 66c327d5e..a6a0d4261 100644 --- a/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn +++ b/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn @@ -75,7 +75,7 @@ ohos_unittest("netsys_native_manager_test") { "$NETMANAGER_BASE_ROOT/services/netmanagernative:netsys_native_manager_static", "$NETMANAGER_BASE_ROOT/services/netmanagernative/bpf:netsys_bpf_utils", "$NETMANAGER_BASE_ROOT/services/netsyscontroller:netsys_controller_static", - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netmanagernative:net_native_manager_if", ] @@ -349,7 +349,6 @@ ohos_unittest("netsys_native_client_test") { "$NETMANAGER_BASE_ROOT/services/netmanagernative/src/netsys", "$NETSYSCONTROLLER_ROOT_DIR/include", "$NETMANAGERNATIVE_ROOT/src/netsys/dnsresolv", - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", ] deps = [ @@ -424,7 +423,7 @@ ohos_unittest("netsys_native_service_proxy_test") { deps = [ "$FWMARK_CLIENT_DIR:fwmark_client", - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$NETMANAGERNATIVE_ROOT:netsys_client", "$NETMANAGER_BASE_ROOT/services/netmanagernative/bpf:netsys_bpf_utils", "$NETMANAGER_BASE_ROOT/services/netsyscontroller:netsys_controller_static", diff --git a/test/netpolicymanager/unittest/net_access_policy_database_test/BUILD.gn b/test/netpolicymanager/unittest/net_access_policy_database_test/BUILD.gn index 6379083df..561cd5cf3 100644 --- a/test/netpolicymanager/unittest/net_access_policy_database_test/BUILD.gn +++ b/test/netpolicymanager/unittest/net_access_policy_database_test/BUILD.gn @@ -64,7 +64,6 @@ ohos_unittest("net_access_policy_database_test") { "ffrt:libffrt", "hitrace:hitrace_meter", "ipc:ipc_core", - "netmanager_base:net_conn_manager_if", "netmanager_base:net_stats_manager_if", "relational_store:native_rdb", "safwk:system_ability_fwk", diff --git a/test/netpolicymanager/unittest/net_policy_manager_test/BUILD.gn b/test/netpolicymanager/unittest/net_policy_manager_test/BUILD.gn index afd656da0..83485908e 100644 --- a/test/netpolicymanager/unittest/net_policy_manager_test/BUILD.gn +++ b/test/netpolicymanager/unittest/net_policy_manager_test/BUILD.gn @@ -87,7 +87,6 @@ ohos_unittest("net_policy_manager_test") { "ffrt:libffrt", "hitrace:hitrace_meter", "ipc:ipc_core", - "netmanager_base:net_conn_manager_if", "netmanager_base:net_stats_manager_if", "relational_store:native_rdb", "safwk:system_ability_fwk", diff --git a/test/netpolicymanager/unittest/net_policy_service_nocfi_test/BUILD.gn b/test/netpolicymanager/unittest/net_policy_service_nocfi_test/BUILD.gn index 5bda87d8c..c5f639f2f 100644 --- a/test/netpolicymanager/unittest/net_policy_service_nocfi_test/BUILD.gn +++ b/test/netpolicymanager/unittest/net_policy_service_nocfi_test/BUILD.gn @@ -59,7 +59,6 @@ ohos_unittest("net_policy_service_nocfi_test") { "googletest:gmock_main", "hitrace:hitrace_meter", "ipc:ipc_core", - "netmanager_base:net_conn_manager_if", "netmanager_base:net_stats_manager_if", "relational_store:native_rdb", "safwk:system_ability_fwk", diff --git a/test/netpolicymanager/unittest/net_policy_service_test/BUILD.gn b/test/netpolicymanager/unittest/net_policy_service_test/BUILD.gn index d53363bba..17ab7e445 100644 --- a/test/netpolicymanager/unittest/net_policy_service_test/BUILD.gn +++ b/test/netpolicymanager/unittest/net_policy_service_test/BUILD.gn @@ -66,7 +66,6 @@ ohos_unittest("net_policy_service_test") { "googletest:gmock_main", "hitrace:hitrace_meter", "ipc:ipc_core", - "netmanager_base:net_conn_manager_if", "netmanager_base:net_stats_manager_if", "relational_store:native_rdb", "safwk:system_ability_fwk", diff --git a/test/netstatsmanager/unittest/net_stats_manager_test/BUILD.gn b/test/netstatsmanager/unittest/net_stats_manager_test/BUILD.gn index e6de1a46f..023c912d2 100644 --- a/test/netstatsmanager/unittest/net_stats_manager_test/BUILD.gn +++ b/test/netstatsmanager/unittest/net_stats_manager_test/BUILD.gn @@ -37,7 +37,7 @@ ohos_unittest("net_stats_mock_data") { ] deps = [ - "$INNERKITS_ROOT/netconnclient:net_conn_manager_if", + "$INNERKITS_ROOT/netconnclient:net_conn_manager_if_static", "$INNERKITS_ROOT/netstatsclient:net_stats_manager_if", "$NETMANAGER_BASE_ROOT/services/netstatsmanager:net_stats_manager_static", "$NETMANAGER_BASE_ROOT/utils:net_manager_common", -- Gitee