diff --git a/frameworks/native/netconnclient/src/net_conn_client.cpp b/frameworks/native/netconnclient/src/net_conn_client.cpp index 09e8329541a208c09f1978ff475a4394123b50b1..61608a8bc948937d04cfc15d1c98b93b08f0007e 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 fc0835176a8d6edc6bdd747144428b60c9f60658..0e7e699bf9cd56167580d2896f8d4236fe9cc2c2 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,72 @@ 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", + "ipc:ipc_single", + ] + + 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 58505675366950f355ae242223f0bc74344d62bb..92df6798f32f68d4aa6a88ce4871d852847a7c62 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 b311747749d0c8e8b9b803b7ee45957b7c67334d..d5f793ae9f6106e816ca7157b34e96a1c5fdd0d5 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 17a6bb7a38c2fef192f254d3c4ddb772271a306c..0d0a33c7c6f5befe189684b15f9bfc189c6d1f1c 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 4a87357e6be2ae7bba7ed4860380f9ae92a32d27..ca40f77914e9a7f43530bb51773c3bf8a18730db 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 434e7cb88458250f61f5a0c29579e7b073f836ab..36cd38b9d87e45d79025708542c18f8e85c7c598 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 ae090b9ee0c06a48d2721c8d2f0ea6421b6b508f..6136ee002bad2cd593a414cfb37ea4e767490bb9 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 a7bc72b48afb281ceca87da569dd3d2114bdcafd..d004b83d0eb88bd252c2c2097fbdebf92cd9c534 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 fdcc16c34a2c1373a688c830cb603123be32d89c..9b648991f657287e970d91fcd0bbef4de02f8401 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/unittest/net_conn_manager_test/BUILD.gn b/test/netconnmanager/unittest/net_conn_manager_test/BUILD.gn index dfe05d4ab128e3bd34ef2a6a02257f0fd88c8ec6..e5b7e8594dc557af79448c253d1a7269854e7991 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 c4aeed59d419a4712d4269bbcd51832807ad2c6d..81dcb7bbf795e1fb7d5018b7de872eecdb92c624 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 57ad620bf1a206883e2b517bb5272d785f0aecb0..1273bcf2d02c71c42aa8db583cb97442ca187d63 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 320d8fb9a28adde29448951e13a7c3c26733a7b4..ab01b0f2406938d4ba3bd1f233a7a7694c99944f 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 eb5b78a9a845d975c59b0cc94dcf6fb87fd0d2e0..498717960030f8546f74f70eecfdfeb92adbecd8 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 5ab80690c618c856c404b5772d52f46c371cf089..0ea660387b1dc7aba6a1809526085c6ba4f0091e 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 2f1f43d7fb87b7980455a53e3c650f2e5536d558..12425e8456ce00e3130d93997242040c5f69ae7f 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 25b3620421275a90baa1eafcad077932cfa3bf44..d3b6b9e04689e0ef3cde670c3f06b5cb0e02f82b 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 6d5eeb0e57d314fe97abd3339235c27f7c9f5a4d..6d248953b11befe2ca31dfa5032ccd7cc1a67c56 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 e4cbf718d5d400d154a02d96dba3d41650bf527e..f3e480ad5989b534edcd60f5e4898468de5bff01 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 66c327d5ea17ee698ad0654c8b20b8ca8d100a00..a6a0d426166cf5546740628de844bf5e67859907 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 6379083dfe0cbfefc4a6fd3d79806299e4f806d0..561cd5cf36995f12d666d4483d8b1738e3af66d2 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 afd656da0481a7aa6b01dab45387d2fbe72385a3..83485908e6f688ec9c1ff41ab197934983a4a48e 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 5bda87d8c86eb7422fd9329be4bb129268082dd2..c5f639f2fb1c040bfcd05d52d3376848f01ad7a1 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 d53363bba1865d117024226c9cbd23a65a8c3f48..17ab7e445c8e4338f3347eb5291c016a574aa09d 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 e6de1a46fc11ed0fed9729ecc4b42b55e0eb41d9..023c912d291c26edeeeaf70ec1f80dfaa2d13bea 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",