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
24 const char *const HOST_PROP_NAME = "host";
25 const char *const PORT_PROP_NAME = "port";
26 const char *const EXCLUSION_LIST_PROP_NAME = "exclusionList";
27
CreateFirewallActionObject(napi_env env,napi_value value)28 void NetworkManagerAddon::CreateFirewallActionObject(napi_env env, napi_value value)
29 {
30 napi_value nAllow;
31 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::ALLOW), &nAllow));
32 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALLOW", nAllow));
33 napi_value nDeny;
34 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::DENY), &nDeny));
35 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DENY", nDeny));
36 }
37
CreateFirewallProtocolObject(napi_env env,napi_value value)38 void NetworkManagerAddon::CreateFirewallProtocolObject(napi_env env, napi_value value)
39 {
40 napi_value nAll;
41 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ALL), &nAll));
42 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALL", nAll));
43 napi_value nTCP;
44 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::TCP), &nTCP));
45 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TCP", nTCP));
46 napi_value nUDP;
47 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::UDP), &nUDP));
48 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UDP", nUDP));
49 napi_value nICMP;
50 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ICMP), &nICMP));
51 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ICMP", nICMP));
52 }
53
CreateFirewallDirectionObject(napi_env env,napi_value value)54 void NetworkManagerAddon::CreateFirewallDirectionObject(napi_env env, napi_value value)
55 {
56 napi_value nInput;
57 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::INPUT), &nInput));
58 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INPUT", nInput));
59 napi_value nOutput;
60 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::OUTPUT), &nOutput));
61 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "OUTPUT", nOutput));
62 }
63
CreateFirewallAddMethodObject(napi_env env,napi_value value)64 void NetworkManagerAddon::CreateFirewallAddMethodObject(napi_env env, napi_value value)
65 {
66 napi_value nAppend;
67 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::APPEND), &nAppend));
68 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "APPEND", nAppend));
69 napi_value nInsert;
70 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::INSERT), &nInsert));
71 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INSERT", nInsert));
72 }
73
Init(napi_env env,napi_value exports)74 napi_value NetworkManagerAddon::Init(napi_env env, napi_value exports)
75 {
76 napi_value nFirewallAction = nullptr;
77 NAPI_CALL(env, napi_create_object(env, &nFirewallAction));
78 CreateFirewallActionObject(env, nFirewallAction);
79
80 napi_value nFirewallProtocol = nullptr;
81 NAPI_CALL(env, napi_create_object(env, &nFirewallProtocol));
82 CreateFirewallProtocolObject(env, nFirewallProtocol);
83
84 napi_value nFirewallDirection = nullptr;
85 NAPI_CALL(env, napi_create_object(env, &nFirewallDirection));
86 CreateFirewallDirectionObject(env, nFirewallDirection);
87
88 napi_value nFirewallAddMethod = nullptr;
89 NAPI_CALL(env, napi_create_object(env, &nFirewallAddMethod));
90 CreateFirewallAddMethodObject(env, nFirewallAddMethod);
91
92 napi_property_descriptor property[] = {
93 DECLARE_NAPI_FUNCTION("getAllNetworkInterfaces", GetAllNetworkInterfaces),
94 DECLARE_NAPI_FUNCTION("getIpAddress", GetIpAddress),
95 DECLARE_NAPI_FUNCTION("getMac", GetMac),
96 DECLARE_NAPI_FUNCTION("setNetworkInterfaceDisabled", SetNetworkInterfaceDisabled),
97 DECLARE_NAPI_FUNCTION("isNetworkInterfaceDisabled", IsNetworkInterfaceDisabled),
98
99 DECLARE_NAPI_PROPERTY("Action", nFirewallAction),
100 DECLARE_NAPI_PROPERTY("Protocol", nFirewallProtocol),
101 DECLARE_NAPI_PROPERTY("Direction", nFirewallDirection),
102 DECLARE_NAPI_PROPERTY("AddMethod", nFirewallAddMethod),
103 DECLARE_NAPI_FUNCTION("addIptablesFilterRule", AddIptablesFilterRule),
104 DECLARE_NAPI_FUNCTION("removeIptablesFilterRule", RemoveIptablesFilterRule),
105 DECLARE_NAPI_FUNCTION("listIptablesFilterRules", ListIptablesFilterRules),
106
107 DECLARE_NAPI_FUNCTION("setGlobalProxy", SetGlobalHttpProxy),
108 DECLARE_NAPI_FUNCTION("getGlobalProxy", GetGlobalHttpProxy),
109 };
110 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
111 return exports;
112 }
113
GetAllNetworkInterfaces(napi_env env,napi_callback_info info)114 napi_value NetworkManagerAddon::GetAllNetworkInterfaces(napi_env env, napi_callback_info info)
115 {
116 size_t argc = ARGS_SIZE_TWO;
117 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
118 napi_value thisArg = nullptr;
119 void *data = nullptr;
120 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
121 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
122 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
123 if (argc > ARGS_SIZE_ONE) {
124 matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
125 }
126 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
127 auto asyncCallbackInfo = new (std::nothrow) AsyncNetworkInterfacesCallbackInfo();
128 if (asyncCallbackInfo == nullptr) {
129 return nullptr;
130 }
131 std::unique_ptr<AsyncNetworkInterfacesCallbackInfo> callbackPtr{asyncCallbackInfo};
132 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
133 "element name param error");
134 EDMLOGD(
135 "GetAllNetworkInterfaces: asyncCallbackInfo->elementName.bundlename %{public}s, "
136 "asyncCallbackInfo->abilityname:%{public}s",
137 asyncCallbackInfo->elementName.GetBundleName().c_str(),
138 asyncCallbackInfo->elementName.GetAbilityName().c_str());
139 if (argc > ARGS_SIZE_ONE) {
140 EDMLOGD("NAPI_GetAllNetworkInterfaces argc == ARGS_SIZE_TWO");
141 napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
142 }
143 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "GetAllNetworkInterface",
144 NativeGetAllNetworkInterfaces, NativeArrayStringCallbackComplete);
145 callbackPtr.release();
146 return asyncWorkReturn;
147 }
148
NativeGetAllNetworkInterfaces(napi_env env,void * data)149 void NetworkManagerAddon::NativeGetAllNetworkInterfaces(napi_env env, void *data)
150 {
151 EDMLOGI("NAPI_NativeGetAllNetworkInterfaces called");
152 if (data == nullptr) {
153 EDMLOGE("data is nullptr");
154 return;
155 }
156 AsyncNetworkInterfacesCallbackInfo *asyncCallbackInfo = static_cast<AsyncNetworkInterfacesCallbackInfo *>(data);
157 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
158 if (networkManagerProxy == nullptr) {
159 EDMLOGE("can not get GetNetworkManagerProxy");
160 return;
161 }
162 asyncCallbackInfo->ret =
163 networkManagerProxy->GetAllNetworkInterfaces(asyncCallbackInfo->elementName, asyncCallbackInfo->arrayStringRet);
164 }
165
GetIpAddress(napi_env env,napi_callback_info info)166 napi_value NetworkManagerAddon::GetIpAddress(napi_env env, napi_callback_info info)
167 {
168 EDMLOGI("NetworkManagerAddon::GetIpAddress called");
169 return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_IP_ADDRESS);
170 }
171
GetMac(napi_env env,napi_callback_info info)172 napi_value NetworkManagerAddon::GetMac(napi_env env, napi_callback_info info)
173 {
174 EDMLOGI("NetworkManagerAddon::GetMac called");
175 return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_MAC);
176 }
177
GetIpOrMacAddress(napi_env env,napi_callback_info info,int policyCode)178 napi_value NetworkManagerAddon::GetIpOrMacAddress(napi_env env, napi_callback_info info, int policyCode)
179 {
180 size_t argc = ARGS_SIZE_THREE;
181 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
182 napi_value thisArg = nullptr;
183 void *data = nullptr;
184 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
185 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
186 bool matchFlag =
187 MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
188 if (argc > ARGS_SIZE_TWO) {
189 matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_TWO], napi_function);
190 }
191 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
192 auto asyncCallbackInfo = new (std::nothrow) AsyncNetworkInfoCallbackInfo();
193 if (asyncCallbackInfo == nullptr) {
194 return nullptr;
195 }
196 std::unique_ptr<AsyncNetworkInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
197 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
198 "element name param error");
199 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->networkInterface, argv[ARR_INDEX_ONE]),
200 "parameter networkInterface error");
201 EDMLOGD(
202 "GetIpOrMacAddress: asyncCallbackInfo->elementName.bundlename %{public}s, "
203 "asyncCallbackInfo->abilityname:%{public}s",
204 asyncCallbackInfo->elementName.GetBundleName().c_str(),
205 asyncCallbackInfo->elementName.GetAbilityName().c_str());
206 if (argc > ARGS_SIZE_TWO) {
207 EDMLOGD("NAPI_GetIpOrMacAddress argc == ARGS_SIZE_THREE");
208 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
209 }
210 asyncCallbackInfo->policyCode = policyCode;
211 napi_value asyncWorkReturn =
212 HandleAsyncWork(env, asyncCallbackInfo, "GetIpAddress", NativeGetIpOrMacAddress, NativeStringCallbackComplete);
213 callbackPtr.release();
214 return asyncWorkReturn;
215 }
216
NativeGetIpOrMacAddress(napi_env env,void * data)217 void NetworkManagerAddon::NativeGetIpOrMacAddress(napi_env env, void *data)
218 {
219 EDMLOGI("NAPI_NativeGetIpOrMacAddress called");
220 if (data == nullptr) {
221 EDMLOGE("data is nullptr");
222 return;
223 }
224 AsyncNetworkInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncNetworkInfoCallbackInfo *>(data);
225 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
226 if (networkManagerProxy == nullptr) {
227 EDMLOGE("can not get GetNetworkManagerProxy");
228 return;
229 }
230 asyncCallbackInfo->ret = networkManagerProxy->GetIpOrMacAddress(asyncCallbackInfo->elementName,
231 asyncCallbackInfo->networkInterface, asyncCallbackInfo->policyCode, asyncCallbackInfo->stringRet);
232 }
233
SetNetworkInterfaceDisabled(napi_env env,napi_callback_info info)234 napi_value NetworkManagerAddon::SetNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
235 {
236 size_t argc = ARGS_SIZE_FOUR;
237 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
238 napi_value thisArg = nullptr;
239 void *data = nullptr;
240 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
241 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
242 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
243 MatchValueType(env, argv[ARR_INDEX_ONE], napi_string) && MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean);
244 if (argc > ARGS_SIZE_THREE) {
245 matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_THREE], napi_function);
246 }
247 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
248 auto asyncCallbackInfo = new (std::nothrow) AsyncSetNetworkInterfaceCallbackInfo();
249 if (asyncCallbackInfo == nullptr) {
250 return nullptr;
251 }
252 std::unique_ptr<AsyncSetNetworkInterfaceCallbackInfo> callbackPtr{asyncCallbackInfo};
253 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
254 "parameter element name error");
255 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->networkInterface, argv[ARR_INDEX_ONE]),
256 "parameter networkInterface error");
257 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, asyncCallbackInfo->isDisabled, argv[ARR_INDEX_TWO]),
258 "parameter isDisabled error");
259 EDMLOGD(
260 "SetNetworkInterfaceDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
261 "asyncCallbackInfo->abilityname:%{public}s",
262 asyncCallbackInfo->elementName.GetBundleName().c_str(),
263 asyncCallbackInfo->elementName.GetAbilityName().c_str());
264 if (argc > ARGS_SIZE_THREE) {
265 EDMLOGD("NAPI_SetNetworkInterfaceDisabled argc == ARGS_SIZE_FOUR");
266 napi_create_reference(env, argv[ARGS_SIZE_THREE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
267 }
268 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "SetNetworkInterfaceDisabled",
269 NativeSetNetworkInterfaceDisabled, NativeVoidCallbackComplete);
270 callbackPtr.release();
271 return asyncWorkReturn;
272 }
273
NativeSetNetworkInterfaceDisabled(napi_env env,void * data)274 void NetworkManagerAddon::NativeSetNetworkInterfaceDisabled(napi_env env, void *data)
275 {
276 EDMLOGI("NAPI_NativeSetNetworkInterfaceDisabled called");
277 if (data == nullptr) {
278 EDMLOGE("data is nullptr");
279 return;
280 }
281 AsyncSetNetworkInterfaceCallbackInfo *asyncCallbackInfo = static_cast<AsyncSetNetworkInterfaceCallbackInfo *>(data);
282 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
283 if (networkManagerProxy == nullptr) {
284 EDMLOGE("can not get GetNetworkManagerProxy");
285 return;
286 }
287 asyncCallbackInfo->ret = networkManagerProxy->SetNetworkInterfaceDisabled(asyncCallbackInfo->elementName,
288 asyncCallbackInfo->networkInterface, asyncCallbackInfo->isDisabled);
289 }
290
IsNetworkInterfaceDisabled(napi_env env,napi_callback_info info)291 napi_value NetworkManagerAddon::IsNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
292 {
293 size_t argc = ARGS_SIZE_THREE;
294 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
295 napi_value thisArg = nullptr;
296 void *data = nullptr;
297 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
298 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
299 bool matchFlag =
300 MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) && MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
301 if (argc > ARGS_SIZE_TWO) {
302 matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_TWO], napi_function);
303 }
304 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
305 auto asyncCallbackInfo = new (std::nothrow) AsyncNetworkInfoCallbackInfo();
306 if (asyncCallbackInfo == nullptr) {
307 return nullptr;
308 }
309 std::unique_ptr<AsyncNetworkInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
310 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
311 "parameter element name error");
312 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->networkInterface, argv[ARR_INDEX_ONE]),
313 "parameter networkInterface error");
314 EDMLOGD(
315 "IsNetworkInterfaceDisabled: asyncCallbackInfo->elementName.bundlename %{public}s, "
316 "asyncCallbackInfo->abilityname:%{public}s",
317 asyncCallbackInfo->elementName.GetBundleName().c_str(),
318 asyncCallbackInfo->elementName.GetAbilityName().c_str());
319 if (argc > ARGS_SIZE_TWO) {
320 EDMLOGD("NAPI_IsNetworkInterfaceDisabled argc == ARGS_SIZE_THREE");
321 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
322 }
323 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "IsNetworkInterfaceDisabled",
324 NativeIsNetworkInterfaceDisabled, NativeBoolCallbackComplete);
325 callbackPtr.release();
326 return asyncWorkReturn;
327 }
328
NativeIsNetworkInterfaceDisabled(napi_env env,void * data)329 void NetworkManagerAddon::NativeIsNetworkInterfaceDisabled(napi_env env, void *data)
330 {
331 EDMLOGI("NAPI_NativeIsNetworkInterfaceDisabled called");
332 if (data == nullptr) {
333 EDMLOGE("data is nullptr");
334 return;
335 }
336 AsyncNetworkInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncNetworkInfoCallbackInfo *>(data);
337 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
338 if (networkManagerProxy == nullptr) {
339 EDMLOGE("can not get GetNetworkManagerProxy");
340 return;
341 }
342 asyncCallbackInfo->ret = networkManagerProxy->IsNetworkInterfaceDisabled(asyncCallbackInfo->elementName,
343 asyncCallbackInfo->networkInterface, asyncCallbackInfo->boolRet);
344 }
345
AddIptablesFilterRule(napi_env env,napi_callback_info info)346 napi_value NetworkManagerAddon::AddIptablesFilterRule(napi_env env, napi_callback_info info)
347 {
348 EDMLOGI("NetworkManagerAddon::AddIptablesFilterRule called");
349 size_t argc = ARGS_SIZE_THREE;
350 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
351 napi_value thisArg = nullptr;
352 void *data = nullptr;
353 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
354 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
355 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
356 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
357 if (argc > ARGS_SIZE_TWO) {
358 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
359 }
360 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
361 auto asyncCallbackInfo = new (std::nothrow) AsyncIptablesCallbackInfo();
362 if (asyncCallbackInfo == nullptr) {
363 return nullptr;
364 }
365 std::unique_ptr<AsyncIptablesCallbackInfo> callbackPtr{asyncCallbackInfo};
366 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
367 "element name param error");
368 EDMLOGD(
369 "AddIptalbsFilterRule: asyncCallbackInfo->elementName.bundlename %{public}s, "
370 "asyncCallbackInfo->abilityname:%{public}s",
371 asyncCallbackInfo->elementName.GetBundleName().c_str(),
372 asyncCallbackInfo->elementName.GetAbilityName().c_str());
373 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToAddFirewallObject(env, argv[ARR_INDEX_ONE], asyncCallbackInfo->addFilter),
374 "addFilter param error");
375 if (argc > ARGS_SIZE_TWO) {
376 EDMLOGD("NAPI_AddIptalbsFilterRule argc == ARGS_SIZE_THREE");
377 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
378 }
379 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "AddIptablesFilterRule",
380 NativeAddIptalbsFilterRule, NativeVoidCallbackComplete);
381 callbackPtr.release();
382 return asyncWorkReturn;
383 }
384
JsObjToAddFirewallObject(napi_env env,napi_value object,IPTABLES::AddFilter & filter)385 bool NetworkManagerAddon::JsObjToAddFirewallObject(napi_env env, napi_value object, IPTABLES::AddFilter &filter)
386 {
387 JsObjectToUint(env, object, "ruleNo", false, filter.ruleNo);
388 JsObjectToString(env, object, "srcAddr", false, filter.srcAddr);
389 JsObjectToString(env, object, "destAddr", false, filter.destAddr);
390 JsObjectToString(env, object, "srcPort", false, filter.srcPort);
391 JsObjectToString(env, object, "destPort", false, filter.destPort);
392 JsObjectToString(env, object, "uid", false, filter.uid);
393 int32_t method = -1;
394 if (!JsObjectToInt(env, object, "method", true, method) ||
395 !IPTABLES::IptablesUtils::ProcessFirewallMethod(method, filter.method)) {
396 EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject method trans failed");
397 return false;
398 }
399 int32_t direction = -1;
400 if (!JsObjectToInt(env, object, "direction", true, direction) ||
401 !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, filter.direction)) {
402 EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject direction trans failed");
403 return false;
404 }
405 int32_t action = -1;
406 if (!JsObjectToInt(env, object, "action", true, action) ||
407 !IPTABLES::IptablesUtils::ProcessFirewallAction(action, filter.action)) {
408 EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject action trans failed");
409 return false;
410 }
411 int32_t protocol = -1;
412 JsObjectToInt(env, object, "protocol", false, protocol);
413 IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, filter.protocol);
414 return true;
415 }
416
NativeAddIptalbsFilterRule(napi_env env,void * data)417 void NetworkManagerAddon::NativeAddIptalbsFilterRule(napi_env env, void *data)
418 {
419 EDMLOGI("NAPI_NativeAddIptalbsFilterRule called");
420 if (data == nullptr) {
421 EDMLOGE("data is nullptr");
422 return;
423 }
424 AsyncIptablesCallbackInfo *asyncCallbackInfo = static_cast<AsyncIptablesCallbackInfo *>(data);
425 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddIptablesFilterRule(
426 asyncCallbackInfo->elementName, asyncCallbackInfo->addFilter);
427 }
428
RemoveIptablesFilterRule(napi_env env,napi_callback_info info)429 napi_value NetworkManagerAddon::RemoveIptablesFilterRule(napi_env env, napi_callback_info info)
430 {
431 EDMLOGI("NetworkManagerAddon::RemoveIptablesFilterRule called");
432 size_t argc = ARGS_SIZE_THREE;
433 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
434 napi_value thisArg = nullptr;
435 void *data = nullptr;
436 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
437 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
438 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
439 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
440 if (argc > ARGS_SIZE_TWO) {
441 matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
442 }
443 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
444 auto asyncCallbackInfo = new (std::nothrow) AsyncIptablesCallbackInfo();
445 if (asyncCallbackInfo == nullptr) {
446 return nullptr;
447 }
448 std::unique_ptr<AsyncIptablesCallbackInfo> callbackPtr{asyncCallbackInfo};
449 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
450 "element name param error");
451 EDMLOGD(
452 "RemoveIptablesFilterRule: asyncCallbackInfo->elementName.bundlename %{public}s, "
453 "asyncCallbackInfo->abilityname:%{public}s",
454 asyncCallbackInfo->elementName.GetBundleName().c_str(),
455 asyncCallbackInfo->elementName.GetAbilityName().c_str());
456 ASSERT_AND_THROW_PARAM_ERROR(env,
457 JsObjToRemoveFirewallObject(env, argv[ARR_INDEX_ONE], asyncCallbackInfo->removeFilter), "firewall param error");
458 if (argc > ARGS_SIZE_TWO) {
459 EDMLOGD("NAPI_RemoveIptablesFilterRule argc == ARGS_SIZE_THREE");
460 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
461 }
462 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "RemoveIptablesFilterRule",
463 NativeRemoveIptalbsFilterRule, NativeVoidCallbackComplete);
464 callbackPtr.release();
465 return asyncWorkReturn;
466 }
467
JsObjToRemoveFirewallObject(napi_env env,napi_value object,IPTABLES::RemoveFilter & firewall)468 bool NetworkManagerAddon::JsObjToRemoveFirewallObject(napi_env env, napi_value object, IPTABLES::RemoveFilter &firewall)
469 {
470 JsObjectToString(env, object, "srcAddr", false, firewall.srcAddr);
471 JsObjectToString(env, object, "destAddr", false, firewall.destAddr);
472 JsObjectToString(env, object, "srcPort", false, firewall.srcPort);
473 JsObjectToString(env, object, "destPort", false, firewall.destPort);
474 JsObjectToString(env, object, "uid", false, firewall.uid);
475 int32_t direction = -1;
476 if (!JsObjectToInt(env, object, "direction", true, direction) ||
477 !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, firewall.direction)) {
478 EDMLOGE("NAPI_removeIptalbsFilterRule JsObjToRemoveFirewallObject direction trans failed");
479 return false;
480 }
481 int32_t action = -1;
482 JsObjectToInt(env, object, "action", false, action);
483 IPTABLES::IptablesUtils::ProcessFirewallAction(action, firewall.action);
484 int32_t protocol = -1;
485 JsObjectToInt(env, object, "protocol", false, protocol);
486 IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, firewall.protocol);
487 return true;
488 }
489
NativeRemoveIptalbsFilterRule(napi_env env,void * data)490 void NetworkManagerAddon::NativeRemoveIptalbsFilterRule(napi_env env, void *data)
491 {
492 EDMLOGI("NAPI_NativeRemoveIptalbsFilterRule called");
493 if (data == nullptr) {
494 EDMLOGE("data is nullptr");
495 return;
496 }
497 AsyncIptablesCallbackInfo *asyncCallbackInfo = static_cast<AsyncIptablesCallbackInfo *>(data);
498 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
499 asyncCallbackInfo->ret =
500 networkManagerProxy->RemoveIptablesFilterRule(asyncCallbackInfo->elementName, asyncCallbackInfo->removeFilter);
501 }
502
ListIptablesFilterRules(napi_env env,napi_callback_info info)503 napi_value NetworkManagerAddon::ListIptablesFilterRules(napi_env env, napi_callback_info info)
504 {
505 size_t argc = ARGS_SIZE_TWO;
506 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
507 napi_value thisArg = nullptr;
508 void *data = nullptr;
509 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
510 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
511 bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
512 if (argc > ARGS_SIZE_ONE) {
513 matchFlag = matchFlag && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
514 }
515 ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
516 auto asyncCallbackInfo = new (std::nothrow) AsyncIptablesCallbackInfo();
517 if (asyncCallbackInfo == nullptr) {
518 return nullptr;
519 }
520 std::unique_ptr<AsyncIptablesCallbackInfo> callbackPtr{asyncCallbackInfo};
521 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
522 "element name param error");
523 EDMLOGD(
524 "ListIptablesFilterRules: asyncCallbackInfo->elementName.bundlename %{public}s, "
525 "asyncCallbackInfo->abilityname:%{public}s",
526 asyncCallbackInfo->elementName.GetBundleName().c_str(),
527 asyncCallbackInfo->elementName.GetAbilityName().c_str());
528 if (argc > ARGS_SIZE_ONE) {
529 EDMLOGD("NAPI_ListIptablesFilterRule argc == ARGS_SIZE_TWO");
530 napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
531 }
532 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "ListIptablesFilterRules",
533 NativeListIptablesFilterRules, NativeStringCallbackComplete);
534 callbackPtr.release();
535 return asyncWorkReturn;
536 }
537
NativeListIptablesFilterRules(napi_env env,void * data)538 void NetworkManagerAddon::NativeListIptablesFilterRules(napi_env env, void *data)
539 {
540 EDMLOGI("NAPI_NativeListIptablesFilterRule called");
541 if (data == nullptr) {
542 EDMLOGE("data is nullptr");
543 return;
544 }
545 AsyncIptablesCallbackInfo *asyncCallbackInfo = static_cast<AsyncIptablesCallbackInfo *>(data);
546 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->ListIptablesFilterRules(
547 asyncCallbackInfo->elementName, asyncCallbackInfo->stringRet);
548 }
549
SetGlobalHttpProxy(napi_env env,napi_callback_info info)550 napi_value NetworkManagerAddon::SetGlobalHttpProxy(napi_env env, napi_callback_info info)
551 {
552 size_t argc = ARGS_SIZE_THREE;
553 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
554 napi_value thisArg = nullptr;
555 void *data = nullptr;
556 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
557 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
558
559 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
560 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "parameter admin error");
561
562 bool isHttpProxy = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
563 ASSERT_AND_THROW_PARAM_ERROR(env, isHttpProxy, "parameter http proxy error");
564
565 if (argc > ARGS_SIZE_TWO) {
566 bool hasCallback = MatchValueType(env, argv[ARGS_SIZE_TWO], napi_function);
567 ASSERT_AND_THROW_PARAM_ERROR(env, hasCallback, "parameter callback error");
568 }
569
570 auto asyncCallbackInfo = new (std::nothrow) AsyncHttpProxyCallbackInfo();
571 if (asyncCallbackInfo == nullptr) {
572 return nullptr;
573 }
574 std::unique_ptr<AsyncHttpProxyCallbackInfo> callbackPtr{asyncCallbackInfo};
575 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
576 "parameter element name error");
577 bool parseRet = ParseHttpProxyParam(env, argv[ARR_INDEX_ONE], asyncCallbackInfo);
578 ASSERT_AND_THROW_PARAM_ERROR(env, parseRet, "ParseHttpProxyParam error");
579 if (argc > ARGS_SIZE_TWO) {
580 EDMLOGD("NAPI_IsNetworkInterfaceDisabled argc == ARGS_SIZE_THREE");
581 napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
582 }
583 napi_value asyncWorkReturn =
584 HandleAsyncWork(env, asyncCallbackInfo, "setGlobalProxy", NativeSetGlobalHttpProxy, NativeVoidCallbackComplete);
585 callbackPtr.release();
586 return asyncWorkReturn;
587 }
588
ParseHttpProxyParam(napi_env env,napi_value argv,AsyncHttpProxyCallbackInfo * callbackInfo)589 bool NetworkManagerAddon::ParseHttpProxyParam(napi_env env, napi_value argv, AsyncHttpProxyCallbackInfo *callbackInfo)
590 {
591 std::string host;
592 if (!JsObjectToString(env, argv, HOST_PROP_NAME, false, host)) {
593 EDMLOGE("error host value");
594 return false;
595 }
596 std::int32_t port = 0;
597 if (!JsObjectToInt(env, argv, PORT_PROP_NAME, false, port)) {
598 EDMLOGE("error port value");
599 return false;
600 }
601 std::vector<std::string> exclusionList;
602 if (!JsObjectToStringVector(env, argv, EXCLUSION_LIST_PROP_NAME, false, exclusionList)) {
603 EDMLOGE("error exclusionList value");
604 return false;
605 }
606
607 callbackInfo->httpProxy.SetHost(host.c_str());
608 callbackInfo->httpProxy.SetPort(port);
609 std::list<std::string> dataList;
610 for (const auto &item : exclusionList) {
611 dataList.emplace_back(item);
612 }
613 callbackInfo->httpProxy.SetExclusionList(dataList);
614 return true;
615 }
616
NativeSetGlobalHttpProxy(napi_env env,void * data)617 void NetworkManagerAddon::NativeSetGlobalHttpProxy(napi_env env, void *data)
618 {
619 EDMLOGI("NAPI_NativeSetGlobalHttpProxycalled");
620 if (data == nullptr) {
621 EDMLOGE("data is nullptr");
622 return;
623 }
624 AsyncHttpProxyCallbackInfo *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
625 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->SetGlobalHttpProxy(
626 asyncCallbackInfo->elementName, asyncCallbackInfo->httpProxy);
627 }
628
ConvertHttpProxyToJS(napi_env env,const OHOS::NetManagerStandard::HttpProxy & httpProxy)629 napi_value NetworkManagerAddon::ConvertHttpProxyToJS(napi_env env, const OHOS::NetManagerStandard::HttpProxy &httpProxy)
630 {
631 napi_value proxy = nullptr;
632 NAPI_CALL(env, napi_create_object(env, &proxy));
633 napi_value host = nullptr;
634 NAPI_CALL(env, napi_create_string_utf8(env, httpProxy.GetHost().c_str(), httpProxy.GetHost().length(), &host));
635 napi_value port = nullptr;
636 NAPI_CALL(env, napi_create_int32(env, httpProxy.GetPort(), &port));
637 napi_value list = nullptr;
638 if (httpProxy.GetExclusionList().empty()) {
639 NAPI_CALL(env, napi_create_array(env, &list));
640 } else {
641 std::list<std::string> tempList = httpProxy.GetExclusionList();
642 NAPI_CALL(env, napi_create_array_with_length(env, tempList.size(), &list));
643 size_t index = 0;
644 for (const auto &item : tempList) {
645 napi_value ip = nullptr;
646 NAPI_CALL(env, napi_create_string_utf8(env, item.c_str(), item.length(), &ip));
647 NAPI_CALL(env, napi_set_element(env, list, index++, ip));
648 }
649 }
650 NAPI_CALL(env, napi_set_named_property(env, proxy, HOST_PROP_NAME, host));
651 NAPI_CALL(env, napi_set_named_property(env, proxy, PORT_PROP_NAME, port));
652 NAPI_CALL(env, napi_set_named_property(env, proxy, EXCLUSION_LIST_PROP_NAME, list));
653 return proxy;
654 }
655
GetGlobalHttpProxy(napi_env env,napi_callback_info info)656 napi_value NetworkManagerAddon::GetGlobalHttpProxy(napi_env env, napi_callback_info info)
657 {
658 size_t argc = ARGS_SIZE_TWO;
659 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
660 napi_value thisArg = nullptr;
661 void *data = nullptr;
662 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
663 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
664 auto asyncCallbackInfo = new (std::nothrow) AsyncHttpProxyCallbackInfo();
665 if (asyncCallbackInfo == nullptr) {
666 return nullptr;
667 }
668 std::unique_ptr<AsyncHttpProxyCallbackInfo> callbackPtr{asyncCallbackInfo};
669 bool matchValue = false;
670 if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
671 asyncCallbackInfo->hasAdmin = false;
672 matchValue = true;
673 } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
674 asyncCallbackInfo->hasAdmin = true;
675 matchValue = true;
676 }
677 if (argc > ARGS_SIZE_ONE) {
678 matchValue = matchValue && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
679 }
680 ASSERT_AND_THROW_PARAM_ERROR(env, matchValue, "parameter type error");
681 if (asyncCallbackInfo->hasAdmin) {
682 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
683 "element name param error");
684 EDMLOGD(
685 "GetGlobalHttpProxy: asyncCallbackInfo->elementName.bundlename %{public}s, "
686 "asyncCallbackInfo->abilityname:%{public}s",
687 asyncCallbackInfo->elementName.GetBundleName().c_str(),
688 asyncCallbackInfo->elementName.GetAbilityName().c_str());
689 }
690 if (argc > ARGS_SIZE_ONE) {
691 EDMLOGD("NAPI_GetGlobalHttpProxy argc == ARGS_SIZE_TWO");
692 napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
693 }
694 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "NativeGetGlobalHttpProxy",
695 NativeGetGlobalHttpProxy, NativeHttpProxyCallbackComplete);
696 callbackPtr.release();
697 return asyncWorkReturn;
698 }
699
NativeGetGlobalHttpProxy(napi_env env,void * data)700 void NetworkManagerAddon::NativeGetGlobalHttpProxy(napi_env env, void *data)
701 {
702 EDMLOGI("NAPI_NativeGetGlobalHttpProxy called");
703 if (data == nullptr) {
704 EDMLOGE("data is nullptr");
705 return;
706 }
707 AsyncHttpProxyCallbackInfo *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
708
709 if (asyncCallbackInfo->hasAdmin) {
710 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(
711 &asyncCallbackInfo->elementName, asyncCallbackInfo->httpProxy);
712 } else {
713 asyncCallbackInfo->ret =
714 NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(nullptr, asyncCallbackInfo->httpProxy);
715 }
716 }
717
NativeHttpProxyCallbackComplete(napi_env env,napi_status status,void * data)718 void NetworkManagerAddon::NativeHttpProxyCallbackComplete(napi_env env, napi_status status, void *data)
719 {
720 EDMLOGD("NativeHttpProxyCallbackComplete start");
721 if (data == nullptr) {
722 EDMLOGE("data is nullptr");
723 return;
724 }
725 auto *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
726 if (asyncCallbackInfo->deferred != nullptr) {
727 EDMLOGD("asyncCallbackInfo->deferred != nullptr");
728 if (asyncCallbackInfo->ret == ERR_OK) {
729 napi_value jsHttpProxy = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
730 napi_resolve_deferred(env, asyncCallbackInfo->deferred, jsHttpProxy);
731 } else {
732 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
733 }
734 } else {
735 napi_value callbackValue[ARGS_SIZE_TWO] = {0};
736 if (asyncCallbackInfo->ret == ERR_OK) {
737 napi_get_null(env, &callbackValue[ARR_INDEX_ZERO]);
738 callbackValue[ARR_INDEX_ONE] = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
739 } else {
740 callbackValue[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
741 napi_get_null(env, &callbackValue[ARR_INDEX_ONE]);
742 }
743 napi_value callback = nullptr;
744 napi_value result = nullptr;
745 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
746 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
747 napi_delete_reference(env, asyncCallbackInfo->callback);
748 }
749 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
750 delete asyncCallbackInfo;
751 }
752
753 static napi_module g_networkManagerModule = {
754 .nm_version = 1,
755 .nm_flags = 0,
756 .nm_filename = nullptr,
757 .nm_register_func = NetworkManagerAddon::Init,
758 .nm_modname = "enterprise.networkManager",
759 .nm_priv = ((void *)0),
760 .reserved = {0},
761 };
762
NetworkManagerRegister()763 extern "C" __attribute__((constructor)) void NetworkManagerRegister()
764 {
765 napi_module_register(&g_networkManagerModule);
766 }