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
33namespace OHOS {
34namespace NetManagerStandard {
35namespace {
36constexpr uint16_t DEPENDENT_SERVICE_NET_CONN_MANAGER = 0x0001;
37constexpr uint16_t DEPENDENT_SERVICE_COMMON_EVENT = 0x0002;
38constexpr uint16_t DEPENDENT_SERVICE_All = 0x0003;
39constexpr const char *NET_ACTIVATE_WORK_THREAD = "POLICY_CALLBACK_WORK_THREAD";
40const bool REGISTER_LOCAL_RESULT_ETH =
41    SystemAbility::MakeAndRegisterAbility(DelayedSingleton<EthernetService>::GetInstance().get());
42} // namespace
43
44EthernetService::EthernetService() : SystemAbility(COMM_ETHERNET_MANAGER_SYS_ABILITY_ID, true) {}
45
46EthernetService::~EthernetService() = default;
47
48void 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
66void EthernetService::OnStop()
67{
68    state_ = STATE_STOPPED;
69    registerToService_ = false;
70    ethernetServiceFfrtQueue_.reset();
71}
72
73int32_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
82void 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
102bool 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
133void EthernetService::InitManagement()
134{
135    NETMGR_EXT_LOG_D("EthernetService::InitManagement Enter");
136    ethManagement_.Init();
137}
138
139int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceAddressUpdated(const std::string &addr,
140                                                                                 const std::string &ifName, int flags,
141                                                                                 int scope)
142{
143    return 0;
144}
145
146int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceAddressRemoved(const std::string &addr,
147                                                                                 const std::string &ifName, int flags,
148                                                                                 int scope)
149{
150    return 0;
151}
152
153int32_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
161int32_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
169int32_t EthernetService::GlobalInterfaceStateCallback::OnInterfaceChanged(const std::string &iface, bool up)
170{
171    return 0;
172}
173
174int32_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
182int32_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
189int32_t EthernetService::GlobalInterfaceStateCallback::OnDhcpSuccess(NetsysControllerCallback::DhcpResult &dhcpResult)
190{
191    return 0;
192}
193
194int32_t EthernetService::GlobalInterfaceStateCallback::OnBandwidthReachedLimit(const std::string &limitName,
195                                                                               const std::string &iface)
196{
197    return 0;
198}
199
200int32_t EthernetService::GetMacAddress(std::vector<MacAddressInfo> &macAddrList)
201{
202    if (!NetManagerPermission::IsSystemCaller()) {
203        NETMGR_EXT_LOG_E("Caller not have sys permission");
204        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
205    }
206    if (!NetManagerPermission::CheckPermission(Permission::GET_ETHERNET_LOCAL_MAC)) {
207        NETMGR_EXT_LOG_E("EthernetService GetMacAddress no js permission");
208        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
209    }
210
211    return ethManagement_.GetMacAddress(macAddrList);
212}
213
214int32_t EthernetService::SetIfaceConfig(const std::string &iface, sptr<InterfaceConfiguration> &ic)
215{
216    NETMGR_EXT_LOG_D("Set iface: %{public}s config", iface.c_str());
217    if (!NetManagerPermission::IsSystemCaller()) {
218        NETMGR_EXT_LOG_E("Caller not have sys permission");
219        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
220    }
221    if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
222        NETMGR_EXT_LOG_E("EthernetService SetIfaceConfig no js permission");
223        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
224    }
225
226    return ethManagement_.UpdateDevInterfaceCfg(iface, ic);
227}
228
229int32_t EthernetService::GetIfaceConfig(const std::string &iface, sptr<InterfaceConfiguration> &ifaceConfig)
230{
231    NETMGR_EXT_LOG_D("Get iface: %{public}s config", iface.c_str());
232    if (!NetManagerPermission::IsSystemCaller()) {
233        NETMGR_EXT_LOG_E("Caller not have sys permission");
234        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
235    }
236    if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
237        NETMGR_EXT_LOG_E("EthernetService GetIfaceConfig no js permission");
238        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
239    }
240
241    return ethManagement_.GetDevInterfaceCfg(iface, ifaceConfig);
242}
243
244int32_t EthernetService::IsIfaceActive(const std::string &iface, int32_t &activeStatus)
245{
246    NETMGR_EXT_LOG_D("Get iface: %{public}s is active", iface.c_str());
247    if (!NetManagerPermission::IsSystemCaller()) {
248        NETMGR_EXT_LOG_E("Caller not have sys permission");
249        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
250    }
251    if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
252        NETMGR_EXT_LOG_E("EthernetService IsIfaceActive no js permission");
253        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
254    }
255
256    return ethManagement_.IsIfaceActive(iface, activeStatus);
257}
258
259int32_t EthernetService::GetAllActiveIfaces(std::vector<std::string> &activeIfaces)
260{
261    if (!NetManagerPermission::IsSystemCaller()) {
262        NETMGR_EXT_LOG_E("Caller not have sys permission");
263        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
264    }
265    if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
266        NETMGR_EXT_LOG_E("EthernetService GetAllActiveIfaces no js permission");
267        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
268    }
269
270    return ethManagement_.GetAllActiveIfaces(activeIfaces);
271}
272
273int32_t EthernetService::ResetFactory()
274{
275    if (!NetManagerPermission::IsSystemCaller()) {
276        NETMGR_EXT_LOG_E("Caller not have sys permission");
277        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
278    }
279    if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
280        NETMGR_EXT_LOG_E("EthernetService GetAllActiveIfaces no js permission");
281        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
282    }
283
284    return ethManagement_.ResetFactory();
285}
286
287int32_t EthernetService::RegisterIfacesStateChanged(const sptr<InterfaceStateCallback> &callback)
288{
289    if (callback == nullptr) {
290        NETMGR_EXT_LOG_E("Register interface callback failed");
291        return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
292    }
293    if (!NetManagerPermission::IsSystemCaller()) {
294        NETMGR_EXT_LOG_E("Caller not have sys permission");
295        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
296    }
297    if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
298        NETMGR_EXT_LOG_E("RegisterIfacesStateChanged no permission");
299        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
300    }
301    return RegisterMonitorIfaceCallbackAsync(callback);
302}
303
304int32_t EthernetService::UnregisterIfacesStateChanged(const sptr<InterfaceStateCallback> &callback)
305{
306    if (callback == nullptr) {
307        NETMGR_EXT_LOG_E("Unregister interface callback failed");
308        return NETMANAGER_EXT_ERR_PARAMETER_ERROR;
309    }
310    if (!NetManagerPermission::IsSystemCaller()) {
311        NETMGR_EXT_LOG_E("Caller not have sys permission");
312        return NETMANAGER_EXT_ERR_NOT_SYSTEM_CALL;
313    }
314    if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
315        NETMGR_EXT_LOG_E("RegisterIfacesStateChanged no permission");
316        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
317    }
318    return UnregisterMonitorIfaceCallbackAsync(callback);
319}
320
321int32_t EthernetService::SetInterfaceUp(const std::string &iface)
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
331int32_t EthernetService::SetInterfaceDown(const std::string &iface)
332{
333    NETMGR_EXT_LOG_D("Set interface: %{public}s down", iface.c_str());
334    if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
335        NETMGR_EXT_LOG_E("EthernetService SetInterfaceDown no permission");
336        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
337    }
338    return NetsysController::GetInstance().SetInterfaceDown(iface);
339}
340
341int32_t EthernetService::GetInterfaceConfig(const std::string &iface, OHOS::nmd::InterfaceConfigurationParcel &config)
342{
343    NETMGR_EXT_LOG_D("Get interface: %{public}s config", iface.c_str());
344    if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
345        NETMGR_EXT_LOG_E("EthernetService GetInterfaceConfig no permission");
346        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
347    }
348    config.ifName = iface;
349    return NetsysController::GetInstance().GetInterfaceConfig(config);
350}
351
352int32_t EthernetService::SetInterfaceConfig(const std::string &iface, OHOS::nmd::InterfaceConfigurationParcel &cfg)
353{
354    NETMGR_EXT_LOG_D("Set interface: %{public}s config", iface.c_str());
355    if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
356        NETMGR_EXT_LOG_E("EthernetService SetInterfaceConfig no permission");
357        return NETMANAGER_EXT_ERR_PERMISSION_DENIED;
358    }
359    cfg.ifName = iface;
360    return NetsysController::GetInstance().SetInterfaceConfig(cfg);
361}
362
363int32_t EthernetService::RegisterMonitorIfaceCallbackAsync(const sptr<InterfaceStateCallback> &callback)
364{
365    int32_t ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
366    if (!ethernetServiceFfrtQueue_) {
367        NETMGR_EXT_LOG_E("FFRT Init Fail");
368        return ret;
369    }
370    ffrt::task_handle RegisterMonitorIfaceTask = ethernetServiceFfrtQueue_->submit_h([this, &callback, &ret]() {
371        for (auto iterCb = monitorIfaceCallbacks_.begin(); iterCb != monitorIfaceCallbacks_.end(); iterCb++) {
372            if ((*iterCb)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) {
373                NETMGR_EXT_LOG_D("Register interface callback failed, callback already exists");
374                ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
375                return;
376            }
377        }
378        monitorIfaceCallbacks_.push_back(callback);
379        NETMGR_EXT_LOG_D("Register interface callback success");
380        ret = NETMANAGER_EXT_SUCCESS;
381    }, ffrt::task_attr().name("RegisterMonitorIfaceCallbackAsync"));
382    ethernetServiceFfrtQueue_->wait(RegisterMonitorIfaceTask);
383    return ret;
384}
385
386int32_t EthernetService::UnregisterMonitorIfaceCallbackAsync(const sptr<InterfaceStateCallback> &callback)
387{
388    int32_t ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
389    if (!ethernetServiceFfrtQueue_) {
390        NETMGR_EXT_LOG_E("FFRT Init Fail");
391        return ret;
392    }
393    ffrt::task_handle UnregisterMonitorIfaceTask = ethernetServiceFfrtQueue_->submit_h([this, &callback, &ret]() {
394        for (auto iterCb = monitorIfaceCallbacks_.begin(); iterCb != monitorIfaceCallbacks_.end(); iterCb++) {
395            if ((*iterCb)->AsObject().GetRefPtr() == callback->AsObject().GetRefPtr()) {
396                monitorIfaceCallbacks_.erase(iterCb);
397                NETMGR_EXT_LOG_D("Unregister interface callback success.");
398                ret = NETMANAGER_EXT_SUCCESS;
399                return;
400            }
401        }
402            NETMGR_EXT_LOG_E("Unregister interface callback is doesnot exist.");
403            ret = NETMANAGER_EXT_ERR_OPERATION_FAILED;
404    }, ffrt::task_attr().name("UnregisterMonitorIfaceCallbackAsync"));
405    ethernetServiceFfrtQueue_->wait(UnregisterMonitorIfaceTask);
406    return ret;
407}
408
409void EthernetService::NotifyMonitorIfaceCallbackAsync(OnFunctionT onFunction)
410{
411    if (!ethernetServiceFfrtQueue_) {
412        NETMGR_EXT_LOG_E("FFRT Init Fail");
413        return;
414    }
415    ffrt::task_handle NotifyMonitorIfaceTask_ = ethernetServiceFfrtQueue_->submit_h([this, &onFunction]() {
416        std::for_each(monitorIfaceCallbacks_.begin(), monitorIfaceCallbacks_.end(), onFunction);
417    }, ffrt::task_attr().name("NotifyMonitorIfaceCallbackAsync"));
418    ethernetServiceFfrtQueue_->wait(NotifyMonitorIfaceTask_);
419}
420} // namespace NetManagerStandard
421} // namespace OHOS
422