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