1 /*
2  * Copyright (C) 2022-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_exec.h"
17 
18 #include <cstdint>
19 #include <new>
20 #include <numeric>
21 #include <string>
22 
23 #include "mac_address_info.h"
24 #include "ethernet_client.h"
25 #include "napi_utils.h"
26 #include "net_manager_constants.h"
27 #include "netmanager_ext_log.h"
28 
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace EthernetExec {
32 namespace {
33 constexpr const char *MODE = "mode";
34 constexpr const char *IP_ADDR = "ipAddr";
35 constexpr const char *ROUTE = "route";
36 constexpr const char *NET_MASK = "netMask";
37 constexpr const char *GATEWAY = "gateway";
38 constexpr const char *DNS_SERVERS = "dnsServers";
39 constexpr const char *DOMAIN = "domain";
40 constexpr const char *DEFAULT_SEPARATOR = ",";
41 constexpr const char *MAC_ADDR = "macAddr";
42 constexpr const char *IFACE = "iface";
43 
AccumulateNetAddress(const std::vector<INetAddr> &netAddrList)44 std::string AccumulateNetAddress(const std::vector<INetAddr> &netAddrList)
45 {
46     return std::accumulate(
47         netAddrList.begin(), netAddrList.end(), std::string(), [](const std::string &addr, const INetAddr &iter) {
48             return addr.empty() ? (addr + iter.address_) : (addr + DEFAULT_SEPARATOR + iter.address_);
49         });
50 }
51 } // namespace
ExecGetMacAddress(GetMacAddressContext *context)52 bool ExecGetMacAddress(GetMacAddressContext *context)
53 {
54     int32_t result = DelayedSingleton<EthernetClient>::GetInstance()->GetMacAddress(context->macAddrInfo_);
55     if (result != NETMANAGER_EXT_SUCCESS) {
56         NETMANAGER_EXT_LOGE("ExecGetMacAddress error, errorCode: %{public}d", result);
57         context->SetErrorCode(result);
58         return false;
59     }
60     return true;
61 }
62 
GetMacAddressCallback(GetMacAddressContext *context)63 napi_value GetMacAddressCallback(GetMacAddressContext *context)
64 {
65     napi_value macAddressList = NapiUtils::CreateArray(context->GetEnv(), context->macAddrInfo_.size());
66     uint32_t index = 0;
67     for (auto &eachInfo : context->macAddrInfo_) {
68         napi_value macAddrInfo = NapiUtils::CreateObject(context->GetEnv());
69         NapiUtils::SetStringPropertyUtf8(
70             context->GetEnv(), macAddrInfo, IFACE, eachInfo.iface_);
71         NapiUtils::SetStringPropertyUtf8(
72             context->GetEnv(), macAddrInfo, MAC_ADDR, eachInfo.macAddress_);
73         NapiUtils::SetArrayElement(context->GetEnv(), macAddressList, index++, macAddrInfo);
74     }
75     return macAddressList;
76 }
77 
ExecGetIfaceConfig(GetIfaceConfigContext *context)78 bool ExecGetIfaceConfig(GetIfaceConfigContext *context)
79 {
80     int32_t result = DelayedSingleton<EthernetClient>::GetInstance()->GetIfaceConfig(context->iface_, context->config_);
81     if (context->config_ == nullptr || result != NETMANAGER_EXT_SUCCESS) {
82         NETMANAGER_EXT_LOGE("ExecGetIfaceConfig error, errorCode: %{public}d", result);
83         context->SetErrorCode(result);
84         return false;
85     }
86     return true;
87 }
88 
GetIfaceConfigCallback(GetIfaceConfigContext *context)89 napi_value GetIfaceConfigCallback(GetIfaceConfigContext *context)
90 {
91     napi_value interfaceConfiguration = NapiUtils::CreateObject(context->GetEnv());
92     NapiUtils::SetInt32Property(context->GetEnv(), interfaceConfiguration, MODE, context->config_->mode_);
93 
94     std::string ipAddresses = AccumulateNetAddress(context->config_->ipStatic_.ipAddrList_);
95     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), interfaceConfiguration, IP_ADDR, ipAddresses);
96 
97     std::string routeAddresses = AccumulateNetAddress(context->config_->ipStatic_.routeList_);
98     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), interfaceConfiguration, ROUTE, routeAddresses);
99 
100     std::string gatewayAddresses = AccumulateNetAddress(context->config_->ipStatic_.gatewayList_);
101     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), interfaceConfiguration, GATEWAY, gatewayAddresses);
102 
103     std::string maskAddresses = AccumulateNetAddress(context->config_->ipStatic_.netMaskList_);
104     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), interfaceConfiguration, NET_MASK, maskAddresses);
105 
106     std::string dnsServers = AccumulateNetAddress(context->config_->ipStatic_.dnsServers_);
107     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), interfaceConfiguration, DNS_SERVERS, dnsServers);
108 
109     NapiUtils::SetStringPropertyUtf8(context->GetEnv(), interfaceConfiguration, DOMAIN,
110                                      context->config_->ipStatic_.domain_);
111     return interfaceConfiguration;
112 }
113 
ExecSetIfaceConfig(SetIfaceConfigContext *context)114 bool ExecSetIfaceConfig(SetIfaceConfigContext *context)
115 {
116     int32_t result = DelayedSingleton<EthernetClient>::GetInstance()->SetIfaceConfig(context->iface_, context->config_);
117     if (result != NETMANAGER_EXT_SUCCESS) {
118         NETMANAGER_EXT_LOGE("ExecSetIfaceConfig error, errorCode: %{public}d", result);
119         context->SetErrorCode(result);
120         return false;
121     }
122     return true;
123 }
124 
SetIfaceConfigCallback(SetIfaceConfigContext *context)125 napi_value SetIfaceConfigCallback(SetIfaceConfigContext *context)
126 {
127     return NapiUtils::GetUndefined(context->GetEnv());
128 }
129 
ExecIsIfaceActive(IsIfaceActiveContext *context)130 bool ExecIsIfaceActive(IsIfaceActiveContext *context)
131 {
132     int32_t result =
133         DelayedSingleton<EthernetClient>::GetInstance()->IsIfaceActive(context->iface_, context->ifActivate_);
134     if (result != NETMANAGER_EXT_SUCCESS) {
135         context->SetErrorCode(result);
136         NETMANAGER_EXT_LOGE("ExecIsIfaceActive error, errorCode: %{public}d", result);
137         return false;
138     }
139     return true;
140 }
141 
IsIfaceActiveCallback(IsIfaceActiveContext *context)142 napi_value IsIfaceActiveCallback(IsIfaceActiveContext *context)
143 {
144     return NapiUtils::CreateInt32(context->GetEnv(), context->ifActivate_);
145 }
146 
ExecGetAllActiveIfaces(GetAllActiveIfacesContext *context)147 bool ExecGetAllActiveIfaces(GetAllActiveIfacesContext *context)
148 {
149     int32_t result = DelayedSingleton<EthernetClient>::GetInstance()->GetAllActiveIfaces(context->ethernetNameList_);
150     if (result != NETMANAGER_EXT_SUCCESS) {
151         context->SetErrorCode(result);
152         NETMANAGER_EXT_LOGE("ExecIsIfaceActive error, errorCode: %{public}d", result);
153         return false;
154     }
155     return true;
156 }
157 
GetAllActiveIfacesCallback(GetAllActiveIfacesContext *context)158 napi_value GetAllActiveIfacesCallback(GetAllActiveIfacesContext *context)
159 {
160     napi_value ifaces = NapiUtils::CreateArray(context->GetEnv(), context->ethernetNameList_.size());
161     uint32_t index = 0;
162     for (const auto &iface : context->ethernetNameList_) {
163         napi_value ifaceStr = NapiUtils::CreateStringUtf8(context->GetEnv(), iface);
164         NapiUtils::SetArrayElement(context->GetEnv(), ifaces, index++, ifaceStr);
165     }
166     return ifaces;
167 }
168 } // namespace EthernetExec
169 } // namespace NetManagerStandard
170 } // namespace OHOS
171