1 /*
2 * Copyright (c) 2021-2024 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 "ethernet_service.h"
17
18 #include <new>
19 #include <sys/time.h>
20
21 #include "ethernet_management.h"
22 #include "mac_address_info.h"
23 #include "interface_configuration.h"
24 #include "iremote_object.h"
25 #include "net_ethernet_base_service.h"
26 #include "net_manager_center.h"
27 #include "net_manager_constants.h"
28 #include "netmanager_base_permission.h"
29 #include "netmgr_ext_log_wrapper.h"
30 #include "netsys_controller.h"
31 #include "system_ability_definition.h"
32
33 namespace OHOS {
34 namespace NetManagerStandard {
35 namespace {
36 constexpr uint16_t DEPENDENT_SERVICE_NET_CONN_MANAGER = 0x0001;
37 constexpr uint16_t DEPENDENT_SERVICE_COMMON_EVENT = 0x0002;
38 constexpr uint16_t DEPENDENT_SERVICE_All = 0x0003;
39 constexpr const char *NET_ACTIVATE_WORK_THREAD = "POLICY_CALLBACK_WORK_THREAD";
40 const bool REGISTER_LOCAL_RESULT_ETH =
41 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<EthernetService>::GetInstance().get());
42 } // namespace
43
EthernetService()44 EthernetService::EthernetService() : SystemAbility(COMM_ETHERNET_MANAGER_SYS_ABILITY_ID, true) {}
45
46 EthernetService::~EthernetService() = default;
47
OnStart()48 void EthernetService::OnStart()
49 {
50 struct timeval tv;
51 gettimeofday(&tv, nullptr);
52 NETMGR_EXT_LOG_D("EthernetService::OnStart begin");
53 if (state_ == STATE_RUNNING) {
54 NETMGR_EXT_LOG_D("EthernetService the state is already running");
55 return;
56 }
57 if (!Init()) {
58 NETMGR_EXT_LOG_E("EthernetService init failed");
59 return;
60 }
61 state_ = STATE_RUNNING;
62 gettimeofday(&tv, nullptr);
63 NETMGR_EXT_LOG_D("EthernetService::OnStart end");
64 }
65
OnStop()66 void EthernetService::OnStop()
67 {
68 state_ = STATE_STOPPED;
69 registerToService_ = false;
70 ethernetServiceFfrtQueue_.reset();
71 }
72
Dump(int32_t fd,const std::vector<std::u16string> & args)73 int32_t EthernetService::Dump(int32_t fd, const std::vector<std::u16string> &args)
74 {
75 NETMGR_EXT_LOG_D("Start Dump, fd: %{public}d", fd);
76 std::string result;
77 ethManagement_.GetDumpInfo(result);
78 int32_t ret = dprintf(fd, "%s\n", result.c_str());
79 return ret < 0 ? NETMANAGER_EXT_ERR_LOCAL_PTR_NULL : NETMANAGER_EXT_SUCCESS;
80 }
81
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)82 void EthernetService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
83 {
84 switch (systemAbilityId) {
85 case COMM_NET_CONN_MANAGER_SYS_ABILITY_ID:
86 NETMGR_EXT_LOG_D("EthernetService::OnAddSystemAbility Conn");
87 dependentServiceState_ |= DEPENDENT_SERVICE_NET_CONN_MANAGER;
88 break;
89 case COMMON_EVENT_SERVICE_ID:
90 NETMGR_EXT_LOG_D("EthernetService::OnAddSystemAbility CES");
91 dependentServiceState_ |= DEPENDENT_SERVICE_COMMON_EVENT;
92 break;
93 default:
94 NETMGR_EXT_LOG_D("EthernetService::OnAddSystemAbility unhandled sysabilityId:%{public}d", systemAbilityId);
95 break;
96 }
97 if (dependentServiceState_ == DEPENDENT_SERVICE_All) {
98 InitManagement();
99 }
100 }
101
Init()102 bool EthernetService::Init()
103 {
104 if (!REGISTER_LOCAL_RESULT_ETH) {
105 NETMGR_EXT_LOG_E("EthernetService Register to local sa manager failed");
106 return false;
107 }
108 if (!registerToService_) {
109 if (!Publish(DelayedSingleton<EthernetService>::GetInstance().get())) {
110 NETMGR_EXT_LOG_E("EthernetService Register to sa manager failed");
111 return false;
112 }
113 registerToService_ = true;
114 }
115 AddSystemAbilityListener(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID);
116 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
117 interfaceStateCallback_ = new (std::nothrow) GlobalInterfaceStateCallback(*this);
118 if (interfaceStateCallback_ == nullptr) {
119 NETMGR_EXT_LOG_E("allInterfaceStateCallback_ is nullptr");
120 return false;
121 }
122 NetsysController::GetInstance().RegisterCallback(interfaceStateCallback_);
123 serviceComm_ = new (std::nothrow) EthernetServiceCommon();
124 if (serviceComm_ == nullptr) {
125 NETMGR_EXT_LOG_E("serviceComm_ is nullptr");
126 return false;
127 }
128 NetManagerCenter::GetInstance().RegisterEthernetService(serviceComm_);
129 ethernetServiceFfrtQueue_ = std::make_shared<ffrt::queue>("EthernetService");
130 return true;
131 }
132
InitManagement()133 void EthernetService::InitManagement()
134 {
135 NETMGR_EXT_LOG_D("EthernetService::InitManagement Enter");
136 ethManagement_.Init();
137 }
138
OnInterfaceAddressUpdated(const std::string & addr,const std::string & ifName,int flags,int scope)139 int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceAddressUpdated(const std::string &addr,
140 const std::string &ifName, int flags,
141 int scope)
142 {
143 return 0;
144 }
145
OnInterfaceAddressRemoved(const std::string & addr,const std::string & ifName,int flags,int scope)146 int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceAddressRemoved(const std::string &addr,
147 const std::string &ifName, int flags,
148 int scope)
149 {
150 return 0;
151 }
152
OnInterfaceAdded(const std::string & iface)153 int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceAdded(const std::string &iface)
154 {
155 NETMGR_EXT_LOG_D("iface: %{public}s, added", iface.c_str());
156 ethernetService_.NotifyMonitorIfaceCallbackAsync(
157 [=](const sptr<InterfaceStateCallback> &callback) { callback->OnInterfaceAdded(iface); });
158 return 0;
159 }
160
OnInterfaceRemoved(const std::string & iface)161 int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceRemoved(const std::string &iface)
162 {
163 NETMGR_EXT_LOG_D("iface: %{public}s, removed", iface.c_str());
164 ethernetService_.NotifyMonitorIfaceCallbackAsync(
165 [=](const sptr<InterfaceStateCallback> &callback) { callback->OnInterfaceRemoved(iface); });
166 return 0;
167 }
168
OnInterfaceChanged(const std::string & iface,bool up)169 int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceChanged(const std::string &iface, bool up)
170 {
171 return 0;
172 }
173
OnInterfaceLinkStateChanged(const std::string & ifName,bool up)174 int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceLinkStateChanged(const std::string &ifName, bool up)
175 {
176 NETMGR_EXT_LOG_D("iface: %{public}s, up: %{public}d", ifName.c_str(), up);
177 ethernetService_.NotifyMonitorIfaceCallbackAsync(
178 [=](const sptr<InterfaceStateCallback> &callback) { callback->OnInterfaceChanged(ifName, up); });
179 return 0;
180 }
181
OnRouteChanged(bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)182 int32_t EthernetService::GlobalInterfaceStateCallback::OnRouteChanged(bool updated, const std::string &route,
183 const std::string &gateway,
184 const std::string &ifName)
185 {
186 return 0;
187 }
188
OnDhcpSuccess(NetsysControllerCallback::DhcpResult & dhcpResult)189 int32_t EthernetService::GlobalInterfaceStateCallback::OnDhcpSuccess(NetsysControllerCallback::DhcpResult &dhcpResult)
190 {
191 return 0;
192 }
193
OnBandwidthReachedLimit(const std::string & limitName,const std::string & iface)194 int32_t EthernetService::GlobalInterfaceStateCallback::OnBandwidthReachedLimit(const std::string &limitName,
195 const std::string &iface)
196 {
197 return 0;
198 }
199
GetMacAddress(std::vector<MacAddressInfo> & macAddrList)200 int32_t EthernetService::GetMacAddress(std::vector<MacAddressInfo> &macAddrList)
201 {
202 if (!NetManagerPermission::CheckPermission(Permission::GET_ETHERNET_LOCAL_MAC)) {
203 NETMGR_EXT_LOG_E("EthernetService GetMacAddress no js permission");
204 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
205 }
206
207 return ethManagement_.GetMacAddress(macAddrList);
208 }
209
SetIfaceConfig(const std::string & iface,const sptr<InterfaceConfiguration> & ic)210 int32_t EthernetService::SetIfaceConfig(const std::string &iface, const sptr<InterfaceConfiguration> &ic)
211 {
212 NETMGR_EXT_LOG_D("Set iface: %{public}s config", iface.c_str());
213 if (!NetManagerPermission::IsSystemCaller()) {
214 NETMGR_EXT_LOG_E("Caller not have sys permission");
215 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
216 }
217 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
218 NETMGR_EXT_LOG_E("EthernetService SetIfaceConfig no js permission");
219 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
220 }
221
222 return ethManagement_.UpdateDevInterfaceCfg(iface, ic);
223 }
224
GetIfaceConfig(const std::string & iface,sptr<InterfaceConfiguration> & ifaceConfig)225 int32_t EthernetService::GetIfaceConfig(const std::string &iface, sptr<InterfaceConfiguration> &ifaceConfig)
226 {
227 NETMGR_EXT_LOG_D("Get iface: %{public}s config", iface.c_str());
228 if (!NetManagerPermission::IsSystemCaller()) {
229 NETMGR_EXT_LOG_E("Caller not have sys permission");
230 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
231 }
232 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
233 NETMGR_EXT_LOG_E("EthernetService GetIfaceConfig no js permission");
234 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
235 }
236
237 return ethManagement_.GetDevInterfaceCfg(iface, ifaceConfig);
238 }
239
IsIfaceActive(const std::string & iface,int32_t & activeStatus)240 int32_t EthernetService::IsIfaceActive(const std::string &iface, int32_t &activeStatus)
241 {
242 NETMGR_EXT_LOG_D("Get iface: %{public}s is active", iface.c_str());
243 if (!NetManagerPermission::IsSystemCaller()) {
244 NETMGR_EXT_LOG_E("Caller not have sys permission");
245 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
246 }
247 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
248 NETMGR_EXT_LOG_E("EthernetService IsIfaceActive no js permission");
249 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
250 }
251
252 return ethManagement_.IsIfaceActive(iface, activeStatus);
253 }
254
GetAllActiveIfaces(std::vector<std::string> & activeIfaces)255 int32_t EthernetService::GetAllActiveIfaces(std::vector<std::string> &activeIfaces)
256 {
257 if (!NetManagerPermission::IsSystemCaller()) {
258 NETMGR_EXT_LOG_E("Caller not have sys permission");
259 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
260 }
261 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
262 NETMGR_EXT_LOG_E("EthernetService GetAllActiveIfaces no js permission");
263 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
264 }
265
266 return ethManagement_.GetAllActiveIfaces(activeIfaces);
267 }
268
ResetFactory()269 int32_t EthernetService::ResetFactory()
270 {
271 if (!NetManagerPermission::IsSystemCaller()) {
272 NETMGR_EXT_LOG_E("Caller not have sys permission");
273 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
274 }
275 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
276 NETMGR_EXT_LOG_E("EthernetService GetAllActiveIfaces no js permission");
277 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
278 }
279
280 return ethManagement_.ResetFactory();
281 }
282
RegisterIfacesStateChanged(const sptr<InterfaceStateCallback> & callback)283 int32_t EthernetService::RegisterIfacesStateChanged(const sptr<InterfaceStateCallback> &callback)
284 {
285 if (callback == nullptr) {
286 NETMGR_EXT_LOG_E("Register interface callback failed");
287 return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
288 }
289 if (!NetManagerPermission::IsSystemCaller()) {
290 NETMGR_EXT_LOG_E("Caller not have sys permission");
291 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
292 }
293 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
294 NETMGR_EXT_LOG_E("RegisterIfacesStateChanged no permission");
295 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
296 }
297 return RegisterMonitorIfaceCallbackAsync(callback);
298 }
299
UnregisterIfacesStateChanged(const sptr<InterfaceStateCallback> & callback)300 int32_t EthernetService::UnregisterIfacesStateChanged(const sptr<InterfaceStateCallback> &callback)
301 {
302 if (callback == nullptr) {
303 NETMGR_EXT_LOG_E("Unregister interface callback failed");
304 return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
305 }
306 if (!NetManagerPermission::IsSystemCaller()) {
307 NETMGR_EXT_LOG_E("Caller not have sys permission");
308 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
309 }
310 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
311 NETMGR_EXT_LOG_E("RegisterIfacesStateChanged no permission");
312 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
313 }
314 return UnregisterMonitorIfaceCallbackAsync(callback);
315 }
316
SetInterfaceUp(const std::string & iface)317 int32_t EthernetService::SetInterfaceUp(const std::string &iface)
318 {
319 if (!NetManagerPermission::IsSystemCaller()) {
320 NETMGR_EXT_LOG_E("SetInterfaceUp Caller no sys permission");
321 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
322 }
323 NETMGR_EXT_LOG_D("Set interface: %{public}s up", iface.c_str());
324 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
325 NETMGR_EXT_LOG_E("EthernetService SetInterfaceUp no permission");
326 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
327 }
328 return NetsysController::GetInstance().SetInterfaceUp(iface);
329 }
330
SetInterfaceDown(const std::string & iface)331 int32_t EthernetService::SetInterfaceDown(const std::string &iface)
332 {
333 if (!NetManagerPermission::IsSystemCaller()) {
334 NETMGR_EXT_LOG_E("SetInterfaceDown Caller no sys permission");
335 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
336 }
337 NETMGR_EXT_LOG_D("Set interface: %{public}s down", iface.c_str());
338 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
339 NETMGR_EXT_LOG_E("EthernetService SetInterfaceDown no permission");
340 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
341 }
342 return NetsysController::GetInstance().SetInterfaceDown(iface);
343 }
344
GetInterfaceConfig(const std::string & iface,ConfigurationParcelIpc & cfgIpc)345 int32_t EthernetService::GetInterfaceConfig(const std::string &iface, ConfigurationParcelIpc &cfgIpc)
346 {
347 if (!NetManagerPermission::IsSystemCaller()) {
348 NETMGR_EXT_LOG_E("GetInterfaceConfig Caller no sys permission");
349 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
350 }
351 NETMGR_EXT_LOG_D("Get interface: %{public}s config", iface.c_str());
352 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
353 NETMGR_EXT_LOG_E("EthernetService GetInterfaceConfig no permission");
354 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
355 }
356 OHOS::nmd::InterfaceConfigurationParcel config;
357 config.ifName = iface;
358 int32_t ret = NetsysController::GetInstance().GetInterfaceConfig(config);
359 ConfigurationParcelIpc::ConvertNmdToEtherConfigParcel(cfgIpc, config);
360 return ret;
361 }
362
SetInterfaceConfig(const std::string & iface,const ConfigurationParcelIpc & cfgIpc)363 int32_t EthernetService::SetInterfaceConfig(const std::string &iface, const ConfigurationParcelIpc &cfgIpc)
364 {
365 if (!NetManagerPermission::IsSystemCaller()) {
366 NETMGR_EXT_LOG_E("SetInterfaceConfig Caller no sys permission");
367 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
368 }
369 NETMGR_EXT_LOG_D("Set interface: %{public}s config", iface.c_str());
370 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
371 NETMGR_EXT_LOG_E("EthernetService SetInterfaceConfig no permission");
372 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
373 }
374 OHOS::nmd::InterfaceConfigurationParcel config;
375 ConfigurationParcelIpc::ConvertEtherConfigParcelToNmd(cfgIpc, config);
376 config.ifName = iface;
377 return NetsysController::GetInstance().SetInterfaceConfig(config);
378 }
379
RegisterMonitorIfaceCallbackAsync(const sptr<InterfaceStateCallback> & callback)380 int32_t EthernetService::RegisterMonitorIfaceCallbackAsync(const sptr<InterfaceStateCallback> &callback)
381 {
382 int32_t ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
383 if (!ethernetServiceFfrtQueue_) {
384 NETMGR_EXT_LOG_E("FFRT Init Fail");
385 return ret;
386 }
387 ffrt::task_handle RegisterMonitorIfaceTask = ethernetServiceFfrtQueue_->submit_h([this, &callback, &ret]() {
388 for (auto iterCb = monitorIfaceCallbacks_.begin(); iterCb != monitorIfaceCallbacks_.end(); iterCb++) {
389 if ((*iterCb)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) {
390 NETMGR_EXT_LOG_D("Register interface callback failed, callback already exists");
391 ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
392 return;
393 }
394 }
395 monitorIfaceCallbacks_.push_back(callback);
396 NETMGR_EXT_LOG_D("Register interface callback success");
397 ret = NETMANAGER_EXT_SUCCESS;
398 }, ffrt::task_attr().name("RegisterMonitorIfaceCallbackAsync"));
399 ethernetServiceFfrtQueue_->wait(RegisterMonitorIfaceTask);
400 return ret;
401 }
402
UnregisterMonitorIfaceCallbackAsync(const sptr<InterfaceStateCallback> & callback)403 int32_t EthernetService::UnregisterMonitorIfaceCallbackAsync(const sptr<InterfaceStateCallback> &callback)
404 {
405 int32_t ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
406 if (!ethernetServiceFfrtQueue_) {
407 NETMGR_EXT_LOG_E("FFRT Init Fail");
408 return ret;
409 }
410 ffrt::task_handle UnregisterMonitorIfaceTask = ethernetServiceFfrtQueue_->submit_h([this, &callback, &ret]() {
411 for (auto iterCb = monitorIfaceCallbacks_.begin(); iterCb != monitorIfaceCallbacks_.end(); iterCb++) {
412 if ((*iterCb)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) {
413 monitorIfaceCallbacks_.erase(iterCb);
414 NETMGR_EXT_LOG_D("Unregister interface callback success.");
415 ret = NETMANAGER_EXT_SUCCESS;
416 return;
417 }
418 }
419 NETMGR_EXT_LOG_E("Unregister interface callback is doesnot exist.");
420 ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
421 }, ffrt::task_attr().name("UnregisterMonitorIfaceCallbackAsync"));
422 ethernetServiceFfrtQueue_->wait(UnregisterMonitorIfaceTask);
423 return ret;
424 }
425
NotifyMonitorIfaceCallbackAsync(OnFunctionT onFunction)426 void EthernetService::NotifyMonitorIfaceCallbackAsync(OnFunctionT onFunction)
427 {
428 if (!ethernetServiceFfrtQueue_) {
429 NETMGR_EXT_LOG_E("FFRT Init Fail");
430 return;
431 }
432 ffrt::task_handle NotifyMonitorIfaceTask_ = ethernetServiceFfrtQueue_->submit_h([this, &onFunction]() {
433 std::for_each(monitorIfaceCallbacks_.begin(), monitorIfaceCallbacks_.end(), onFunction);
434 }, ffrt::task_attr().name("NotifyMonitorIfaceCallbackAsync"));
435 ethernetServiceFfrtQueue_->wait(NotifyMonitorIfaceTask_);
436 }
437
RegCustomEapHandler(int netType,const std::string & regCmd,const sptr<INetEapPostbackCallback> & callback)438 int32_t EthernetService::RegCustomEapHandler(int netType, const std::string ®Cmd,
439 const sptr<INetEapPostbackCallback> &callback)
440 {
441 NETMGR_EXT_LOG_D("Enter RegCustomEapHandler");
442 if (!NetManagerPermission::CheckPermission(Permission::MANAGE_ENTERPRISE_WIFI_CONNECTION)) {
443 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
444 return EAP_ERRCODE_PERMISSION_DENIED;
445 }
446 return NetEapHandler::GetInstance().RegCustomEapHandler(static_cast<NetType>(netType), regCmd, callback);
447 }
448
ReplyCustomEapData(int eapResult,const sptr<EapData> & eapData)449 int32_t EthernetService::ReplyCustomEapData(int eapResult, const sptr<EapData> &eapData)
450 {
451 NETMGR_EXT_LOG_D("Enter ReplyCustomEapData");
452 if (!NetManagerPermission::CheckPermission(Permission::MANAGE_ENTERPRISE_WIFI_CONNECTION)) {
453 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
454 return EAP_ERRCODE_PERMISSION_DENIED;
455 }
456 return NetEapHandler::GetInstance().ReplyCustomEapData(eapResult, eapData);
457 }
458
RegisterCustomEapCallback(int netType,const sptr<INetRegisterEapCallback> & callback)459 int32_t EthernetService::RegisterCustomEapCallback(int netType, const sptr<INetRegisterEapCallback> &callback)
460 {
461 NETMGR_EXT_LOG_D("Enter RegisterCustomEapCallback");
462 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
463 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
464 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
465 }
466 return NetEapHandler::GetInstance().RegisterCustomEapCallback(static_cast<NetType>(netType), callback);
467 }
468
UnRegisterCustomEapCallback(int netType,const sptr<INetRegisterEapCallback> & callback)469 int32_t EthernetService::UnRegisterCustomEapCallback(int netType,
470 const sptr<INetRegisterEapCallback> &callback)
471 {
472 NETMGR_EXT_LOG_D("Enter UnRegisterCustomEapCallback");
473 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
474 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
475 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
476 }
477 return NetEapHandler::GetInstance().UnRegisterCustomEapCallback(static_cast<NetType>(netType), callback);
478 }
479
NotifyWpaEapInterceptInfo(int netType,const sptr<EapData> & eapData)480 int32_t EthernetService::NotifyWpaEapInterceptInfo(int netType, const sptr<EapData> &eapData)
481 {
482 NETMGR_EXT_LOG_D("Enter NotifyWpaEapInterceptInfo");
483 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
484 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
485 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
486 }
487 return NetEapHandler::GetInstance().NotifyWpaEapInterceptInfo(static_cast<NetType>(netType), eapData);
488 }
489
GetDeviceInformation(std::vector<EthernetDeviceInfo> & deviceInfoList)490 int32_t EthernetService::GetDeviceInformation(std::vector<EthernetDeviceInfo> &deviceInfoList)
491 {
492 if (!NetManagerPermission::IsSystemCaller()) {
493 NETMGR_EXT_LOG_E("GetDeviceInformation Caller no sys permission");
494 return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
495 }
496 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
497 NETMGR_EXT_LOG_E("GetDeviceInformation no js permission");
498 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
499 }
500 return ethManagement_.GetDeviceInformation(deviceInfoList);
501 }
502
StartEthEap(int32_t netId,const EthEapProfile & profile)503 int32_t EthernetService::StartEthEap(int32_t netId, const EthEapProfile& profile)
504 {
505 if (!NetManagerPermission::CheckPermission(Permission::MANAGE_ENTERPRISE_WIFI_CONNECTION)) {
506 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
507 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
508 }
509 #ifdef NET_EXTENSIBLE_AUTHENTICATION
510 return NetEapHandler::GetInstance().StartEthEap(netId, profile);
511 #endif
512 return NETMANAGER_SUCCESS;
513 }
514
LogOffEthEap(int32_t netId)515 int32_t EthernetService::LogOffEthEap(int32_t netId)
516 {
517 if (!NetManagerPermission::CheckPermission(Permission::MANAGE_ENTERPRISE_WIFI_CONNECTION)) {
518 NETMGR_EXT_LOG_E("%{public}s no permission.", __func__);
519 return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
520 }
521 #ifdef NET_EXTENSIBLE_AUTHENTICATION
522 return NetEapHandler::GetInstance().LogOffEthEap(netId);
523 #endif
524 return NETMANAGER_SUCCESS;
525 }
526
527 } // namespace NetManagerStandard
528 } // namespace OHOS
529