1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "net_connect_adapter_impl.h"
17
18 #include "cellular_data_client.h"
19 #include "core_service_client.h"
20 #include "net_connect_utils.h"
21 #include "net_link_info.h"
22 #include "nweb_log.h"
23
24 namespace OHOS::NWeb {
25
26 namespace {
27 const int32_t DEFAULT_VALUE = -1;
28 const int32_t BEARER_VPN = 4;
29 }
30
NetVPNEventSubscriber(EventFwk::CommonEventSubscribeInfo & in,std::shared_ptr<VpnListener> cb)31 NetVPNEventSubscriber::NetVPNEventSubscriber(
32 EventFwk::CommonEventSubscribeInfo& in,
33 std::shared_ptr<VpnListener> cb)
34 : EventFwk::CommonEventSubscriber(in),
35 cb_(cb)
36 {}
37
OnReceiveEvent(const EventFwk::CommonEventData & data)38 void NetVPNEventSubscriber::OnReceiveEvent(const EventFwk::CommonEventData& data)
39 {
40 const std::string action = data.GetWant().GetAction();
41 if (action != EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE) {
42 WVLOG_I("receive other action %{public}s", action.c_str());
43 return;
44 }
45
46 int32_t code = data.GetCode();
47 int32_t netType = data.GetWant().GetIntParam("NetType", DEFAULT_VALUE);
48
49 WVLOG_I("receive COMMON_EVENT_CONNECTIVITY_CHANGE type: %{public}d code: %{public}d", netType, code);
50 if (netType == DEFAULT_VALUE) {
51 WVLOG_E("net vpn default net type");
52 return;
53 }
54
55 if (netType != BEARER_VPN) {
56 return;
57 }
58
59 if (!cb_) {
60 WVLOG_E("net vpn listener is not set");
61 return;
62 }
63
64 if (code == NetManagerStandard::NetConnState::NET_CONN_STATE_CONNECTED) {
65 WVLOG_I("vpn is available");
66 cb_->OnAvailable();
67 return;
68 }
69
70 if (code == NetManagerStandard::NetConnState::NET_CONN_STATE_DISCONNECTED) {
71 WVLOG_I("vpn is lost");
72 cb_->OnLost();
73 return;
74 }
75 }
76
RegisterVpnListener(std::shared_ptr<VpnListener> cb)77 void NetConnectAdapterImpl::RegisterVpnListener(std::shared_ptr<VpnListener> cb)
78 {
79 if (commonEventSubscriber_) {
80 WVLOG_I("start vpn listen, common event subscriber has registered");
81 return;
82 }
83
84 if (!cb) {
85 WVLOG_E("start vpn listen, register vpn listener failed cb is nullptr");
86 return;
87 }
88
89 EventFwk::MatchingSkills skill = EventFwk::MatchingSkills();
90 skill.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CONNECTIVITY_CHANGE);
91 EventFwk::CommonEventSubscribeInfo info(skill);
92 info.SetPriority(1); //The higher the value, the higher the priority
93 commonEventSubscriber_ = std::make_shared<NetVPNEventSubscriber>(info, cb);
94 if (!commonEventSubscriber_) {
95 WVLOG_E("start vpn listen, common event subscriber is null");
96 return;
97 }
98
99 bool ret = EventFwk::CommonEventManager::SubscribeCommonEvent(commonEventSubscriber_);
100 if (ret == false) {
101 WVLOG_E("start vpn listen, subscribe common event failed");
102 }
103
104 if (HasVpnTransport()) {
105 WVLOG_I("has vpn transport, vpn is available");
106 cb->OnAvailable();
107 }
108 }
109
HasVpnTransport()110 bool NetConnectAdapterImpl::HasVpnTransport()
111 {
112 std::list<sptr<NetManagerStandard::NetHandle>> netHandleList;
113 int32_t ret = NetConnClient::GetInstance().GetAllNets(netHandleList);
114 if (ret != NETMANAGER_SUCCESS) {
115 WVLOG_E("get all nets failed, ret = %{public}d.", ret);
116 return false;
117 }
118
119 for (sptr<NetManagerStandard::NetHandle> netHandle : netHandleList) {
120 NetManagerStandard::NetAllCapabilities netAllCap;
121 NetConnClient::GetInstance().GetNetCapabilities(*netHandle, netAllCap);
122 if (netAllCap.bearerTypes_.count(NetManagerStandard::BEARER_VPN) > 0) {
123 return true;
124 }
125 }
126 return false;
127 }
128
UnRegisterVpnListener()129 void NetConnectAdapterImpl::UnRegisterVpnListener()
130 {
131 if (commonEventSubscriber_) {
132 commonEventSubscriber_ = nullptr;
133 }
134 }
135
RegisterNetConnCallback(std::shared_ptr<NetConnCallback> cb)136 int32_t NetConnectAdapterImpl::RegisterNetConnCallback(std::shared_ptr<NetConnCallback> cb)
137 {
138 static int32_t count = 0;
139 if (cb == nullptr) {
140 WVLOG_E("register NetConnCallback, cb is nullptr.");
141 return -1;
142 }
143
144 sptr<NetConnectCallbackImpl> callbackImpl = new (std::nothrow) NetConnectCallbackImpl(cb);
145 if (callbackImpl == nullptr) {
146 WVLOG_E("new NetConnectCallbackImpl failed.");
147 return -1;
148 }
149
150 int32_t ret = NetConnClient::GetInstance().RegisterNetConnCallback(callbackImpl);
151 if (ret != NETMANAGER_SUCCESS) {
152 WVLOG_E("register NetConnCallback failed, ret = %{public}d.", ret);
153 return -1;
154 }
155
156 int32_t id = count++;
157 if (count < 0) {
158 count = 0;
159 }
160
161 netConnCallbackMap_.insert(std::make_pair(id, callbackImpl));
162 WVLOG_I("register NetConnCallback success.");
163 return id;
164 }
165
UnregisterNetConnCallback(int32_t id)166 int32_t NetConnectAdapterImpl::UnregisterNetConnCallback(int32_t id)
167 {
168 auto it = netConnCallbackMap_.find(id);
169 if (it == netConnCallbackMap_.end()) {
170 WVLOG_E("unregister NetConnCallback, not find the NetConnCallback.");
171 return -1;
172 }
173
174 int32_t ret = NetConnClient::GetInstance().UnregisterNetConnCallback(it->second);
175 if (ret != NETMANAGER_SUCCESS) {
176 WVLOG_E("unregister NetConnCallback failed, ret = %{public}d.", ret);
177 return -1;
178 }
179
180 netConnCallbackMap_.erase(it);
181 WVLOG_I("uregister NetConnCallback success.");
182 return 0;
183 }
184
GetDefaultNetConnect(NetConnectType & type,NetConnectSubtype & subtype)185 int32_t NetConnectAdapterImpl::GetDefaultNetConnect(NetConnectType &type, NetConnectSubtype &subtype)
186 {
187 NetHandle netHandle;
188 int32_t ret = NetConnClient::GetInstance().GetDefaultNet(netHandle);
189 if (ret != NETMANAGER_SUCCESS) {
190 WVLOG_E("get default net failed, ret = %{public}d.", ret);
191 return -1;
192 }
193 WVLOG_I("get default net success, net id = %{public}d.", netHandle.GetNetId());
194
195 NetAllCapabilities netAllCap;
196 ret = NetConnClient::GetInstance().GetNetCapabilities(netHandle, netAllCap);
197 if (ret != NETMANAGER_SUCCESS) {
198 WVLOG_E("get default net capbilities failed, ret = %{public}d.", ret);
199 return -1;
200 }
201 WVLOG_I("get default net capbilities success");
202
203 subtype = NetConnectSubtype::SUBTYPE_UNKNOWN;
204 RadioTech radioTech = RadioTech::RADIO_TECHNOLOGY_UNKNOWN;
205 for (auto bearerTypes : netAllCap.bearerTypes_) {
206 if (bearerTypes == BEARER_CELLULAR) {
207 int32_t slotId = CellularDataClient::GetInstance().GetDefaultCellularDataSlotId();
208 if (slotId < 0) {
209 WVLOG_E("get default soltId failed, ret = %{public}d.", slotId);
210 slotId = 0;
211 }
212 sptr<NetworkState> networkState = nullptr;
213 CoreServiceClient::GetInstance().GetNetworkState(slotId, networkState);
214 if (networkState != nullptr) {
215 radioTech = networkState->GetPsRadioTech();
216 WVLOG_I("net radio tech = %{public}d.", static_cast<int32_t>(radioTech));
217 subtype = NetConnectUtils::ConvertToConnectsubtype(radioTech);
218 }
219 }
220 type = NetConnectUtils::ConvertToConnectType(bearerTypes, radioTech);
221 WVLOG_I("net connect type = %{public}s.", NetConnectUtils::ConnectTypeToString(type).c_str());
222 break;
223 }
224 WVLOG_D("NetAllCapabilities dump, %{public}s.", netAllCap.ToString("").c_str());
225 return 0;
226 }
227
GetDnsServersInternal(const NetHandle & netHandle)228 std::vector<std::string> NetConnectAdapterImpl::GetDnsServersInternal(const NetHandle &netHandle) {
229 std::vector<std::string> servers;
230 NetLinkInfo info;
231 int32_t ret = NetConnClient::GetInstance().GetConnectionProperties(netHandle, info);
232 if (ret != NETMANAGER_SUCCESS) {
233 WVLOG_E("get net properties failed, ret = %{public}d.", ret);
234 return servers;
235 }
236 WVLOG_D("get net properties for dns servers success, net id = %{public}d, "
237 "netinfo = %{public}s.", netHandle.GetNetId(), info.ToString(" ").c_str());
238
239 for (const auto &dns : info.dnsList_) {
240 servers.emplace_back(dns.address_);
241 }
242 WVLOG_I("get dns servers success, net id = %{public}d, servers size = %{public}d.",
243 netHandle.GetNetId(), static_cast<int32_t>(servers.size()));
244 return servers;
245 }
246
GetDnsServers()247 std::vector<std::string> NetConnectAdapterImpl::GetDnsServers()
248 {
249 NetHandle netHandle;
250 int32_t ret = NetConnClient::GetInstance().GetDefaultNet(netHandle);
251 if (ret != NETMANAGER_SUCCESS) {
252 WVLOG_E("get default net for dns servers failed, ret = %{public}d.", ret);
253 return std::vector<std::string>();
254 }
255
256 return GetDnsServersInternal(netHandle);
257 }
258
GetDnsServersForVpn()259 std::vector<std::string> NetConnectAdapterImpl::GetDnsServersForVpn()
260 {
261 std::list<sptr<NetManagerStandard::NetHandle>> netHandleList;
262 int32_t ret = NetConnClient::GetInstance().GetAllNets(netHandleList);
263 if (ret != NETMANAGER_SUCCESS) {
264 WVLOG_E("get all nets by net id for dns servers failed, ret = %{public}d.", ret);
265 return std::vector<std::string>();
266 }
267
268 for (sptr<NetManagerStandard::NetHandle> netHandle : netHandleList) {
269 NetManagerStandard::NetAllCapabilities netAllCap;
270 NetConnClient::GetInstance().GetNetCapabilities(*netHandle, netAllCap);
271 if (netAllCap.bearerTypes_.count(NetManagerStandard::BEARER_VPN) > 0) {
272 WVLOG_I("get dns for vpn");
273 return GetDnsServersInternal(*netHandle);
274 }
275 }
276 return std::vector<std::string>();
277 }
278
GetDnsServersByNetId(int32_t netId)279 std::vector<std::string> NetConnectAdapterImpl::GetDnsServersByNetId(int32_t netId)
280 {
281 WVLOG_I("get dns servers by net id %{public}d.", netId);
282 if (netId == -1) {
283 return GetDnsServers();
284 }
285
286 std::list<sptr<NetManagerStandard::NetHandle>> netHandleList;
287 int32_t ret = NetConnClient::GetInstance().GetAllNets(netHandleList);
288 if (ret != NETMANAGER_SUCCESS) {
289 WVLOG_E("get all nets by net id for dns servers failed, ret = %{public}d.", ret);
290 return std::vector<std::string>();
291 }
292
293 for (sptr<NetManagerStandard::NetHandle> netHandle : netHandleList) {
294 if (netHandle->GetNetId() == netId) {
295 return GetDnsServersInternal(*netHandle);
296 }
297 }
298 return std::vector<std::string>();
299 }
300
301 } // namespace OHOS::NWeb
302