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