• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023 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 const char *const HOST_PROP_NAME = "host";
26 const char *const PORT_PROP_NAME = "port";
27 const char *const EXCLUSION_LIST_PROP_NAME = "exclusionList";
28 
CreateFirewallActionObject(napi_env env,napi_value value)29 void NetworkManagerAddon::CreateFirewallActionObject(napi_env env, napi_value value)
30 {
31     napi_value nAllow;
32     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::ALLOW), &nAllow));
33     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALLOW", nAllow));
34     napi_value nDeny;
35     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::DENY), &nDeny));
36     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DENY", nDeny));
37 }
38 
CreateFirewallProtocolObject(napi_env env,napi_value value)39 void NetworkManagerAddon::CreateFirewallProtocolObject(napi_env env, napi_value value)
40 {
41     napi_value nAll;
42     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ALL), &nAll));
43     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALL", nAll));
44     napi_value nTCP;
45     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::TCP), &nTCP));
46     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TCP", nTCP));
47     napi_value nUDP;
48     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::UDP), &nUDP));
49     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UDP", nUDP));
50     napi_value nICMP;
51     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ICMP), &nICMP));
52     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ICMP", nICMP));
53 }
54 
CreateFirewallDirectionObject(napi_env env,napi_value value)55 void NetworkManagerAddon::CreateFirewallDirectionObject(napi_env env, napi_value value)
56 {
57     napi_value nInput;
58     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::INPUT), &nInput));
59     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INPUT", nInput));
60     napi_value nOutput;
61     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::OUTPUT), &nOutput));
62     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "OUTPUT", nOutput));
63 }
64 
CreateFirewallAddMethodObject(napi_env env,napi_value value)65 void NetworkManagerAddon::CreateFirewallAddMethodObject(napi_env env, napi_value value)
66 {
67     napi_value nAppend;
68     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::APPEND), &nAppend));
69     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "APPEND", nAppend));
70     napi_value nInsert;
71     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::INSERT), &nInsert));
72     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INSERT", nInsert));
73 }
74 
Init(napi_env env,napi_value exports)75 napi_value NetworkManagerAddon::Init(napi_env env, napi_value exports)
76 {
77     napi_value nFirewallAction = nullptr;
78     NAPI_CALL(env, napi_create_object(env, &nFirewallAction));
79     CreateFirewallActionObject(env, nFirewallAction);
80 
81     napi_value nFirewallProtocol = nullptr;
82     NAPI_CALL(env, napi_create_object(env, &nFirewallProtocol));
83     CreateFirewallProtocolObject(env, nFirewallProtocol);
84 
85     napi_value nFirewallDirection = nullptr;
86     NAPI_CALL(env, napi_create_object(env, &nFirewallDirection));
87     CreateFirewallDirectionObject(env, nFirewallDirection);
88 
89     napi_value nFirewallAddMethod = nullptr;
90     NAPI_CALL(env, napi_create_object(env, &nFirewallAddMethod));
91     CreateFirewallAddMethodObject(env, nFirewallAddMethod);
92 
93     napi_property_descriptor property[] = {
94         DECLARE_NAPI_FUNCTION("getAllNetworkInterfaces", GetAllNetworkInterfaces),
95         DECLARE_NAPI_FUNCTION("getIpAddress", GetIpAddress),
96         DECLARE_NAPI_FUNCTION("getMac", GetMac),
97         DECLARE_NAPI_FUNCTION("setNetworkInterfaceDisabled", SetNetworkInterfaceDisabled),
98         DECLARE_NAPI_FUNCTION("isNetworkInterfaceDisabled", IsNetworkInterfaceDisabled),
99 
100         DECLARE_NAPI_PROPERTY("Action", nFirewallAction),
101         DECLARE_NAPI_PROPERTY("Protocol", nFirewallProtocol),
102         DECLARE_NAPI_PROPERTY("Direction", nFirewallDirection),
103         DECLARE_NAPI_PROPERTY("AddMethod", nFirewallAddMethod),
104         DECLARE_NAPI_FUNCTION("addIptablesFilterRule", AddIptablesFilterRule),
105         DECLARE_NAPI_FUNCTION("removeIptablesFilterRule", RemoveIptablesFilterRule),
106         DECLARE_NAPI_FUNCTION("listIptablesFilterRules", ListIptablesFilterRules),
107 
108         DECLARE_NAPI_FUNCTION("addFirewallRule", AddFirewallRule),
109         DECLARE_NAPI_FUNCTION("removeFirewallRule", RemoveFirewallRule),
110         DECLARE_NAPI_FUNCTION("getFirewallRules", GetFirewallRules),
111 
112         DECLARE_NAPI_FUNCTION("addDomainFilterRule", AddDomainFilterRule),
113         DECLARE_NAPI_FUNCTION("removeDomainFilterRule", RemoveDomainFilterRule),
114         DECLARE_NAPI_FUNCTION("getDomainFilterRules", GetDomainFilterRules),
115 
116         DECLARE_NAPI_FUNCTION("setGlobalProxy", SetGlobalHttpProxy),
117         DECLARE_NAPI_FUNCTION("getGlobalProxy", GetGlobalHttpProxy),
118     };
119     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
120     return exports;
121 }
122 
GetAllNetworkInterfaces(napi_env env,napi_callback_info info)123 napi_value NetworkManagerAddon::GetAllNetworkInterfaces(napi_env env, napi_callback_info info)
124 {
125     size_t argc = ARGS_SIZE_TWO;
126     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
127     napi_value thisArg = nullptr;
128     void *data = nullptr;
129     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
130     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
131     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
132     if (argc > ARGS_SIZE_ONE) {
133         matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
134     }
135     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
136     auto asyncCallbackInfo = new (std::nothrow) AsyncNetworkInterfacesCallbackInfo();
137     if (asyncCallbackInfo == nullptr) {
138         return nullptr;
139     }
140     std::unique_ptr<AsyncNetworkInterfacesCallbackInfo> callbackPtr{asyncCallbackInfo};
141     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
142         "element name param error");
143     EDMLOGD(
144         "GetAllNetworkInterfaces: asyncCallbackInfo->elementName.bundlename %{public}s, "
145         "asyncCallbackInfo->abilityname:%{public}s",
146         asyncCallbackInfo->elementName.GetBundleName().c_str(),
147         asyncCallbackInfo->elementName.GetAbilityName().c_str());
148     if (argc > ARGS_SIZE_ONE) {
149         EDMLOGD("NAPI_GetAllNetworkInterfaces argc == ARGS_SIZE_TWO");
150         napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
151     }
152     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetAllNetworkInterface",
153         NativeGetAllNetworkInterfaces, NativeArrayStringCallbackComplete);
154     callbackPtr.release();
155     return asyncWorkReturn;
156 }
157 
NativeGetAllNetworkInterfaces(napi_env env,void * data)158 void NetworkManagerAddon::NativeGetAllNetworkInterfaces(napi_env env, void *data)
159 {
160     EDMLOGI("NAPI_NativeGetAllNetworkInterfaces called");
161     if (data == nullptr) {
162         EDMLOGE("data is nullptr");
163         return;
164     }
165     AsyncNetworkInterfacesCallbackInfo *asyncCallbackInfo = static_cast<AsyncNetworkInterfacesCallbackInfo *>(data);
166     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
167     if (networkManagerProxy == nullptr) {
168         EDMLOGE("can not get GetNetworkManagerProxy");
169         return;
170     }
171     asyncCallbackInfo->ret =
172         networkManagerProxy->GetAllNetworkInterfaces(asyncCallbackInfo->elementName, asyncCallbackInfo->arrayStringRet);
173 }
174 
GetIpAddress(napi_env env,napi_callback_info info)175 napi_value NetworkManagerAddon::GetIpAddress(napi_env env, napi_callback_info info)
176 {
177     EDMLOGI("NetworkManagerAddon::GetIpAddress called");
178     return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_IP_ADDRESS);
179 }
180 
GetMac(napi_env env,napi_callback_info info)181 napi_value NetworkManagerAddon::GetMac(napi_env env, napi_callback_info info)
182 {
183     EDMLOGI("NetworkManagerAddon::GetMac called");
184     return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_MAC);
185 }
186 
GetIpOrMacAddress(napi_env env,napi_callback_info info,int policyCode)187 napi_value NetworkManagerAddon::GetIpOrMacAddress(napi_env env, napi_callback_info info, int policyCode)
188 {
189     size_t argc = ARGS_SIZE_THREE;
190     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
191     napi_value thisArg = nullptr;
192     void *data = nullptr;
193     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
194     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
195     bool matchFlag =
196         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
197     if (argc > ARGS_SIZE_TWO) {
198         matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_TWO], napi_function);
199     }
200     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
201     auto asyncCallbackInfo = new (std::nothrow) AsyncNetworkInfoCallbackInfo();
202     if (asyncCallbackInfo == nullptr) {
203         return nullptr;
204     }
205     std::unique_ptr<AsyncNetworkInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
206     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
207         "element name param error");
208     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->networkInterface, argv[ARR_INDEX_ONE]),
209         "parameter networkInterface error");
210     EDMLOGD(
211         "GetIpOrMacAddress: asyncCallbackInfo->elementName.bundlename %{public}s, "
212         "asyncCallbackInfo->abilityname:%{public}s",
213         asyncCallbackInfo->elementName.GetBundleName().c_str(),
214         asyncCallbackInfo->elementName.GetAbilityName().c_str());
215     if (argc > ARGS_SIZE_TWO) {
216         EDMLOGD("NAPI_GetIpOrMacAddress argc == ARGS_SIZE_THREE");
217         napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
218     }
219     asyncCallbackInfo->policyCode = policyCode;
220     napi_value asyncWorkReturn =
221         HandleAsyncWork(env, asyncCallbackInfo, "GetIpAddress", NativeGetIpOrMacAddress, NativeStringCallbackComplete);
222     callbackPtr.release();
223     return asyncWorkReturn;
224 }
225 
NativeGetIpOrMacAddress(napi_env env,void * data)226 void NetworkManagerAddon::NativeGetIpOrMacAddress(napi_env env, void *data)
227 {
228     EDMLOGI("NAPI_NativeGetIpOrMacAddress called");
229     if (data == nullptr) {
230         EDMLOGE("data is nullptr");
231         return;
232     }
233     AsyncNetworkInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncNetworkInfoCallbackInfo *>(data);
234     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
235     if (networkManagerProxy == nullptr) {
236         EDMLOGE("can not get GetNetworkManagerProxy");
237         return;
238     }
239     asyncCallbackInfo->ret = networkManagerProxy->GetIpOrMacAddress(asyncCallbackInfo->elementName,
240         asyncCallbackInfo->networkInterface, asyncCallbackInfo->policyCode, asyncCallbackInfo->stringRet);
241 }
242 
SetNetworkInterfaceDisabled(napi_env env,napi_callback_info info)243 napi_value NetworkManagerAddon::SetNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
244 {
245     size_t argc = ARGS_SIZE_FOUR;
246     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
247     napi_value thisArg = nullptr;
248     void *data = nullptr;
249     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
250     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
251     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
252         MatchValueType(env, argv[ARR_INDEX_ONE], napi_string) && MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean);
253     if (argc > ARGS_SIZE_THREE) {
254         matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_THREE], napi_function);
255     }
256     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
257     auto asyncCallbackInfo = new (std::nothrow) AsyncSetNetworkInterfaceCallbackInfo();
258     if (asyncCallbackInfo == nullptr) {
259         return nullptr;
260     }
261     std::unique_ptr<AsyncSetNetworkInterfaceCallbackInfo> callbackPtr{asyncCallbackInfo};
262     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
263         "parameter element name error");
264     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->networkInterface, argv[ARR_INDEX_ONE]),
265         "parameter networkInterface error");
266     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, asyncCallbackInfo->isDisabled, argv[ARR_INDEX_TWO]),
267         "parameter isDisabled error");
268     EDMLOGD(
269         "SetNetworkInterfaceDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
270         "asyncCallbackInfo->abilityname:%{public}s",
271         asyncCallbackInfo->elementName.GetBundleName().c_str(),
272         asyncCallbackInfo->elementName.GetAbilityName().c_str());
273     if (argc > ARGS_SIZE_THREE) {
274         EDMLOGD("NAPI_SetNetworkInterfaceDisabled argc == ARGS_SIZE_FOUR");
275         napi_create_reference(env, argv[ARGS_SIZE_THREE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
276     }
277     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetNetworkInterfaceDisabled",
278         NativeSetNetworkInterfaceDisabled, NativeVoidCallbackComplete);
279     callbackPtr.release();
280     return asyncWorkReturn;
281 }
282 
NativeSetNetworkInterfaceDisabled(napi_env env,void * data)283 void NetworkManagerAddon::NativeSetNetworkInterfaceDisabled(napi_env env, void *data)
284 {
285     EDMLOGI("NAPI_NativeSetNetworkInterfaceDisabled called");
286     if (data == nullptr) {
287         EDMLOGE("data is nullptr");
288         return;
289     }
290     AsyncSetNetworkInterfaceCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetNetworkInterfaceCallbackInfo *>(data);
291     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
292     if (networkManagerProxy == nullptr) {
293         EDMLOGE("can not get GetNetworkManagerProxy");
294         return;
295     }
296     asyncCallbackInfo->ret = networkManagerProxy->SetNetworkInterfaceDisabled(asyncCallbackInfo->elementName,
297         asyncCallbackInfo->networkInterface, asyncCallbackInfo->isDisabled);
298 }
299 
IsNetworkInterfaceDisabled(napi_env env,napi_callback_info info)300 napi_value NetworkManagerAddon::IsNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
301 {
302     size_t argc = ARGS_SIZE_THREE;
303     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
304     napi_value thisArg = nullptr;
305     void *data = nullptr;
306     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
307     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
308     bool matchFlag =
309         MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
310     if (argc > ARGS_SIZE_TWO) {
311         matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_TWO], napi_function);
312     }
313     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
314     auto asyncCallbackInfo = new (std::nothrow) AsyncNetworkInfoCallbackInfo();
315     if (asyncCallbackInfo == nullptr) {
316         return nullptr;
317     }
318     std::unique_ptr<AsyncNetworkInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
319     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
320         "parameter element name error");
321     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->networkInterface, argv[ARR_INDEX_ONE]),
322         "parameter networkInterface error");
323     EDMLOGD(
324         "IsNetworkInterfaceDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
325         "asyncCallbackInfo->abilityname:%{public}s",
326         asyncCallbackInfo->elementName.GetBundleName().c_str(),
327         asyncCallbackInfo->elementName.GetAbilityName().c_str());
328     if (argc > ARGS_SIZE_TWO) {
329         EDMLOGD("NAPI_IsNetworkInterfaceDisabled argc == ARGS_SIZE_THREE");
330         napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
331     }
332     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "IsNetworkInterfaceDisabled",
333         NativeIsNetworkInterfaceDisabled, NativeBoolCallbackComplete);
334     callbackPtr.release();
335     return asyncWorkReturn;
336 }
337 
NativeIsNetworkInterfaceDisabled(napi_env env,void * data)338 void NetworkManagerAddon::NativeIsNetworkInterfaceDisabled(napi_env env, void *data)
339 {
340     EDMLOGI("NAPI_NativeIsNetworkInterfaceDisabled called");
341     if (data == nullptr) {
342         EDMLOGE("data is nullptr");
343         return;
344     }
345     AsyncNetworkInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncNetworkInfoCallbackInfo *>(data);
346     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
347     if (networkManagerProxy == nullptr) {
348         EDMLOGE("can not get GetNetworkManagerProxy");
349         return;
350     }
351     asyncCallbackInfo->ret = networkManagerProxy->IsNetworkInterfaceDisabled(asyncCallbackInfo->elementName,
352         asyncCallbackInfo->networkInterface, asyncCallbackInfo->boolRet);
353 }
354 
AddIptablesFilterRule(napi_env env,napi_callback_info info)355 napi_value NetworkManagerAddon::AddIptablesFilterRule(napi_env env, napi_callback_info info)
356 {
357     EDMLOGI("NetworkManagerAddon::AddIptablesFilterRule called");
358     size_t argc = ARGS_SIZE_THREE;
359     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
360     napi_value thisArg = nullptr;
361     void *data = nullptr;
362     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
363     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
364     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
365     matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
366     if (argc > ARGS_SIZE_TWO) {
367         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
368     }
369     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
370     auto asyncCallbackInfo = new (std::nothrow) AsyncIptablesCallbackInfo();
371     if (asyncCallbackInfo == nullptr) {
372         return nullptr;
373     }
374     std::unique_ptr<AsyncIptablesCallbackInfo> callbackPtr{asyncCallbackInfo};
375     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
376         "element name param error");
377     EDMLOGD(
378         "AddIptalbsFilterRule: asyncCallbackInfo->elementName.bundlename %{public}s, "
379         "asyncCallbackInfo->abilityname:%{public}s",
380         asyncCallbackInfo->elementName.GetBundleName().c_str(),
381         asyncCallbackInfo->elementName.GetAbilityName().c_str());
382     ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToAddFirewallObject(env, argv[ARR_INDEX_ONE], asyncCallbackInfo->addFilter),
383         "addFilter param error");
384     if (argc > ARGS_SIZE_TWO) {
385         EDMLOGD("NAPI_AddIptalbsFilterRule argc == ARGS_SIZE_THREE");
386         napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
387     }
388     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "AddIptablesFilterRule",
389         NativeAddIptalbsFilterRule, NativeVoidCallbackComplete);
390     callbackPtr.release();
391     return asyncWorkReturn;
392 }
393 
JsObjToAddFirewallObject(napi_env env,napi_value object,IPTABLES::AddFilter & filter)394 bool NetworkManagerAddon::JsObjToAddFirewallObject(napi_env env, napi_value object, IPTABLES::AddFilter &filter)
395 {
396     JsObjectToUint(env, object, "ruleNo", false, filter.ruleNo);
397     JsObjectToString(env, object, "srcAddr", false, filter.srcAddr);
398     JsObjectToString(env, object, "destAddr", false, filter.destAddr);
399     JsObjectToString(env, object, "srcPort", false, filter.srcPort);
400     JsObjectToString(env, object, "destPort", false, filter.destPort);
401     JsObjectToString(env, object, "uid", false, filter.uid);
402     int32_t method = -1;
403     if (!JsObjectToInt(env, object, "method", true, method) ||
404         !IPTABLES::IptablesUtils::ProcessFirewallMethod(method, filter.method)) {
405         EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject method trans failed");
406         return false;
407     }
408     int32_t direction = -1;
409     if (!JsObjectToInt(env, object, "direction", true, direction) ||
410         !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, filter.direction)) {
411         EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject direction trans failed");
412         return false;
413     }
414     int32_t action = -1;
415     if (!JsObjectToInt(env, object, "action", true, action) ||
416         !IPTABLES::IptablesUtils::ProcessFirewallAction(action, filter.action)) {
417         EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject action trans failed");
418         return false;
419     }
420     int32_t protocol = -1;
421     JsObjectToInt(env, object, "protocol", false, protocol);
422     IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, filter.protocol);
423     return true;
424 }
425 
NativeAddIptalbsFilterRule(napi_env env,void * data)426 void NetworkManagerAddon::NativeAddIptalbsFilterRule(napi_env env, void *data)
427 {
428     EDMLOGI("NAPI_NativeAddIptalbsFilterRule called");
429     if (data == nullptr) {
430         EDMLOGE("data is nullptr");
431         return;
432     }
433     AsyncIptablesCallbackInfo *asyncCallbackInfo = static_cast<AsyncIptablesCallbackInfo *>(data);
434     asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddIptablesFilterRule(
435         asyncCallbackInfo->elementName, asyncCallbackInfo->addFilter);
436 }
437 
RemoveIptablesFilterRule(napi_env env,napi_callback_info info)438 napi_value NetworkManagerAddon::RemoveIptablesFilterRule(napi_env env, napi_callback_info info)
439 {
440     EDMLOGI("NetworkManagerAddon::RemoveIptablesFilterRule called");
441     size_t argc = ARGS_SIZE_THREE;
442     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
443     napi_value thisArg = nullptr;
444     void *data = nullptr;
445     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
446     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
447     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
448     matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
449     if (argc > ARGS_SIZE_TWO) {
450         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
451     }
452     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
453     auto asyncCallbackInfo = new (std::nothrow) AsyncIptablesCallbackInfo();
454     if (asyncCallbackInfo == nullptr) {
455         return nullptr;
456     }
457     std::unique_ptr<AsyncIptablesCallbackInfo> callbackPtr{asyncCallbackInfo};
458     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
459         "element name param error");
460     EDMLOGD(
461         "RemoveIptablesFilterRule: asyncCallbackInfo->elementName.bundlename %{public}s, "
462         "asyncCallbackInfo->abilityname:%{public}s",
463         asyncCallbackInfo->elementName.GetBundleName().c_str(),
464         asyncCallbackInfo->elementName.GetAbilityName().c_str());
465     ASSERT_AND_THROW_PARAM_ERROR(env,
466         JsObjToRemoveFirewallObject(env, argv[ARR_INDEX_ONE], asyncCallbackInfo->removeFilter), "firewall param error");
467     if (argc > ARGS_SIZE_TWO) {
468         EDMLOGD("NAPI_RemoveIptablesFilterRule argc == ARGS_SIZE_THREE");
469         napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
470     }
471     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "RemoveIptablesFilterRule",
472         NativeRemoveIptalbsFilterRule, NativeVoidCallbackComplete);
473     callbackPtr.release();
474     return asyncWorkReturn;
475 }
476 
JsObjToRemoveFirewallObject(napi_env env,napi_value object,IPTABLES::RemoveFilter & firewall)477 bool NetworkManagerAddon::JsObjToRemoveFirewallObject(napi_env env, napi_value object, IPTABLES::RemoveFilter &firewall)
478 {
479     JsObjectToString(env, object, "srcAddr", false, firewall.srcAddr);
480     JsObjectToString(env, object, "destAddr", false, firewall.destAddr);
481     JsObjectToString(env, object, "srcPort", false, firewall.srcPort);
482     JsObjectToString(env, object, "destPort", false, firewall.destPort);
483     JsObjectToString(env, object, "uid", false, firewall.uid);
484     int32_t direction = -1;
485     if (!JsObjectToInt(env, object, "direction", true, direction) ||
486         !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, firewall.direction)) {
487         EDMLOGE("NAPI_removeIptalbsFilterRule JsObjToRemoveFirewallObject direction trans failed");
488         return false;
489     }
490     int32_t action = -1;
491     JsObjectToInt(env, object, "action", false, action);
492     IPTABLES::IptablesUtils::ProcessFirewallAction(action, firewall.action);
493     int32_t protocol = -1;
494     JsObjectToInt(env, object, "protocol", false, protocol);
495     IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, firewall.protocol);
496     return true;
497 }
498 
NativeRemoveIptalbsFilterRule(napi_env env,void * data)499 void NetworkManagerAddon::NativeRemoveIptalbsFilterRule(napi_env env, void *data)
500 {
501     EDMLOGI("NAPI_NativeRemoveIptalbsFilterRule called");
502     if (data == nullptr) {
503         EDMLOGE("data is nullptr");
504         return;
505     }
506     AsyncIptablesCallbackInfo *asyncCallbackInfo = static_cast<AsyncIptablesCallbackInfo *>(data);
507     auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
508     asyncCallbackInfo->ret =
509         networkManagerProxy->RemoveIptablesFilterRule(asyncCallbackInfo->elementName, asyncCallbackInfo->removeFilter);
510 }
511 
ListIptablesFilterRules(napi_env env,napi_callback_info info)512 napi_value NetworkManagerAddon::ListIptablesFilterRules(napi_env env, napi_callback_info info)
513 {
514     size_t argc = ARGS_SIZE_TWO;
515     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
516     napi_value thisArg = nullptr;
517     void *data = nullptr;
518     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
519     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
520     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
521     if (argc > ARGS_SIZE_ONE) {
522         matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
523     }
524     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
525     auto asyncCallbackInfo = new (std::nothrow) AsyncIptablesCallbackInfo();
526     if (asyncCallbackInfo == nullptr) {
527         return nullptr;
528     }
529     std::unique_ptr<AsyncIptablesCallbackInfo> callbackPtr{asyncCallbackInfo};
530     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
531         "element name param error");
532     EDMLOGD(
533         "ListIptablesFilterRules: asyncCallbackInfo->elementName.bundlename %{public}s, "
534         "asyncCallbackInfo->abilityname:%{public}s",
535         asyncCallbackInfo->elementName.GetBundleName().c_str(),
536         asyncCallbackInfo->elementName.GetAbilityName().c_str());
537     if (argc > ARGS_SIZE_ONE) {
538         EDMLOGD("NAPI_ListIptablesFilterRule argc == ARGS_SIZE_TWO");
539         napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
540     }
541     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "ListIptablesFilterRules",
542         NativeListIptablesFilterRules, NativeStringCallbackComplete);
543     callbackPtr.release();
544     return asyncWorkReturn;
545 }
546 
NativeListIptablesFilterRules(napi_env env,void * data)547 void NetworkManagerAddon::NativeListIptablesFilterRules(napi_env env, void *data)
548 {
549     EDMLOGI("NAPI_NativeListIptablesFilterRule called");
550     if (data == nullptr) {
551         EDMLOGE("data is nullptr");
552         return;
553     }
554     AsyncIptablesCallbackInfo *asyncCallbackInfo = static_cast<AsyncIptablesCallbackInfo *>(data);
555     asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->ListIptablesFilterRules(
556         asyncCallbackInfo->elementName, asyncCallbackInfo->stringRet);
557 }
558 
AddFirewallRule(napi_env env,napi_callback_info info)559 napi_value NetworkManagerAddon::AddFirewallRule(napi_env env, napi_callback_info info)
560 {
561     EDMLOGI("AddFirewallRule start");
562     size_t argc = ARGS_SIZE_TWO;
563     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
564     napi_value thisArg = nullptr;
565     void *data = nullptr;
566     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
567     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
568     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
569     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
570     bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
571     ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be FirewallRule.");
572 
573     OHOS::AppExecFwk::ElementName elementName;
574     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
575         "element name param error");
576     IPTABLES::FirewallRule rule = {IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID,
577         IPTABLES::Protocol::INVALID, "", "", "", "", ""};
578     ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToFirewallRule(env, argv[ARR_INDEX_ONE], rule), "firewallRule param error");
579 
580     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddFirewallRule(elementName, rule);
581     if (FAILED(ret)) {
582         napi_throw(env, CreateError(env, ret));
583     }
584     return nullptr;
585 }
586 
RemoveFirewallRule(napi_env env,napi_callback_info info)587 napi_value NetworkManagerAddon::RemoveFirewallRule(napi_env env, napi_callback_info info)
588 {
589     EDMLOGI("RemoveFirewallRule start");
590     size_t argc = ARGS_SIZE_TWO;
591     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
592     napi_value thisArg = nullptr;
593     void *data = nullptr;
594     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
595     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
596     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
597     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
598     if (argc >= ARGS_SIZE_TWO) {
599         bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
600         ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be FirewallRule.");
601     }
602     OHOS::AppExecFwk::ElementName elementName;
603     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
604         "element name param error");
605     IPTABLES::FirewallRule rule = {IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID,
606         IPTABLES::Protocol::INVALID, "", "", "", "", ""};
607     if (argc >= ARGS_SIZE_TWO) {
608         ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToFirewallRule(env, argv[ARR_INDEX_ONE], rule),
609             "firewallRule param error");
610     }
611     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->RemoveFirewallRule(elementName, rule);
612     if (FAILED(ret)) {
613         napi_throw(env, CreateError(env, ret));
614     }
615     return nullptr;
616 }
617 
GetFirewallRules(napi_env env,napi_callback_info info)618 napi_value NetworkManagerAddon::GetFirewallRules(napi_env env, napi_callback_info info)
619 {
620     size_t argc = ARGS_SIZE_TWO;
621     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
622     napi_value thisArg = nullptr;
623     void *data = nullptr;
624     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
625     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
626     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
627     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
628 
629     OHOS::AppExecFwk::ElementName elementName;
630     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
631         "element name param error");
632     std::vector<IPTABLES::FirewallRule> result;
633     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetFirewallRules(elementName, result);
634     if (FAILED(ret)) {
635         napi_throw(env, CreateError(env, ret));
636         return nullptr;
637     }
638     napi_value jsList = nullptr;
639     NAPI_CALL(env, napi_create_array_with_length(env, result.size(), &jsList));
640     for (size_t i = 0; i < result.size(); i++) {
641         napi_value item = FirewallRuleToJsObj(env, result[i]);
642         NAPI_CALL(env, napi_set_element(env, jsList, i, item));
643     }
644     return jsList;
645 }
646 
JsObjToFirewallRule(napi_env env,napi_value object,IPTABLES::FirewallRule & rule)647 bool NetworkManagerAddon::JsObjToFirewallRule(napi_env env, napi_value object, IPTABLES::FirewallRule &rule)
648 {
649     int32_t direction = -1;
650     JsObjectToInt(env, object, "direction", false, direction);
651     EDMLOGI("JsObjToFirewallRule direction %{pubilc}d", direction);
652     IPTABLES::Direction directionEnum = IPTABLES::Direction::INVALID;
653     IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, directionEnum);
654 
655     int32_t action = -1;
656     JsObjectToInt(env, object, "action", false, action);
657     EDMLOGI("JsObjToFirewallRule action %{pubilc}d", action);
658     IPTABLES::Action actionEnum = IPTABLES::Action::INVALID;
659     IPTABLES::IptablesUtils::ProcessFirewallAction(action, actionEnum);
660 
661     int32_t protocol = -1;
662     JsObjectToInt(env, object, "protocol", false, protocol);
663     EDMLOGI("JsObjToFirewallRule protocol %{pubilc}d", protocol);
664     IPTABLES::Protocol protocolEnum = IPTABLES::Protocol::INVALID;
665     IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, protocolEnum);
666 
667     std::string srcAddr;
668     JsObjectToString(env, object, "srcAddr", false, srcAddr);
669 
670     std::string destAddr;
671     JsObjectToString(env, object, "destAddr", false, destAddr);
672 
673     std::string srcPort;
674     JsObjectToString(env, object, "srcPort", false, srcPort);
675 
676     std::string destPort;
677     JsObjectToString(env, object, "destPort", false, destPort);
678 
679     std::string appUid;
680     JsObjectToString(env, object, "appUid", false, appUid);
681     rule = {directionEnum, actionEnum, protocolEnum, srcAddr, destAddr, srcPort, destPort, appUid};
682     return true;
683 }
684 
FirewallRuleToJsObj(napi_env env,const IPTABLES::FirewallRule & rule)685 napi_value NetworkManagerAddon::FirewallRuleToJsObj(napi_env env, const IPTABLES::FirewallRule &rule)
686 {
687     napi_value jsRule = nullptr;
688     NAPI_CALL(env, napi_create_object(env, &jsRule));
689 
690     napi_value direction = nullptr;
691     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_DICECTION_IND>(rule)), &direction));
692     napi_value action = nullptr;
693     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_ACTION_IND>(rule)), &action));
694     napi_value protocol = nullptr;
695     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_PROT_IND>(rule)), &protocol));
696     napi_value srcAddr = nullptr;
697     std::string srcAddrStr = std::get<FIREWALL_SRCADDR_IND>(rule);
698     NAPI_CALL(env, napi_create_string_utf8(env, srcAddrStr.c_str(), srcAddrStr.length(), &srcAddr));
699     napi_value destAddr = nullptr;
700     std::string destAddrStr = std::get<FIREWALL_DESTADDR_IND>(rule);
701     NAPI_CALL(env, napi_create_string_utf8(env, destAddrStr.c_str(), destAddrStr.length(), &destAddr));
702     napi_value srcPort = nullptr;
703     std::string srcPortStr = std::get<FIREWALL_SRCPORT_IND>(rule);
704     NAPI_CALL(env, napi_create_string_utf8(env, srcPortStr.c_str(), srcPortStr.length(), &srcPort));
705     napi_value destPort = nullptr;
706     std::string destPortStr = std::get<FIREWALL_DESTPORT_IND>(rule);
707     NAPI_CALL(env, napi_create_string_utf8(env, destPortStr.c_str(), destPortStr.length(), &destPort));
708     napi_value appUid = nullptr;
709     std::string appUidStr = std::get<FIREWALL_APPUID_IND>(rule);
710     NAPI_CALL(env, napi_create_string_utf8(env, appUidStr.c_str(), appUidStr.length(), &appUid));
711 
712     NAPI_CALL(env, napi_set_named_property(env, jsRule, "direction", direction));
713     NAPI_CALL(env, napi_set_named_property(env, jsRule, "action", action));
714     NAPI_CALL(env, napi_set_named_property(env, jsRule, "protocol", protocol));
715     NAPI_CALL(env, napi_set_named_property(env, jsRule, "srcAddr", srcAddr));
716     NAPI_CALL(env, napi_set_named_property(env, jsRule, "destAddr", destAddr));
717     NAPI_CALL(env, napi_set_named_property(env, jsRule, "srcPort", srcPort));
718     NAPI_CALL(env, napi_set_named_property(env, jsRule, "destPort", destPort));
719     NAPI_CALL(env, napi_set_named_property(env, jsRule, "appUid", appUid));
720     return jsRule;
721 }
722 
AddDomainFilterRule(napi_env env,napi_callback_info info)723 napi_value NetworkManagerAddon::AddDomainFilterRule(napi_env env, napi_callback_info info)
724 {
725     size_t argc = ARGS_SIZE_TWO;
726     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
727     napi_value thisArg = nullptr;
728     void *data = nullptr;
729     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
730     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
731     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
732     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
733     bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
734     ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be DomainFilterRule.");
735 
736     OHOS::AppExecFwk::ElementName elementName;
737     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
738         "element name param error");
739     IPTABLES::DomainFilterRule rule = {IPTABLES::Action::INVALID, "", ""};
740     ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToDomainFilterRule(env, argv[ARR_INDEX_ONE], rule),
741         "DomainFilterRule param error");
742     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddDomainFilterRule(elementName, rule);
743     if (FAILED(ret)) {
744         napi_throw(env, CreateError(env, ret));
745     }
746     return nullptr;
747 }
748 
RemoveDomainFilterRule(napi_env env,napi_callback_info info)749 napi_value NetworkManagerAddon::RemoveDomainFilterRule(napi_env env, napi_callback_info info)
750 {
751     size_t argc = ARGS_SIZE_TWO;
752     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
753     napi_value thisArg = nullptr;
754     void *data = nullptr;
755     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
756     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
757     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
758     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
759     if (argc >= ARGS_SIZE_TWO) {
760         bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
761         ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be DomainFilterRule.");
762     }
763 
764     OHOS::AppExecFwk::ElementName elementName;
765     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
766         "element name param error");
767     IPTABLES::DomainFilterRule rule = {IPTABLES::Action::INVALID, "", ""};
768     if (argc >= ARGS_SIZE_TWO) {
769         ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToDomainFilterRule(env, argv[ARR_INDEX_ONE], rule),
770             "DomainFilterRule param error");
771     }
772 
773     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->RemoveDomainFilterRule(elementName, rule);
774     if (FAILED(ret)) {
775         napi_throw(env, CreateError(env, ret));
776     }
777     return nullptr;
778 }
779 
GetDomainFilterRules(napi_env env,napi_callback_info info)780 napi_value NetworkManagerAddon::GetDomainFilterRules(napi_env env, napi_callback_info info)
781 {
782     size_t argc = ARGS_SIZE_TWO;
783     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
784     napi_value thisArg = nullptr;
785     void *data = nullptr;
786     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
787     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
788     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
789     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
790 
791     OHOS::AppExecFwk::ElementName elementName;
792     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
793         "element name param error");
794     std::vector<IPTABLES::DomainFilterRule> result;
795     int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetDomainFilterRules(elementName, result);
796     if (FAILED(ret)) {
797         napi_throw(env, CreateError(env, ret));
798         return nullptr;
799     }
800     napi_value jsList = nullptr;
801     NAPI_CALL(env, napi_create_array_with_length(env, result.size(), &jsList));
802     for (size_t i = 0; i < result.size(); i++) {
803         napi_value item = DomainFilterRuleToJsObj(env, result[i]);
804         NAPI_CALL(env, napi_set_element(env, jsList, i, item));
805     }
806     return jsList;
807 }
808 
JsObjToDomainFilterRule(napi_env env,napi_value object,IPTABLES::DomainFilterRule & rule)809 bool NetworkManagerAddon::JsObjToDomainFilterRule(napi_env env, napi_value object, IPTABLES::DomainFilterRule &rule)
810 {
811     int32_t action = -1;
812     JsObjectToInt(env, object, "action", false, action);
813     IPTABLES::Action actionEnum = IPTABLES::Action::INVALID;
814     IPTABLES::IptablesUtils::ProcessFirewallAction(action, actionEnum);
815 
816     std::string appUid;
817     JsObjectToString(env, object, "appUid", false, appUid);
818 
819     std::string domainName;
820     JsObjectToString(env, object, "domainName", false, domainName);
821 
822     rule = {actionEnum, appUid, domainName};
823     return true;
824 }
825 
DomainFilterRuleToJsObj(napi_env env,const IPTABLES::DomainFilterRule & rule)826 napi_value NetworkManagerAddon::DomainFilterRuleToJsObj(napi_env env, const IPTABLES::DomainFilterRule &rule)
827 {
828     napi_value jsRule = nullptr;
829     NAPI_CALL(env, napi_create_object(env, &jsRule));
830 
831     napi_value action = nullptr;
832     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<DOMAIN_ACTION_IND>(rule)), &action));
833     napi_value appUid = nullptr;
834     std::string appUidStr = std::get<DOMAIN_APPUID_IND>(rule);
835     NAPI_CALL(env, napi_create_string_utf8(env, appUidStr.c_str(), appUidStr.length(), &appUid));
836     napi_value domainName = nullptr;
837     std::string domainNameStr = std::get<DOMAIN_DOMAINNAME_IND>(rule);
838     NAPI_CALL(env, napi_create_string_utf8(env, domainNameStr.c_str(), domainNameStr.length(), &domainName));
839 
840     NAPI_CALL(env, napi_set_named_property(env, jsRule, "action", action));
841     NAPI_CALL(env, napi_set_named_property(env, jsRule, "appUid", appUid));
842     NAPI_CALL(env, napi_set_named_property(env, jsRule, "domainName", domainName));
843     return jsRule;
844 }
845 
SetGlobalHttpProxy(napi_env env,napi_callback_info info)846 napi_value NetworkManagerAddon::SetGlobalHttpProxy(napi_env env, napi_callback_info info)
847 {
848     size_t argc = ARGS_SIZE_THREE;
849     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
850     napi_value thisArg = nullptr;
851     void *data = nullptr;
852     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
853     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
854 
855     bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
856     ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "parameter admin error");
857 
858     bool isHttpProxy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
859     ASSERT_AND_THROW_PARAM_ERROR(env, isHttpProxy, "parameter http proxy error");
860 
861     if (argc > ARGS_SIZE_TWO) {
862         bool hasCallback = MatchValueType(env, argv[ARGS_SIZE_TWO], napi_function);
863         ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "parameter callback error");
864     }
865 
866     auto asyncCallbackInfo = new (std::nothrow) AsyncHttpProxyCallbackInfo();
867     if (asyncCallbackInfo == nullptr) {
868         return nullptr;
869     }
870     std::unique_ptr<AsyncHttpProxyCallbackInfo> callbackPtr{asyncCallbackInfo};
871     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
872         "parameter element name error");
873     bool parseRet = ParseHttpProxyParam(env, argv[ARR_INDEX_ONE], asyncCallbackInfo);
874     ASSERT_AND_THROW_PARAM_ERROR(env, parseRet, "ParseHttpProxyParam error");
875     if (argc > ARGS_SIZE_TWO) {
876         EDMLOGD("NAPI_IsNetworkInterfaceDisabled argc == ARGS_SIZE_THREE");
877         napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
878     }
879     napi_value asyncWorkReturn =
880         HandleAsyncWork(env, asyncCallbackInfo, "setGlobalProxy", NativeSetGlobalHttpProxy, NativeVoidCallbackComplete);
881     callbackPtr.release();
882     return asyncWorkReturn;
883 }
884 
ParseHttpProxyParam(napi_env env,napi_value argv,AsyncHttpProxyCallbackInfo * callbackInfo)885 bool NetworkManagerAddon::ParseHttpProxyParam(napi_env env, napi_value argv, AsyncHttpProxyCallbackInfo *callbackInfo)
886 {
887     std::string host;
888     if (!JsObjectToString(env, argv, HOST_PROP_NAME, false, host)) {
889         EDMLOGE("error host value");
890         return false;
891     }
892     std::int32_t port = 0;
893     if (!JsObjectToInt(env, argv, PORT_PROP_NAME, false, port)) {
894         EDMLOGE("error port value");
895         return false;
896     }
897     std::vector<std::string> exclusionList;
898     if (!JsObjectToStringVector(env, argv, EXCLUSION_LIST_PROP_NAME, false, exclusionList)) {
899         EDMLOGE("error exclusionList value");
900         return false;
901     }
902 
903     callbackInfo->httpProxy.SetHost(host.c_str());
904     callbackInfo->httpProxy.SetPort(port);
905     std::list<std::string> dataList;
906     for (const auto &item : exclusionList) {
907         dataList.emplace_back(item);
908     }
909     callbackInfo->httpProxy.SetExclusionList(dataList);
910     return true;
911 }
912 
NativeSetGlobalHttpProxy(napi_env env,void * data)913 void NetworkManagerAddon::NativeSetGlobalHttpProxy(napi_env env, void *data)
914 {
915     EDMLOGI("NAPI_NativeSetGlobalHttpProxycalled");
916     if (data == nullptr) {
917         EDMLOGE("data is nullptr");
918         return;
919     }
920     AsyncHttpProxyCallbackInfo *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
921     asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->SetGlobalHttpProxy(
922         asyncCallbackInfo->elementName, asyncCallbackInfo->httpProxy);
923 }
924 
ConvertHttpProxyToJS(napi_env env,const OHOS::NetManagerStandard::HttpProxy & httpProxy)925 napi_value NetworkManagerAddon::ConvertHttpProxyToJS(napi_env env, const OHOS::NetManagerStandard::HttpProxy &httpProxy)
926 {
927     napi_value proxy = nullptr;
928     NAPI_CALL(env, napi_create_object(env, &proxy));
929     napi_value host = nullptr;
930     NAPI_CALL(env, napi_create_string_utf8(env, httpProxy.GetHost().c_str(), httpProxy.GetHost().length(), &host));
931     napi_value port = nullptr;
932     NAPI_CALL(env, napi_create_int32(env, httpProxy.GetPort(), &port));
933     napi_value list = nullptr;
934     if (httpProxy.GetExclusionList().empty()) {
935         NAPI_CALL(env, napi_create_array(env, &list));
936     } else {
937         std::list<std::string> tempList = httpProxy.GetExclusionList();
938         NAPI_CALL(env, napi_create_array_with_length(env, tempList.size(), &list));
939         size_t index = 0;
940         for (const auto &item : tempList) {
941             napi_value ip = nullptr;
942             NAPI_CALL(env, napi_create_string_utf8(env, item.c_str(), item.length(), &ip));
943             NAPI_CALL(env, napi_set_element(env, list, index++, ip));
944         }
945     }
946     NAPI_CALL(env, napi_set_named_property(env, proxy, HOST_PROP_NAME, host));
947     NAPI_CALL(env, napi_set_named_property(env, proxy, PORT_PROP_NAME, port));
948     NAPI_CALL(env, napi_set_named_property(env, proxy, EXCLUSION_LIST_PROP_NAME, list));
949     return proxy;
950 }
951 
GetGlobalHttpProxy(napi_env env,napi_callback_info info)952 napi_value NetworkManagerAddon::GetGlobalHttpProxy(napi_env env, napi_callback_info info)
953 {
954     size_t argc = ARGS_SIZE_TWO;
955     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
956     napi_value thisArg = nullptr;
957     void *data = nullptr;
958     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
959     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
960     auto asyncCallbackInfo = new (std::nothrow) AsyncHttpProxyCallbackInfo();
961     if (asyncCallbackInfo == nullptr) {
962         return nullptr;
963     }
964     std::unique_ptr<AsyncHttpProxyCallbackInfo> callbackPtr{asyncCallbackInfo};
965     bool matchValue = false;
966     if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
967         asyncCallbackInfo->hasAdmin = false;
968         matchValue = true;
969     } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
970         asyncCallbackInfo->hasAdmin = true;
971         matchValue = true;
972     }
973     if (argc > ARGS_SIZE_ONE) {
974         matchValue = matchValue && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
975     }
976     ASSERT_AND_THROW_PARAM_ERROR(env, matchValue, "parameter type error");
977     if (asyncCallbackInfo->hasAdmin) {
978         ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
979             "element name param error");
980         EDMLOGD(
981             "GetGlobalHttpProxy: asyncCallbackInfo->elementName.bundlename %{public}s, "
982             "asyncCallbackInfo->abilityname:%{public}s",
983             asyncCallbackInfo->elementName.GetBundleName().c_str(),
984             asyncCallbackInfo->elementName.GetAbilityName().c_str());
985     }
986     if (argc > ARGS_SIZE_ONE) {
987         EDMLOGD("NAPI_GetGlobalHttpProxy argc == ARGS_SIZE_TWO");
988         napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
989     }
990     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "NativeGetGlobalHttpProxy",
991         NativeGetGlobalHttpProxy, NativeHttpProxyCallbackComplete);
992     callbackPtr.release();
993     return asyncWorkReturn;
994 }
995 
NativeGetGlobalHttpProxy(napi_env env,void * data)996 void NetworkManagerAddon::NativeGetGlobalHttpProxy(napi_env env, void *data)
997 {
998     EDMLOGI("NAPI_NativeGetGlobalHttpProxy called");
999     if (data == nullptr) {
1000         EDMLOGE("data is nullptr");
1001         return;
1002     }
1003     AsyncHttpProxyCallbackInfo *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
1004 
1005     if (asyncCallbackInfo->hasAdmin) {
1006         asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(
1007             &asyncCallbackInfo->elementName, asyncCallbackInfo->httpProxy);
1008     } else {
1009         asyncCallbackInfo->ret =
1010             NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(nullptr, asyncCallbackInfo->httpProxy);
1011     }
1012 }
1013 
NativeHttpProxyCallbackComplete(napi_env env,napi_status status,void * data)1014 void NetworkManagerAddon::NativeHttpProxyCallbackComplete(napi_env env, napi_status status, void *data)
1015 {
1016     EDMLOGD("NativeHttpProxyCallbackComplete start");
1017     if (data == nullptr) {
1018         EDMLOGE("data is nullptr");
1019         return;
1020     }
1021     auto *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
1022     if (asyncCallbackInfo->deferred != nullptr) {
1023         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
1024         if (asyncCallbackInfo->ret == ERR_OK) {
1025             napi_value jsHttpProxy = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
1026             napi_resolve_deferred(env, asyncCallbackInfo->deferred, jsHttpProxy);
1027         } else {
1028             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
1029         }
1030     } else {
1031         napi_value callbackValue[ARGS_SIZE_TWO] = {0};
1032         if (asyncCallbackInfo->ret == ERR_OK) {
1033             napi_get_null(env, &callbackValue[ARR_INDEX_ZERO]);
1034             callbackValue[ARR_INDEX_ONE] = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
1035         } else {
1036             callbackValue[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
1037             napi_get_null(env, &callbackValue[ARR_INDEX_ONE]);
1038         }
1039         napi_value callback = nullptr;
1040         napi_value result = nullptr;
1041         napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
1042         napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
1043         napi_delete_reference(env, asyncCallbackInfo->callback);
1044     }
1045     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1046     delete asyncCallbackInfo;
1047 }
1048 
1049 static napi_module g_networkManagerModule = {
1050     .nm_version = 1,
1051     .nm_flags = 0,
1052     .nm_filename = nullptr,
1053     .nm_register_func = NetworkManagerAddon::Init,
1054     .nm_modname = "enterprise.networkManager",
1055     .nm_priv = ((void *)0),
1056     .reserved = {0},
1057 };
1058 
NetworkManagerRegister()1059 extern "C" __attribute__((constructor)) void NetworkManagerRegister()
1060 {
1061     napi_module_register(&g_networkManagerModule);
1062 }