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