• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-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 #include "network_manager_addon.h"
16 
17 #include "edm_constants.h"
18 #include "edm_ipc_interface_code.h"
19 #include "edm_log.h"
20 #include "iptables_utils.h"
21 #include "os_account_manager.h"
22 
23 using namespace OHOS::EDM;
24 using namespace OHOS::EDM::IPTABLES;
25 
26 #ifdef NETMANAGER_BASE_EDM_ENABLE
27 const char *const HOST_PROP_NAME = "host";
28 const char *const PORT_PROP_NAME = "port";
29 const char *const PROXY_USER_NAME = "username";
30 const char *const PROXY_PASSWORD = "password";
31 const char *const EXCLUSION_LIST_PROP_NAME = "exclusionList";
32 #endif
33 
CreateFirewallActionObject(napi_env env,napi_value value)34 void NetworkManagerAddon::CreateFirewallActionObject(napi_env env, napi_value value)
35 {
36     napi_value nAllow;
37     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::ALLOW), &nAllow));
38     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALLOW", nAllow));
39     napi_value nDeny;
40     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::DENY), &nDeny));
41     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DENY", nDeny));
42     napi_value nReject;
43     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::REJECT), &nReject));
44     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "REJECT", nReject));
45 }
46 
CreateFirewallProtocolObject(napi_env env,napi_value value)47 void NetworkManagerAddon::CreateFirewallProtocolObject(napi_env env, napi_value value)
48 {
49     napi_value nAll;
50     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ALL), &nAll));
51     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALL", nAll));
52     napi_value nTCP;
53     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::TCP), &nTCP));
54     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TCP", nTCP));
55     napi_value nUDP;
56     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::UDP), &nUDP));
57     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UDP", nUDP));
58     napi_value nICMP;
59     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ICMP), &nICMP));
60     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ICMP", nICMP));
61 }
62 
CreateFirewallDirectionObject(napi_env env,napi_value value)63 void NetworkManagerAddon::CreateFirewallDirectionObject(napi_env env, napi_value value)
64 {
65     napi_value nInput;
66     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::INPUT), &nInput));
67     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INPUT", nInput));
68     napi_value nOutput;
69     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::OUTPUT), &nOutput));
70     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "OUTPUT", nOutput));
71     napi_value nForward;
72     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::FORWARD), &nForward));
73     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "FORWARD", nForward));
74 }
75 
CreateFirewallAddMethodObject(napi_env env,napi_value value)76 void NetworkManagerAddon::CreateFirewallAddMethodObject(napi_env env, napi_value value)
77 {
78     napi_value nAppend;
79     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::APPEND), &nAppend));
80     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "APPEND", nAppend));
81     napi_value nInsert;
82     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::INSERT), &nInsert));
83     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INSERT", nInsert));
84 }
85 
Init(napi_env env,napi_value exports)86 napi_value NetworkManagerAddon::Init(napi_env env, napi_value exports)
87 {
88     napi_value nFirewallAction = nullptr;
89     NAPI_CALL(env, napi_create_object(env, &nFirewallAction));
90     CreateFirewallActionObject(env, nFirewallAction);
91 
92     napi_value nFirewallProtocol = nullptr;
93     NAPI_CALL(env, napi_create_object(env, &nFirewallProtocol));
94     CreateFirewallProtocolObject(env, nFirewallProtocol);
95 
96     napi_value nFirewallDirection = nullptr;
97     NAPI_CALL(env, napi_create_object(env, &nFirewallDirection));
98     CreateFirewallDirectionObject(env, nFirewallDirection);
99 
100     napi_value nFirewallAddMethod = nullptr;
101     NAPI_CALL(env, napi_create_object(env, &nFirewallAddMethod));
102     CreateFirewallAddMethodObject(env, nFirewallAddMethod);
103 
104     napi_property_descriptor property[] = {
105         DECLARE_NAPI_FUNCTION("getAllNetworkInterfaces", GetAllNetworkInterfaces),
106         DECLARE_NAPI_FUNCTION("getIpAddress", GetIpAddress),
107         DECLARE_NAPI_FUNCTION("getMac", GetMac),
108         DECLARE_NAPI_FUNCTION("setNetworkInterfaceDisabled", SetNetworkInterfaceDisabled),
109         DECLARE_NAPI_FUNCTION("isNetworkInterfaceDisabled", IsNetworkInterfaceDisabled),
110 
111         DECLARE_NAPI_PROPERTY("Action", nFirewallAction),
112         DECLARE_NAPI_PROPERTY("Protocol", nFirewallProtocol),
113         DECLARE_NAPI_PROPERTY("Direction", nFirewallDirection),
114         DECLARE_NAPI_PROPERTY("AddMethod", nFirewallAddMethod),
115         DECLARE_NAPI_FUNCTION("addIptablesFilterRule", AddIptablesFilterRule),
116         DECLARE_NAPI_FUNCTION("removeIptablesFilterRule", RemoveIptablesFilterRule),
117         DECLARE_NAPI_FUNCTION("listIptablesFilterRules", ListIptablesFilterRules),
118 
119         DECLARE_NAPI_FUNCTION("addFirewallRule", AddFirewallRule),
120         DECLARE_NAPI_FUNCTION("removeFirewallRule", RemoveFirewallRule),
121         DECLARE_NAPI_FUNCTION("getFirewallRules", GetFirewallRules),
122 
123         DECLARE_NAPI_FUNCTION("addDomainFilterRule", AddDomainFilterRule),
124         DECLARE_NAPI_FUNCTION("removeDomainFilterRule", RemoveDomainFilterRule),
125         DECLARE_NAPI_FUNCTION("getDomainFilterRules", GetDomainFilterRules),
126 
127         DECLARE_NAPI_FUNCTION("setGlobalProxy", SetGlobalHttpProxy),
128         DECLARE_NAPI_FUNCTION("getGlobalProxy", GetGlobalHttpProxy),
129 
130         DECLARE_NAPI_FUNCTION("getAllNetworkInterfacesSync", GetAllNetworkInterfacesSync),
131         DECLARE_NAPI_FUNCTION("getIpAddressSync", GetIpAddressSync),
132         DECLARE_NAPI_FUNCTION("getMacSync", GetMacSync),
133         DECLARE_NAPI_FUNCTION("setNetworkInterfaceDisabledSync", SetNetworkInterfaceDisabledSync),
134         DECLARE_NAPI_FUNCTION("isNetworkInterfaceDisabledSync", IsNetworkInterfaceDisabledSync),
135         DECLARE_NAPI_FUNCTION("setGlobalProxySync", SetGlobalHttpProxySync),
136         DECLARE_NAPI_FUNCTION("getGlobalProxySync", GetGlobalHttpProxySync),
137         DECLARE_NAPI_FUNCTION("setGlobalProxyForAccount", SetGlobalHttpProxyForAccountSync),
138         DECLARE_NAPI_FUNCTION("getGlobalProxyForAccount", GetGlobalHttpProxyForAccountSync),
139     };
140     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
141     return exports;
142 }
143 
GetAllNetworkInterfaces(napi_env env,napi_callback_info info)144 napi_value NetworkManagerAddon::GetAllNetworkInterfaces(napi_env env, napi_callback_info info)
145 {
146     AddonMethodSign addonMethodSign;
147     addonMethodSign.name = "GetAllNetworkInterfaces";
148     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
149     addonMethodSign.methodAttribute = MethodAttribute::GET;
150     addonMethodSign.apiVersionTag = EdmConstants::PERMISSION_TAG_VERSION_11;
151     return AddonMethodAdapter(env, info, addonMethodSign, NativeGetAllNetworkInterfaces,
152         NativeArrayStringCallbackComplete);
153 }
154 
NativeGetAllNetworkInterfaces(napi_env env,void * data)155 void NetworkManagerAddon::NativeGetAllNetworkInterfaces(napi_env env, void *data)
156 {
157     EDMLOGI("NAPI_NativeGetAllNetworkInterfaces called");
158     if (data == nullptr) {
159         EDMLOGE("data is nullptr");
160         return;
161     }
162     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
163     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
164     if (networkManagerProxy == nullptr) {
165         EDMLOGE("can not get GetNetworkManagerProxy");
166         return;
167     }
168     asyncCallbackInfo->ret = networkManagerProxy->GetAllNetworkInterfaces(asyncCallbackInfo->data,
169         asyncCallbackInfo->arrayStringRet);
170 }
171 
GetIpOrMacAddressCommon(AddonMethodSign & addonMethodSign,const std::string & apiVersionTag,int32_t policyCode)172 void NetworkManagerAddon::GetIpOrMacAddressCommon(AddonMethodSign &addonMethodSign, const std::string &apiVersionTag,
173     int32_t policyCode)
174 {
175     addonMethodSign.name = "GetIpOrMacAddress";
176     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING};
177     addonMethodSign.methodAttribute = MethodAttribute::GET;
178     addonMethodSign.apiVersionTag = apiVersionTag;
179     addonMethodSign.policyCode = policyCode;
180 }
181 
GetIpAddress(napi_env env,napi_callback_info info)182 napi_value NetworkManagerAddon::GetIpAddress(napi_env env, napi_callback_info info)
183 {
184     EDMLOGI("NetworkManagerAddon::GetIpAddress called");
185     return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_IP_ADDRESS);
186 }
187 
GetMac(napi_env env,napi_callback_info info)188 napi_value NetworkManagerAddon::GetMac(napi_env env, napi_callback_info info)
189 {
190     EDMLOGI("NetworkManagerAddon::GetMac called");
191     return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_MAC);
192 }
193 
GetIpOrMacAddress(napi_env env,napi_callback_info info,int policyCode)194 napi_value NetworkManagerAddon::GetIpOrMacAddress(napi_env env, napi_callback_info info, int policyCode)
195 {
196     AddonMethodSign addonMethodSign;
197     GetIpOrMacAddressCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_11, policyCode);
198     return AddonMethodAdapter(env, info, addonMethodSign, NativeGetIpOrMacAddress, NativeStringCallbackComplete);
199 }
200 
NativeGetIpOrMacAddress(napi_env env,void * data)201 void NetworkManagerAddon::NativeGetIpOrMacAddress(napi_env env, void *data)
202 {
203     EDMLOGI("NAPI_NativeGetIpOrMacAddress called");
204     if (data == nullptr) {
205         EDMLOGE("data is nullptr");
206         return;
207     }
208     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
209     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
210     if (networkManagerProxy == nullptr) {
211         EDMLOGE("can not get GetNetworkManagerProxy");
212         return;
213     }
214     asyncCallbackInfo->ret = networkManagerProxy->GetIpOrMacAddress(asyncCallbackInfo->data,
215         asyncCallbackInfo->policyCode, asyncCallbackInfo->stringRet);
216 }
217 
IsNetworkInterfaceDisabledCommon(AddonMethodSign & addonMethodSign,const std::string & apiVersionTag)218 void NetworkManagerAddon::IsNetworkInterfaceDisabledCommon(AddonMethodSign &addonMethodSign,
219     const std::string &apiVersionTag)
220 {
221     addonMethodSign.name = "IsNetworkInterfaceDisabled";
222     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING};
223     addonMethodSign.methodAttribute = MethodAttribute::GET;
224     addonMethodSign.apiVersionTag = apiVersionTag;
225 }
226 
SetNetworkInterfaceDisabledCommon(AddonMethodSign & addonMethodSign,const std::string & apiVersionTag)227 void NetworkManagerAddon::SetNetworkInterfaceDisabledCommon(AddonMethodSign &addonMethodSign,
228     const std::string &apiVersionTag)
229 {
230     auto convertNetworkInterface2Data = [](napi_env env, napi_value argv, MessageParcel &data,
231         const AddonMethodSign &methodSign) {
232         std::string networkInterface;
233         bool isUint = ParseString(env, networkInterface, argv);
234         if (!isUint) {
235             return false;
236         }
237         std::vector<std::string> key{networkInterface};
238         data.WriteStringVector(key);
239         return true;
240     };
241     auto convertBoolean2Data = [](napi_env env, napi_value argv, MessageParcel &data,
242         const AddonMethodSign &methodSign) {
243         bool isDisabled;
244         bool isUint = ParseBool(env, isDisabled, argv);
245         if (!isUint) {
246             return false;
247         }
248         std::vector<std::string> value{isDisabled ? "true" : "false"};
249         data.WriteStringVector(value);
250         return true;
251     };
252     addonMethodSign.name = "SetNetworkInterfaceDisabled";
253     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING, EdmAddonCommonType::BOOLEAN};
254     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
255     addonMethodSign.apiVersionTag = apiVersionTag;
256     addonMethodSign.argsConvert = {nullptr, convertNetworkInterface2Data, convertBoolean2Data};
257 }
258 
SetNetworkInterfaceDisabled(napi_env env,napi_callback_info info)259 napi_value NetworkManagerAddon::SetNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
260 {
261     AddonMethodSign addonMethodSign;
262     SetNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_11);
263     return AddonMethodAdapter(env, info, addonMethodSign, NativeSetNetworkInterfaceDisabled,
264         NativeVoidCallbackComplete);
265 }
266 
NativeSetNetworkInterfaceDisabled(napi_env env,void * data)267 void NetworkManagerAddon::NativeSetNetworkInterfaceDisabled(napi_env env, void *data)
268 {
269     EDMLOGI("NAPI_NativeSetNetworkInterfaceDisabled called");
270     if (data == nullptr) {
271         EDMLOGE("data is nullptr");
272         return;
273     }
274     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
275     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
276     if (networkManagerProxy == nullptr) {
277         EDMLOGE("can not get GetNetworkManagerProxy");
278         return;
279     }
280     asyncCallbackInfo->ret = networkManagerProxy->SetNetworkInterfaceDisabled(asyncCallbackInfo->data);
281 }
282 
IsNetworkInterfaceDisabled(napi_env env,napi_callback_info info)283 napi_value NetworkManagerAddon::IsNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
284 {
285     AddonMethodSign addonMethodSign;
286     IsNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_11);
287     return AddonMethodAdapter(env, info, addonMethodSign, NativeIsNetworkInterfaceDisabled,
288         NativeBoolCallbackComplete);
289 }
290 
NativeIsNetworkInterfaceDisabled(napi_env env,void * data)291 void NetworkManagerAddon::NativeIsNetworkInterfaceDisabled(napi_env env, void *data)
292 {
293     EDMLOGI("NAPI_NativeIsNetworkInterfaceDisabled called");
294     if (data == nullptr) {
295         EDMLOGE("data is nullptr");
296         return;
297     }
298     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
299     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
300     if (networkManagerProxy == nullptr) {
301         EDMLOGE("can not get GetNetworkManagerProxy");
302         return;
303     }
304     asyncCallbackInfo->ret = networkManagerProxy->IsNetworkInterfaceDisabled(asyncCallbackInfo->data,
305         asyncCallbackInfo->boolRet);
306 }
307 
AddIptablesFilterRule(napi_env env,napi_callback_info info)308 napi_value NetworkManagerAddon::AddIptablesFilterRule(napi_env env, napi_callback_info info)
309 {
310     EDMLOGI("NetworkManagerAddon::AddIptablesFilterRule called");
311     auto convertAddFilter2Data = [](napi_env env, napi_value argv, MessageParcel &data,
312         const AddonMethodSign &methodSign) {
313         IPTABLES::AddFilter filter;
314         bool isUint = JsObjToAddFirewallObject(env, argv, filter);
315         if (!isUint) {
316             return false;
317         }
318         IPTABLES::IptablesUtils::WriteAddFilterConfig(filter, data);
319         return true;
320     };
321     AddonMethodSign addonMethodSign;
322     addonMethodSign.name = "AddIptablesFilterRule";
323     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
324     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
325     addonMethodSign.argsConvert = {nullptr, convertAddFilter2Data};
326     return AddonMethodAdapter(env, info, addonMethodSign, NativeAddIptalbsFilterRule,
327         NativeVoidCallbackComplete);
328 }
329 
JsObjToAddFirewallObject(napi_env env,napi_value object,IPTABLES::AddFilter & filter)330 bool NetworkManagerAddon::JsObjToAddFirewallObject(napi_env env, napi_value object, IPTABLES::AddFilter &filter)
331 {
332     JsObjectToUint(env, object, "ruleNo", false, filter.ruleNo);
333     JsObjectToString(env, object, "srcAddr", false, filter.srcAddr);
334     JsObjectToString(env, object, "destAddr", false, filter.destAddr);
335     JsObjectToString(env, object, "srcPort", false, filter.srcPort);
336     JsObjectToString(env, object, "destPort", false, filter.destPort);
337     JsObjectToString(env, object, "uid", false, filter.uid);
338     int32_t method = -1;
339     if (!JsObjectToInt(env, object, "method", true, method) ||
340         !IPTABLES::IptablesUtils::ProcessFirewallMethod(method, filter.method)) {
341         EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject method trans failed");
342         return false;
343     }
344     int32_t direction = -1;
345     if (!JsObjectToInt(env, object, "direction", true, direction) ||
346         !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, filter.direction)) {
347         EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject direction trans failed");
348         return false;
349     }
350     int32_t action = -1;
351     if (!JsObjectToInt(env, object, "action", true, action) ||
352         !IPTABLES::IptablesUtils::ProcessFirewallAction(action, filter.action)) {
353         EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject action trans failed");
354         return false;
355     }
356     int32_t protocol = -1;
357     JsObjectToInt(env, object, "protocol", false, protocol);
358     IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, filter.protocol);
359     return true;
360 }
361 
NativeAddIptalbsFilterRule(napi_env env,void * data)362 void NetworkManagerAddon::NativeAddIptalbsFilterRule(napi_env env, void *data)
363 {
364     EDMLOGI("NAPI_NativeAddIptalbsFilterRule called");
365     if (data == nullptr) {
366         EDMLOGE("data is nullptr");
367         return;
368     }
369     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
370     asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddIptablesFilterRule(
371         asyncCallbackInfo->data);
372 }
373 
RemoveIptablesFilterRule(napi_env env,napi_callback_info info)374 napi_value NetworkManagerAddon::RemoveIptablesFilterRule(napi_env env, napi_callback_info info)
375 {
376     EDMLOGI("NetworkManagerAddon::RemoveIptablesFilterRule called");
377     auto convertRemoveFilter2Data = [](napi_env env, napi_value argv, MessageParcel &data,
378         const AddonMethodSign &methodSign) {
379         IPTABLES::RemoveFilter filter;
380         bool isUint = JsObjToRemoveFirewallObject(env, argv, filter);
381         if (!isUint) {
382             return false;
383         }
384         IPTABLES::IptablesUtils::WriteRemoveFilterConfig(filter, data);
385         return true;
386     };
387     AddonMethodSign addonMethodSign;
388     addonMethodSign.name = "RemoveIptablesFilterRule";
389     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
390     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
391     addonMethodSign.argsConvert = {nullptr, convertRemoveFilter2Data};
392     return AddonMethodAdapter(env, info, addonMethodSign, NativeRemoveIptalbsFilterRule,
393         NativeVoidCallbackComplete);
394 }
395 
JsObjToRemoveFirewallObject(napi_env env,napi_value object,IPTABLES::RemoveFilter & firewall)396 bool NetworkManagerAddon::JsObjToRemoveFirewallObject(napi_env env, napi_value object, IPTABLES::RemoveFilter &firewall)
397 {
398     JsObjectToString(env, object, "srcAddr", false, firewall.srcAddr);
399     JsObjectToString(env, object, "destAddr", false, firewall.destAddr);
400     JsObjectToString(env, object, "srcPort", false, firewall.srcPort);
401     JsObjectToString(env, object, "destPort", false, firewall.destPort);
402     JsObjectToString(env, object, "uid", false, firewall.uid);
403     int32_t direction = -1;
404     if (!JsObjectToInt(env, object, "direction", true, direction) ||
405         !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, firewall.direction)) {
406         EDMLOGE("NAPI_removeIptalbsFilterRule JsObjToRemoveFirewallObject direction trans failed");
407         return false;
408     }
409     int32_t action = -1;
410     JsObjectToInt(env, object, "action", false, action);
411     IPTABLES::IptablesUtils::ProcessFirewallAction(action, firewall.action);
412     int32_t protocol = -1;
413     JsObjectToInt(env, object, "protocol", false, protocol);
414     IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, firewall.protocol);
415     return true;
416 }
417 
NativeRemoveIptalbsFilterRule(napi_env env,void * data)418 void NetworkManagerAddon::NativeRemoveIptalbsFilterRule(napi_env env, void *data)
419 {
420     EDMLOGI("NAPI_NativeRemoveIptalbsFilterRule called");
421     if (data == nullptr) {
422         EDMLOGE("data is nullptr");
423         return;
424     }
425     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
426     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
427     asyncCallbackInfo->ret =
428         networkManagerProxy->RemoveIptablesFilterRule(asyncCallbackInfo->data);
429 }
430 
ListIptablesFilterRules(napi_env env,napi_callback_info info)431 napi_value NetworkManagerAddon::ListIptablesFilterRules(napi_env env, napi_callback_info info)
432 {
433     AddonMethodSign addonMethodSign;
434     addonMethodSign.name = "ListIptablesFilterRules";
435     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
436     addonMethodSign.methodAttribute = MethodAttribute::GET;
437     return AddonMethodAdapter(env, info, addonMethodSign, NativeListIptablesFilterRules,
438         NativeStringCallbackComplete);
439 }
440 
NativeListIptablesFilterRules(napi_env env,void * data)441 void NetworkManagerAddon::NativeListIptablesFilterRules(napi_env env, void *data)
442 {
443     EDMLOGI("NAPI_NativeListIptablesFilterRule called");
444     if (data == nullptr) {
445         EDMLOGE("data is nullptr");
446         return;
447     }
448     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
449     asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->ListIptablesFilterRules(
450         asyncCallbackInfo->data, asyncCallbackInfo->stringRet);
451 }
452 
AddFirewallRule(napi_env env,napi_callback_info info)453 napi_value NetworkManagerAddon::AddFirewallRule(napi_env env, napi_callback_info info)
454 {
455     EDMLOGI("AddFirewallRule start");
456     auto convertFirewallRule2Data = [](napi_env env, napi_value argv, MessageParcel &data,
457         const AddonMethodSign &methodSign) {
458         IPTABLES::FirewallRule rule;
459         bool isUint = JsObjToFirewallRule(env, argv, rule);
460         if (!isUint) {
461             return false;
462         }
463         IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
464         if (!firewallRuleParcel.Marshalling(data)) {
465             EDMLOGE("NetworkManagerAddon::AddOrRemoveFirewallRuleCommon Marshalling rule fail.");
466             return false;
467         }
468         return true;
469     };
470     AddonMethodSign addonMethodSign;
471     addonMethodSign.name = "AddFirewallRule";
472     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
473     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
474     addonMethodSign.argsConvert = {nullptr, convertFirewallRule2Data};
475     AdapterAddonData adapterAddonData{};
476     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
477         return nullptr;
478     }
479     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddFirewallRule(adapterAddonData.data);
480     if (FAILED(ret)) {
481         napi_throw(env, CreateError(env, ret));
482     }
483     return nullptr;
484 }
485 
RemoveFirewallRule(napi_env env,napi_callback_info info)486 napi_value NetworkManagerAddon::RemoveFirewallRule(napi_env env, napi_callback_info info)
487 {
488     EDMLOGI("RemoveFirewallRule start");
489     size_t argc = ARGS_SIZE_TWO;
490     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
491     napi_value thisArg = nullptr;
492     void *data = nullptr;
493     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
494     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
495     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
496     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
497     if (argc >= ARGS_SIZE_TWO) {
498         bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
499         ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be FirewallRule.");
500     }
501     OHOS::AppExecFwk::ElementName elementName;
502     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
503         "element name param error");
504     IPTABLES::FirewallRule rule = {IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID,
505         IPTABLES::Protocol::INVALID, "", "", "", "", ""};
506     if (argc >= ARGS_SIZE_TWO) {
507         ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToFirewallRule(env, argv[ARR_INDEX_ONE], rule),
508             "firewallRule param error");
509     }
510     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->RemoveFirewallRule(elementName, rule);
511     if (FAILED(ret)) {
512         napi_throw(env, CreateError(env, ret));
513     }
514     return nullptr;
515 }
516 
GetFirewallRules(napi_env env,napi_callback_info info)517 napi_value NetworkManagerAddon::GetFirewallRules(napi_env env, napi_callback_info info)
518 {
519     AddonMethodSign addonMethodSign;
520     addonMethodSign.name = "GetFirewallRules";
521     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
522     addonMethodSign.methodAttribute = MethodAttribute::GET;
523 
524     AdapterAddonData adapterAddonData{};
525     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
526         return nullptr;
527     }
528     std::vector<IPTABLES::FirewallRule> result;
529     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetFirewallRules(adapterAddonData.data, result);
530     if (FAILED(ret)) {
531         napi_throw(env, CreateError(env, ret));
532         return nullptr;
533     }
534     napi_value jsList = nullptr;
535     NAPI_CALL(env, napi_create_array_with_length(env, result.size(), &jsList));
536     for (size_t i = 0; i < result.size(); i++) {
537         napi_value item = FirewallRuleToJsObj(env, result[i]);
538         NAPI_CALL(env, napi_set_element(env, jsList, i, item));
539     }
540     return jsList;
541 }
542 
JsObjToFirewallRule(napi_env env,napi_value object,IPTABLES::FirewallRule & rule)543 bool NetworkManagerAddon::JsObjToFirewallRule(napi_env env, napi_value object, IPTABLES::FirewallRule &rule)
544 {
545     int32_t direction = -1;
546     JsObjectToInt(env, object, "direction", false, direction);
547     EDMLOGI("JsObjToFirewallRule direction %{public}d", direction);
548     IPTABLES::Direction directionEnum = IPTABLES::Direction::INVALID;
549     IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, directionEnum);
550 
551     int32_t action = -1;
552     JsObjectToInt(env, object, "action", false, action);
553     EDMLOGI("JsObjToFirewallRule action %{public}d", action);
554     IPTABLES::Action actionEnum = IPTABLES::Action::INVALID;
555     IPTABLES::IptablesUtils::ProcessFirewallAction(action, actionEnum);
556 
557     int32_t protocol = -1;
558     JsObjectToInt(env, object, "protocol", false, protocol);
559     EDMLOGI("JsObjToFirewallRule protocol %{public}d", protocol);
560     IPTABLES::Protocol protocolEnum = IPTABLES::Protocol::INVALID;
561     IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, protocolEnum);
562 
563     std::string srcAddr;
564     JsObjectToString(env, object, "srcAddr", false, srcAddr);
565 
566     std::string destAddr;
567     JsObjectToString(env, object, "destAddr", false, destAddr);
568 
569     std::string srcPort;
570     JsObjectToString(env, object, "srcPort", false, srcPort);
571 
572     std::string destPort;
573     JsObjectToString(env, object, "destPort", false, destPort);
574 
575     std::string appUid;
576     JsObjectToString(env, object, "appUid", false, appUid);
577     rule = {directionEnum, actionEnum, protocolEnum, srcAddr, destAddr, srcPort, destPort, appUid};
578     return true;
579 }
580 
FirewallRuleToJsObj(napi_env env,const IPTABLES::FirewallRule & rule)581 napi_value NetworkManagerAddon::FirewallRuleToJsObj(napi_env env, const IPTABLES::FirewallRule &rule)
582 {
583     napi_value jsRule = nullptr;
584     NAPI_CALL(env, napi_create_object(env, &jsRule));
585 
586     napi_value direction = nullptr;
587     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_DICECTION_IND>(rule)), &direction));
588     napi_value action = nullptr;
589     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_ACTION_IND>(rule)), &action));
590     napi_value protocol = nullptr;
591     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_PROT_IND>(rule)), &protocol));
592     napi_value srcAddr = nullptr;
593     std::string srcAddrStr = std::get<FIREWALL_SRCADDR_IND>(rule);
594     NAPI_CALL(env, napi_create_string_utf8(env, srcAddrStr.c_str(), srcAddrStr.length(), &srcAddr));
595     napi_value destAddr = nullptr;
596     std::string destAddrStr = std::get<FIREWALL_DESTADDR_IND>(rule);
597     NAPI_CALL(env, napi_create_string_utf8(env, destAddrStr.c_str(), destAddrStr.length(), &destAddr));
598     napi_value srcPort = nullptr;
599     std::string srcPortStr = std::get<FIREWALL_SRCPORT_IND>(rule);
600     NAPI_CALL(env, napi_create_string_utf8(env, srcPortStr.c_str(), srcPortStr.length(), &srcPort));
601     napi_value destPort = nullptr;
602     std::string destPortStr = std::get<FIREWALL_DESTPORT_IND>(rule);
603     NAPI_CALL(env, napi_create_string_utf8(env, destPortStr.c_str(), destPortStr.length(), &destPort));
604     napi_value appUid = nullptr;
605     std::string appUidStr = std::get<FIREWALL_APPUID_IND>(rule);
606     NAPI_CALL(env, napi_create_string_utf8(env, appUidStr.c_str(), appUidStr.length(), &appUid));
607 
608     NAPI_CALL(env, napi_set_named_property(env, jsRule, "direction", direction));
609     NAPI_CALL(env, napi_set_named_property(env, jsRule, "action", action));
610     NAPI_CALL(env, napi_set_named_property(env, jsRule, "protocol", protocol));
611     NAPI_CALL(env, napi_set_named_property(env, jsRule, "srcAddr", srcAddr));
612     NAPI_CALL(env, napi_set_named_property(env, jsRule, "destAddr", destAddr));
613     NAPI_CALL(env, napi_set_named_property(env, jsRule, "srcPort", srcPort));
614     NAPI_CALL(env, napi_set_named_property(env, jsRule, "destPort", destPort));
615     NAPI_CALL(env, napi_set_named_property(env, jsRule, "appUid", appUid));
616     return jsRule;
617 }
618 
AddDomainFilterRule(napi_env env,napi_callback_info info)619 napi_value NetworkManagerAddon::AddDomainFilterRule(napi_env env, napi_callback_info info)
620 {
621     auto convertFirewallRule2Data = [](napi_env env, napi_value argv, MessageParcel &data,
622         const AddonMethodSign &methodSign) {
623         IPTABLES::DomainFilterRule rule = {IPTABLES::Action::INVALID, "", "", IPTABLES::Direction::INVALID};
624         bool isParseOk = JsObjToDomainFilterRule(env, argv, rule);
625         if (!isParseOk) {
626             return false;
627         }
628         IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
629         if (!domainFilterRuleParcel.Marshalling(data)) {
630             EDMLOGE("NetworkManagerAddon::AddOrRemoveDomainFilterRuleCommon Marshalling rule fail.");
631             return false;
632         }
633         return true;
634     };
635     AddonMethodSign addonMethodSign;
636     addonMethodSign.name = "AddDomainFilterRule";
637     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
638     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
639     addonMethodSign.argsConvert = {nullptr, convertFirewallRule2Data};
640     AdapterAddonData adapterAddonData{};
641     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
642         return nullptr;
643     }
644     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddDomainFilterRule(adapterAddonData.data);
645     if (FAILED(ret)) {
646         napi_throw(env, CreateError(env, ret));
647     }
648     return nullptr;
649 }
650 
RemoveDomainFilterRule(napi_env env,napi_callback_info info)651 napi_value NetworkManagerAddon::RemoveDomainFilterRule(napi_env env, napi_callback_info info)
652 {
653     size_t argc = ARGS_SIZE_TWO;
654     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
655     napi_value thisArg = nullptr;
656     void *data = nullptr;
657     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
658     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
659     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
660     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
661     if (argc >= ARGS_SIZE_TWO) {
662         bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
663         ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be DomainFilterRule.");
664     }
665 
666     OHOS::AppExecFwk::ElementName elementName;
667     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
668         "element name param error");
669     IPTABLES::DomainFilterRule rule = {IPTABLES::Action::INVALID, "", "", IPTABLES::Direction::INVALID};
670     if (argc >= ARGS_SIZE_TWO) {
671         ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToDomainFilterRule(env, argv[ARR_INDEX_ONE], rule),
672             "DomainFilterRule param error");
673     }
674 
675     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->RemoveDomainFilterRule(elementName, rule);
676     if (FAILED(ret)) {
677         napi_throw(env, CreateError(env, ret));
678     }
679     return nullptr;
680 }
681 
GetDomainFilterRules(napi_env env,napi_callback_info info)682 napi_value NetworkManagerAddon::GetDomainFilterRules(napi_env env, napi_callback_info info)
683 {
684     AddonMethodSign addonMethodSign;
685     addonMethodSign.name = "GetDomainFilterRules";
686     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
687     addonMethodSign.methodAttribute = MethodAttribute::GET;
688 
689     AdapterAddonData adapterAddonData{};
690     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
691         return nullptr;
692     }
693     std::vector<IPTABLES::DomainFilterRule> result;
694     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetDomainFilterRules(adapterAddonData.data, result);
695     if (FAILED(ret)) {
696         napi_throw(env, CreateError(env, ret));
697         return nullptr;
698     }
699     napi_value jsList = nullptr;
700     NAPI_CALL(env, napi_create_array_with_length(env, result.size(), &jsList));
701     for (size_t i = 0; i < result.size(); i++) {
702         napi_value item = DomainFilterRuleToJsObj(env, result[i]);
703         NAPI_CALL(env, napi_set_element(env, jsList, i, item));
704     }
705     return jsList;
706 }
707 
JsObjToDomainFilterRule(napi_env env,napi_value object,IPTABLES::DomainFilterRule & rule)708 bool NetworkManagerAddon::JsObjToDomainFilterRule(napi_env env, napi_value object, IPTABLES::DomainFilterRule &rule)
709 {
710     int32_t action = -1;
711     JsObjectToInt(env, object, "action", false, action);
712     IPTABLES::Action actionEnum = IPTABLES::Action::INVALID;
713     IPTABLES::IptablesUtils::ProcessFirewallAction(action, actionEnum);
714 
715     std::string appUid;
716     JsObjectToString(env, object, "appUid", false, appUid);
717 
718     std::string domainName;
719     JsObjectToString(env, object, "domainName", false, domainName);
720 
721     int32_t direction = -1;
722     JsObjectToInt(env, object, "direction", false, direction);
723     IPTABLES::Direction directionEnum = IPTABLES::Direction::INVALID;
724     IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, directionEnum);
725     rule = {actionEnum, appUid, domainName, directionEnum};
726     return true;
727 }
728 
DomainFilterRuleToJsObj(napi_env env,const IPTABLES::DomainFilterRule & rule)729 napi_value NetworkManagerAddon::DomainFilterRuleToJsObj(napi_env env, const IPTABLES::DomainFilterRule &rule)
730 {
731     napi_value jsRule = nullptr;
732     NAPI_CALL(env, napi_create_object(env, &jsRule));
733 
734     napi_value direction = nullptr;
735     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<DOMAIN_DIRECTION_IND>(rule)), &direction));
736     napi_value action = nullptr;
737     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<DOMAIN_ACTION_IND>(rule)), &action));
738     napi_value appUid = nullptr;
739     std::string appUidStr = std::get<DOMAIN_APPUID_IND>(rule);
740     NAPI_CALL(env, napi_create_string_utf8(env, appUidStr.c_str(), appUidStr.length(), &appUid));
741     napi_value domainName = nullptr;
742     std::string domainNameStr = std::get<DOMAIN_DOMAINNAME_IND>(rule);
743     NAPI_CALL(env, napi_create_string_utf8(env, domainNameStr.c_str(), domainNameStr.length(), &domainName));
744     NAPI_CALL(env, napi_set_named_property(env, jsRule, "action", action));
745     NAPI_CALL(env, napi_set_named_property(env, jsRule, "appUid", appUid));
746     NAPI_CALL(env, napi_set_named_property(env, jsRule, "domainName", domainName));
747     NAPI_CALL(env, napi_set_named_property(env, jsRule, "direction", direction));
748     return jsRule;
749 }
750 
SetGlobalHttpProxy(napi_env env,napi_callback_info info)751 napi_value NetworkManagerAddon::SetGlobalHttpProxy(napi_env env, napi_callback_info info)
752 {
753 #ifdef NETMANAGER_BASE_EDM_ENABLE
754     AddonMethodSign addonMethodSign;
755     SetGlobalHttpProxyCommon(addonMethodSign);
756     return AddonMethodAdapter(env, info, addonMethodSign, NativeSetGlobalHttpProxy, NativeVoidCallbackComplete);
757 #else
758     EDMLOGW("NetworkManagerAddon::SetGlobalHttpProxy Unsupported Capabilities.");
759     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
760     return nullptr;
761 #endif
762 }
763 
764 #ifdef NETMANAGER_BASE_EDM_ENABLE
ParseHttpProxyParam(napi_env env,napi_value argv,NetManagerStandard::HttpProxy & httpProxy)765 bool NetworkManagerAddon::ParseHttpProxyParam(napi_env env, napi_value argv, NetManagerStandard::HttpProxy &httpProxy)
766 {
767     std::string host;
768     if (!JsObjectToString(env, argv, HOST_PROP_NAME, true, host)) {
769         EDMLOGE("error host value");
770         return false;
771     }
772     std::int32_t port = 0;
773     if (!JsObjectToInt(env, argv, PORT_PROP_NAME, true, port)) {
774         EDMLOGE("error port value");
775         return false;
776     }
777     OHOS::NetManagerStandard::SecureData username;
778     if (!JsObjectToSecureData(env, argv, PROXY_USER_NAME, username)) {
779         EDMLOGE("error username value");
780         return false;
781     }
782     OHOS::NetManagerStandard::SecureData password;
783     if (!JsObjectToSecureData(env, argv, PROXY_PASSWORD, password)) {
784         EDMLOGE("error password value");
785         return false;
786     }
787     if (!username.empty() && !password.empty()) {
788         EDMLOGD("NetworkManagerAddon username and password is not empty.");
789     } else {
790         EDMLOGD("NetworkManagerAddon username or password is empty.");
791     }
792     std::vector<std::string> exclusionList;
793     if (!JsObjectToStringVector(env, argv, EXCLUSION_LIST_PROP_NAME, true, exclusionList)) {
794         EDMLOGE("error exclusionList value");
795         return false;
796     }
797 
798     httpProxy.SetHost(host.c_str());
799     httpProxy.SetPort(port);
800     httpProxy.SetUserName(username);
801     httpProxy.SetPassword(password);
802     std::list<std::string> dataList;
803     for (const auto &item : exclusionList) {
804         dataList.emplace_back(item);
805     }
806     httpProxy.SetExclusionList(dataList);
807     return true;
808 }
809 
JsObjectToSecureData(napi_env env,napi_value object,const char * paramStr,OHOS::NetManagerStandard::SecureData & secureData)810 bool NetworkManagerAddon::JsObjectToSecureData(napi_env env, napi_value object, const char *paramStr,
811     OHOS::NetManagerStandard::SecureData &secureData)
812 {
813     bool hasProperty = false;
814     if (napi_has_named_property(env, object, paramStr, &hasProperty) != napi_ok) {
815         EDMLOGE("get js property failed.");
816         return false;
817     }
818     if (hasProperty) {
819         napi_value prop = nullptr;
820         return napi_get_named_property(env, object, paramStr, &prop) == napi_ok &&
821             ParseSecureData(env, secureData, prop);
822     }
823     return true;
824 }
825 
ParseSecureData(napi_env env,OHOS::NetManagerStandard::SecureData & secureData,napi_value object)826 bool NetworkManagerAddon::ParseSecureData(napi_env env, OHOS::NetManagerStandard::SecureData &secureData,
827     napi_value object)
828 {
829     napi_valuetype valuetype;
830     if (napi_typeof(env, object, &valuetype) != napi_ok || valuetype != napi_string ||
831         !GetSecureDataFromNAPI(env, object, secureData)) {
832         EDMLOGE("can not get string value");
833         return false;
834     }
835     return true;
836 }
837 
GetSecureDataFromNAPI(napi_env env,napi_value object,OHOS::NetManagerStandard::SecureData & secureData)838 bool NetworkManagerAddon::GetSecureDataFromNAPI(napi_env env, napi_value object,
839     OHOS::NetManagerStandard::SecureData &secureData)
840 {
841     OHOS::NetManagerStandard::SecureData result;
842     size_t size = 0;
843 
844     if (napi_get_value_string_utf8(env, object, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
845         EDMLOGE("can not get string size");
846         return false;
847     }
848     result.reserve(size + NAPI_RETURN_ONE);
849     result.resize(size);
850     if (napi_get_value_string_utf8(env, object, result.data(), (size + NAPI_RETURN_ONE), &size) != napi_ok) {
851         EDMLOGE("can not get string value");
852         return false;
853     }
854     secureData = result;
855     return true;
856 }
857 
NativeSetGlobalHttpProxy(napi_env env,void * data)858 void NetworkManagerAddon::NativeSetGlobalHttpProxy(napi_env env, void *data)
859 {
860     EDMLOGI("NAPI_NativeSetGlobalHttpProxycalled");
861     if (data == nullptr) {
862         EDMLOGE("data is nullptr");
863         return;
864     }
865     AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
866     asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->SetGlobalHttpProxy(
867         asyncCallbackInfo->data);
868 }
869 
ConvertHttpProxyToJS(napi_env env,const OHOS::NetManagerStandard::HttpProxy & httpProxy)870 napi_value NetworkManagerAddon::ConvertHttpProxyToJS(napi_env env, const OHOS::NetManagerStandard::HttpProxy &httpProxy)
871 {
872     napi_value proxy = nullptr;
873     NAPI_CALL(env, napi_create_object(env, &proxy));
874     napi_value host = nullptr;
875     NAPI_CALL(env, napi_create_string_utf8(env, httpProxy.GetHost().c_str(), httpProxy.GetHost().length(), &host));
876     napi_value port = nullptr;
877     NAPI_CALL(env, napi_create_int32(env, httpProxy.GetPort(), &port));
878     napi_value list = nullptr;
879     if (httpProxy.GetExclusionList().empty()) {
880         NAPI_CALL(env, napi_create_array(env, &list));
881     } else {
882         std::list<std::string> tempList = httpProxy.GetExclusionList();
883         NAPI_CALL(env, napi_create_array_with_length(env, tempList.size(), &list));
884         size_t index = 0;
885         for (const auto &item : tempList) {
886             napi_value ip = nullptr;
887             NAPI_CALL(env, napi_create_string_utf8(env, item.c_str(), item.length(), &ip));
888             NAPI_CALL(env, napi_set_element(env, list, index++, ip));
889         }
890     }
891     NAPI_CALL(env, napi_set_named_property(env, proxy, HOST_PROP_NAME, host));
892     NAPI_CALL(env, napi_set_named_property(env, proxy, PORT_PROP_NAME, port));
893     NAPI_CALL(env, napi_set_named_property(env, proxy, EXCLUSION_LIST_PROP_NAME, list));
894     return proxy;
895 }
896 #endif
897 
GetGlobalHttpProxy(napi_env env,napi_callback_info info)898 napi_value NetworkManagerAddon::GetGlobalHttpProxy(napi_env env, napi_callback_info info)
899 {
900 #ifdef NETMANAGER_BASE_EDM_ENABLE
901     size_t argc = ARGS_SIZE_TWO;
902     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
903     napi_value thisArg = nullptr;
904     void *data = nullptr;
905     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
906     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
907     auto asyncCallbackInfo = new (std::nothrow) AsyncHttpProxyCallbackInfo();
908     if (asyncCallbackInfo == nullptr) {
909         return nullptr;
910     }
911     std::unique_ptr<AsyncHttpProxyCallbackInfo> callbackPtr{asyncCallbackInfo};
912     bool matchValue = false;
913     if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
914         asyncCallbackInfo->hasAdmin = false;
915         matchValue = true;
916     } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
917         asyncCallbackInfo->hasAdmin = true;
918         matchValue = true;
919     }
920     if (argc > ARGS_SIZE_ONE) {
921         matchValue = matchValue && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
922     }
923     ASSERT_AND_THROW_PARAM_ERROR(env, matchValue, "parameter type error");
924     if (asyncCallbackInfo->hasAdmin) {
925         ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
926             "element name param error");
927         EDMLOGD(
928             "GetGlobalHttpProxy: asyncCallbackInfo->elementName.bundlename %{public}s, "
929             "asyncCallbackInfo->abilityname:%{public}s",
930             asyncCallbackInfo->elementName.GetBundleName().c_str(),
931             asyncCallbackInfo->elementName.GetAbilityName().c_str());
932     }
933     if (argc > ARGS_SIZE_ONE) {
934         EDMLOGD("NAPI_GetGlobalHttpProxy argc == ARGS_SIZE_TWO");
935         napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
936     }
937     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "NativeGetGlobalHttpProxy",
938         NativeGetGlobalHttpProxy, NativeHttpProxyCallbackComplete);
939     callbackPtr.release();
940     return asyncWorkReturn;
941 #else
942     EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxy Unsupported Capabilities.");
943     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
944     return nullptr;
945 #endif
946 }
947 
948 #ifdef NETMANAGER_BASE_EDM_ENABLE
NativeGetGlobalHttpProxy(napi_env env,void * data)949 void NetworkManagerAddon::NativeGetGlobalHttpProxy(napi_env env, void *data)
950 {
951     EDMLOGI("NAPI_NativeGetGlobalHttpProxy called");
952     if (data == nullptr) {
953         EDMLOGE("data is nullptr");
954         return;
955     }
956     AsyncHttpProxyCallbackInfo *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
957     int32_t accountId = -1;
958     if (asyncCallbackInfo->hasAdmin) {
959         asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(
960             &asyncCallbackInfo->elementName, asyncCallbackInfo->httpProxy, accountId);
961     } else {
962         asyncCallbackInfo->ret =
963             NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(nullptr,
964                 asyncCallbackInfo->httpProxy, accountId);
965     }
966 }
967 
NativeHttpProxyCallbackComplete(napi_env env,napi_status status,void * data)968 void NetworkManagerAddon::NativeHttpProxyCallbackComplete(napi_env env, napi_status status, void *data)
969 {
970     EDMLOGD("NativeHttpProxyCallbackComplete start");
971     if (data == nullptr) {
972         EDMLOGE("data is nullptr");
973         return;
974     }
975     auto *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
976     if (asyncCallbackInfo->deferred != nullptr) {
977         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
978         if (asyncCallbackInfo->ret == ERR_OK) {
979             napi_value jsHttpProxy = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
980             napi_resolve_deferred(env, asyncCallbackInfo->deferred, jsHttpProxy);
981         } else {
982             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
983         }
984     } else {
985         napi_value callbackValue[ARGS_SIZE_TWO] = {0};
986         if (asyncCallbackInfo->ret == ERR_OK) {
987             napi_get_null(env, &callbackValue[ARR_INDEX_ZERO]);
988             callbackValue[ARR_INDEX_ONE] = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
989         } else {
990             callbackValue[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
991             napi_get_null(env, &callbackValue[ARR_INDEX_ONE]);
992         }
993         napi_value callback = nullptr;
994         napi_value result = nullptr;
995         napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
996         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
997         napi_delete_reference(env, asyncCallbackInfo->callback);
998     }
999     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1000     delete asyncCallbackInfo;
1001 }
1002 #endif
1003 
GetAllNetworkInterfacesSync(napi_env env,napi_callback_info info)1004 napi_value NetworkManagerAddon::GetAllNetworkInterfacesSync(napi_env env, napi_callback_info info)
1005 {
1006     EDMLOGI("NAPI_GetAllNetworkInterfacesSync called");
1007     AddonMethodSign addonMethodSign;
1008     addonMethodSign.name = "GetAllNetworkInterfacesSync";
1009     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
1010     addonMethodSign.methodAttribute = MethodAttribute::GET;
1011     addonMethodSign.apiVersionTag = EdmConstants::PERMISSION_TAG_VERSION_12;
1012     AdapterAddonData adapterAddonData{};
1013     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1014         return nullptr;
1015     }
1016     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1017     if (networkManagerProxy == nullptr) {
1018         EDMLOGE("can not get GetNetworkManagerProxy");
1019         return nullptr;
1020     }
1021     std::vector<std::string> networkInterface;
1022     int32_t ret = networkManagerProxy->GetAllNetworkInterfaces(adapterAddonData.data, networkInterface);
1023     if (FAILED(ret)) {
1024         napi_throw(env, CreateError(env, ret));
1025         return nullptr;
1026     }
1027     napi_value result = nullptr;
1028     NAPI_CALL(env, napi_create_array(env, &result));
1029     ConvertStringVectorToJS(env, networkInterface, result);
1030     return result;
1031 }
1032 
GetIpAddressSync(napi_env env,napi_callback_info info)1033 napi_value NetworkManagerAddon::GetIpAddressSync(napi_env env, napi_callback_info info)
1034 {
1035     EDMLOGI("NAPI_GetIpAddressSync called");
1036     return GetIpOrMacAddressSync(env, info, EdmInterfaceCode::GET_IP_ADDRESS);
1037 }
1038 
GetMacSync(napi_env env,napi_callback_info info)1039 napi_value NetworkManagerAddon::GetMacSync(napi_env env, napi_callback_info info)
1040 {
1041     EDMLOGI("NAPI_GetMacSync called");
1042     return GetIpOrMacAddressSync(env, info, EdmInterfaceCode::GET_MAC);
1043 }
1044 
GetIpOrMacAddressSync(napi_env env,napi_callback_info info,int policyCode)1045 napi_value NetworkManagerAddon::GetIpOrMacAddressSync(napi_env env, napi_callback_info info, int policyCode)
1046 {
1047     AddonMethodSign addonMethodSign;
1048     GetIpOrMacAddressCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_12, policyCode);
1049     AdapterAddonData adapterAddonData{};
1050     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1051         return nullptr;
1052     }
1053     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1054     if (networkManagerProxy == nullptr) {
1055         EDMLOGE("can not get GetNetworkManagerProxy");
1056         return nullptr;
1057     }
1058     std::string ipOrMacInfo;
1059     int32_t ret = networkManagerProxy->GetIpOrMacAddress(adapterAddonData.data, policyCode, ipOrMacInfo);
1060     if (FAILED(ret)) {
1061         napi_throw(env, CreateError(env, ret));
1062         return nullptr;
1063     }
1064     napi_value result = nullptr;
1065     NAPI_CALL(env, napi_create_string_utf8(env, ipOrMacInfo.c_str(), NAPI_AUTO_LENGTH, &result));
1066     return result;
1067 }
1068 
SetNetworkInterfaceDisabledSync(napi_env env,napi_callback_info info)1069 napi_value NetworkManagerAddon::SetNetworkInterfaceDisabledSync(napi_env env, napi_callback_info info)
1070 {
1071     EDMLOGI("NAPI_SetNetworkInterfaceDisabledSync called");
1072     AddonMethodSign addonMethodSign;
1073     SetNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_12);
1074     AdapterAddonData adapterAddonData{};
1075     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1076         return nullptr;
1077     }
1078     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1079     if (networkManagerProxy == nullptr) {
1080         EDMLOGE("can not get GetNetworkManagerProxy");
1081         return nullptr;
1082     }
1083     int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(adapterAddonData.data);
1084     if (FAILED(ret)) {
1085         napi_throw(env, CreateError(env, ret));
1086         return nullptr;
1087     }
1088     return nullptr;
1089 }
1090 
IsNetworkInterfaceDisabledSync(napi_env env,napi_callback_info info)1091 napi_value NetworkManagerAddon::IsNetworkInterfaceDisabledSync(napi_env env, napi_callback_info info)
1092 {
1093     EDMLOGI("NAPI_IsNetworkInterfaceDisabledSync called");
1094     AddonMethodSign addonMethodSign;
1095     IsNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_12);
1096     AdapterAddonData adapterAddonData{};
1097     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1098         return nullptr;
1099     }
1100     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1101     if (networkManagerProxy == nullptr) {
1102         EDMLOGE("can not get GetNetworkManagerProxy");
1103         return nullptr;
1104     }
1105     bool isDisabled = false;
1106     int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(adapterAddonData.data, isDisabled);
1107     if (FAILED(ret)) {
1108         napi_throw(env, CreateError(env, ret));
1109         return nullptr;
1110     }
1111     napi_value result = nullptr;
1112     NAPI_CALL(env, napi_get_boolean(env, isDisabled, &result));
1113     return result;
1114 }
1115 
SetGlobalHttpProxyCommon(AddonMethodSign & addonMethodSign)1116 void NetworkManagerAddon::SetGlobalHttpProxyCommon(AddonMethodSign &addonMethodSign)
1117 {
1118 #ifdef NETMANAGER_BASE_EDM_ENABLE
1119     auto convertHttpProxy2Data = [](napi_env env, napi_value argv, MessageParcel &data,
1120         const AddonMethodSign &methodSign) {
1121         NetManagerStandard::HttpProxy httpProxy;
1122         bool isParseOk = ParseHttpProxyParam(env, argv, httpProxy);
1123         if (!isParseOk) {
1124             return false;
1125         }
1126         if (!httpProxy.Marshalling(data)) {
1127             EDMLOGE("NetworkManagerAddon::SetGlobalHttpProxyCommon Marshalling proxy fail.");
1128             return false;
1129         }
1130         int32_t accountId = -1;
1131         data.WriteInt32(accountId);
1132         return true;
1133     };
1134     addonMethodSign.name = "SetGlobalHttpProxy";
1135     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
1136     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1137     addonMethodSign.argsConvert = {nullptr, convertHttpProxy2Data};
1138 #endif
1139 }
1140 
SetGlobalHttpProxyCommonForAccount(AddonMethodSign & addonMethodSign)1141 void NetworkManagerAddon::SetGlobalHttpProxyCommonForAccount(AddonMethodSign &addonMethodSign)
1142 {
1143 #ifdef NETMANAGER_BASE_EDM_ENABLE
1144     auto convertHttpProxy2Data = [](napi_env env, napi_value argv, MessageParcel &data,
1145         const AddonMethodSign &methodSign) {
1146         NetManagerStandard::HttpProxy httpProxy;
1147         bool isParseOk = ParseHttpProxyParam(env, argv, httpProxy);
1148         if (!isParseOk) {
1149             return false;
1150         }
1151         if (!httpProxy.Marshalling(data)) {
1152             EDMLOGE("NetworkManagerAddon::SetGlobalHttpProxyCommonForAccount Marshalling proxy fail.");
1153             return false;
1154         }
1155         return true;
1156     };
1157     addonMethodSign.name = "SetGlobalHttpProxyForAccountSync";
1158     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM, EdmAddonCommonType::INT32};
1159     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1160     addonMethodSign.argsConvert = {nullptr, convertHttpProxy2Data, nullptr};
1161 #endif
1162 }
1163 
SetGlobalHttpProxyCommonLogic(napi_env env,napi_callback_info info,AddonMethodSign & addonMethodSign)1164 napi_value NetworkManagerAddon::SetGlobalHttpProxyCommonLogic(napi_env env, napi_callback_info info,
1165     AddonMethodSign& addonMethodSign)
1166 {
1167 #ifdef NETMANAGER_BASE_EDM_ENABLE
1168     AdapterAddonData adapterAddonData{};
1169     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1170         return nullptr;
1171     }
1172 
1173     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1174     if (networkManagerProxy == nullptr) {
1175         EDMLOGE("can not get GetNetworkManagerProxy");
1176         return nullptr;
1177     }
1178 
1179     int32_t ret = networkManagerProxy->SetGlobalHttpProxy(adapterAddonData.data);
1180     if (FAILED(ret)) {
1181         napi_throw(env, CreateError(env, ret));
1182         return nullptr;
1183     }
1184     return nullptr;
1185 #endif
1186 }
1187 
SetGlobalHttpProxySync(napi_env env,napi_callback_info info)1188 napi_value NetworkManagerAddon::SetGlobalHttpProxySync(napi_env env, napi_callback_info info)
1189 {
1190     EDMLOGI("NAPI_SetGlobalHttpProxySync called");
1191 #ifdef NETMANAGER_BASE_EDM_ENABLE
1192     AddonMethodSign addonMethodSign;
1193     SetGlobalHttpProxyCommon(addonMethodSign);
1194 
1195     return SetGlobalHttpProxyCommonLogic(env, info, addonMethodSign);
1196 #else
1197     EDMLOGW("NetworkManagerAddon::SetGlobalHttpProxySync Unsupported Capabilities.");
1198     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1199     return nullptr;
1200 #endif
1201 }
1202 
SetGlobalHttpProxyForAccountSync(napi_env env,napi_callback_info info)1203 napi_value NetworkManagerAddon::SetGlobalHttpProxyForAccountSync(napi_env env, napi_callback_info info)
1204 {
1205     EDMLOGI("NAPI_SetGlobalHttpProxyForAccountSync called");
1206 #if defined(FEATURE_PC_ONLY) && defined(NETMANAGER_BASE_EDM_ENABLE)
1207     AddonMethodSign addonMethodSign;
1208     SetGlobalHttpProxyCommonForAccount(addonMethodSign);
1209 
1210     return SetGlobalHttpProxyCommonLogic(env, info, addonMethodSign);
1211 #else
1212     EDMLOGW("NetworkManagerAddon::SetGlobalHttpProxyForAccountSync Unsupported Capabilities.");
1213     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1214     return nullptr;
1215 #endif
1216 }
1217 
GetGlobalHttpProxyCommon(napi_env env,napi_value * argv,size_t argc,bool hasAdmin,OHOS::AppExecFwk::ElementName & elementName,int32_t accountId)1218 napi_value NetworkManagerAddon::GetGlobalHttpProxyCommon(
1219     napi_env env, napi_value *argv, size_t argc, bool hasAdmin,
1220     OHOS::AppExecFwk::ElementName &elementName, int32_t accountId)
1221 {
1222 #ifdef NETMANAGER_BASE_EDM_ENABLE
1223     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
1224     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
1225         "param admin need be null or want");
1226 
1227     if (hasAdmin) {
1228         EDMLOGD("GetGlobalHttpProxySync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
1229             elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
1230     } else {
1231         EDMLOGD("GetGlobalHttpProxySync: elementName is null");
1232     }
1233 
1234     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1235     if (networkManagerProxy == nullptr) {
1236         EDMLOGE("can not get GetNetworkManagerProxy");
1237         return nullptr;
1238     }
1239 
1240     NetManagerStandard::HttpProxy httpProxy;
1241     int32_t ret = ERR_OK;
1242     if (hasAdmin) {
1243         ret = networkManagerProxy->GetGlobalHttpProxy(&elementName, httpProxy, accountId);
1244     } else {
1245         ret = networkManagerProxy->GetGlobalHttpProxy(nullptr, httpProxy, accountId);
1246     }
1247 
1248     if (FAILED(ret)) {
1249         napi_throw(env, CreateError(env, ret));
1250         return nullptr;
1251     }
1252 
1253     return ConvertHttpProxyToJS(env, httpProxy);
1254 #else
1255     EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxyCommon Unsupported Capabilities.");
1256     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1257     return nullptr;
1258 #endif
1259 }
1260 
GetGlobalHttpProxySync(napi_env env,napi_callback_info info)1261 napi_value NetworkManagerAddon::GetGlobalHttpProxySync(napi_env env, napi_callback_info info)
1262 {
1263     EDMLOGI("NAPI_GetGlobalHttpProxySync called");
1264 
1265 #ifdef NETMANAGER_BASE_EDM_ENABLE
1266     size_t argc = ARGS_SIZE_ONE;
1267     napi_value argv[ARGS_SIZE_ONE] = {nullptr};
1268     napi_value thisArg = nullptr;
1269     void *data = nullptr;
1270     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1271 
1272     bool hasAdmin = false;
1273     OHOS::AppExecFwk::ElementName elementName;
1274     return GetGlobalHttpProxyCommon(env, argv, argc, hasAdmin, elementName, -1);
1275 #else
1276     EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxy Unsupported Capabilities.");
1277     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1278     return nullptr;
1279 #endif
1280 }
1281 
GetGlobalHttpProxyForAccountSync(napi_env env,napi_callback_info info)1282 napi_value NetworkManagerAddon::GetGlobalHttpProxyForAccountSync(napi_env env, napi_callback_info info)
1283 {
1284     EDMLOGI("NAPI_GetGlobalHttpProxyForAccountSync called");
1285 #if defined(FEATURE_PC_ONLY) && defined(NETMANAGER_BASE_EDM_ENABLE)
1286     size_t argc = ARGS_SIZE_TWO;
1287     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1288     napi_value thisArg = nullptr;
1289     void *data = nullptr;
1290     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1291     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1292 
1293     bool hasAdmin = false;
1294     int32_t accountId = -1;
1295     OHOS::AppExecFwk::ElementName elementName;
1296     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
1297         "parameter accountId error");
1298     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
1299         "parameter accountId parse error");
1300 
1301     return GetGlobalHttpProxyCommon(env, argv, argc, hasAdmin, elementName, accountId);
1302 #else
1303     EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxyForAccountSync Unsupported Capabilities.");
1304     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1305     return nullptr;
1306 #endif
1307 }
1308 
1309 static napi_module g_networkManagerModule = {
1310     .nm_version = 1,
1311     .nm_flags = 0,
1312     .nm_filename = nullptr,
1313     .nm_register_func = NetworkManagerAddon::Init,
1314     .nm_modname = "enterprise.networkManager",
1315     .nm_priv = ((void *)0),
1316     .reserved = {0},
1317 };
1318 
NetworkManagerRegister()1319 extern "C" __attribute__((constructor)) void NetworkManagerRegister()
1320 {
1321     napi_module_register(&g_networkManagerModule);
1322 }