1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "network_manager_addon.h"
16
17 #include "edm_constants.h"
18 #include "edm_ipc_interface_code.h"
19 #include "edm_log.h"
20 #include "iptables_utils.h"
21 #include "os_account_manager.h"
22
23 using namespace OHOS::EDM;
24 using namespace OHOS::EDM::IPTABLES;
25
26 #ifdef NETMANAGER_BASE_EDM_ENABLE
27 const char *const HOST_PROP_NAME = "host";
28 const char *const PORT_PROP_NAME = "port";
29 const char *const PROXY_USER_NAME = "username";
30 const char *const PROXY_PASSWORD = "password";
31 const char *const EXCLUSION_LIST_PROP_NAME = "exclusionList";
32 #endif
33
34 const std::set<std::string> REQUIRED_APN_INFO_KEYS = { "apnName", "mcc", "mnc", "apn" };
35 const std::set<std::string> ALL_APN_INFO_KEYS = {
36 "apnName", "mcc", "mnc",
37 "apn", "type", "user",
38 "proxy", "mmsproxy", "authType", "password"
39 };
40 const std::map<std::string, std::string> KEY_TO_FIELD = {
41 { "apnName", "profile_name" },
42 { "type", "apn_types" },
43 { "user", "auth_user" },
44 { "proxy", "proxy_ip_address" },
45 { "mmsproxy", "mms_ip_address" },
46 { "authType", "auth_type" },
47 { "mcc", "mcc" },
48 { "mnc", "mnc" },
49 { "apn", "apn" },
50 { "password", "password" }
51 };
52 #ifdef CELLULAR_DATA_EDM_ENABLE
53 constexpr int32_t PASSWORD_KEY_LENGTH = 8;
54 #endif
55
CreateFirewallActionObject(napi_env env,napi_value value)56 void NetworkManagerAddon::CreateFirewallActionObject(napi_env env, napi_value value)
57 {
58 napi_value nAllow;
59 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::ALLOW), &nAllow));
60 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALLOW", nAllow));
61 napi_value nDeny;
62 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::DENY), &nDeny));
63 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "DENY", nDeny));
64 napi_value nReject;
65 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Action::REJECT), &nReject));
66 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "REJECT", nReject));
67 }
68
CreateFirewallProtocolObject(napi_env env,napi_value value)69 void NetworkManagerAddon::CreateFirewallProtocolObject(napi_env env, napi_value value)
70 {
71 napi_value nAll;
72 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ALL), &nAll));
73 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ALL", nAll));
74 napi_value nTCP;
75 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::TCP), &nTCP));
76 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "TCP", nTCP));
77 napi_value nUDP;
78 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::UDP), &nUDP));
79 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "UDP", nUDP));
80 napi_value nICMP;
81 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Protocol::ICMP), &nICMP));
82 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ICMP", nICMP));
83 }
84
CreateFirewallDirectionObject(napi_env env,napi_value value)85 void NetworkManagerAddon::CreateFirewallDirectionObject(napi_env env, napi_value value)
86 {
87 napi_value nInput;
88 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::INPUT), &nInput));
89 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INPUT", nInput));
90 napi_value nOutput;
91 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::OUTPUT), &nOutput));
92 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "OUTPUT", nOutput));
93 napi_value nForward;
94 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::Direction::FORWARD), &nForward));
95 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "FORWARD", nForward));
96 }
97
CreateFirewallAddMethodObject(napi_env env,napi_value value)98 void NetworkManagerAddon::CreateFirewallAddMethodObject(napi_env env, napi_value value)
99 {
100 napi_value nAppend;
101 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::APPEND), &nAppend));
102 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "APPEND", nAppend));
103 napi_value nInsert;
104 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(IPTABLES::AddMethod::INSERT), &nInsert));
105 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INSERT", nInsert));
106 }
107
Init(napi_env env,napi_value exports)108 napi_value NetworkManagerAddon::Init(napi_env env, napi_value exports)
109 {
110 napi_value nFirewallAction = nullptr;
111 NAPI_CALL(env, napi_create_object(env, &nFirewallAction));
112 CreateFirewallActionObject(env, nFirewallAction);
113
114 napi_value nFirewallProtocol = nullptr;
115 NAPI_CALL(env, napi_create_object(env, &nFirewallProtocol));
116 CreateFirewallProtocolObject(env, nFirewallProtocol);
117
118 napi_value nFirewallDirection = nullptr;
119 NAPI_CALL(env, napi_create_object(env, &nFirewallDirection));
120 CreateFirewallDirectionObject(env, nFirewallDirection);
121
122 napi_value nFirewallAddMethod = nullptr;
123 NAPI_CALL(env, napi_create_object(env, &nFirewallAddMethod));
124 CreateFirewallAddMethodObject(env, nFirewallAddMethod);
125
126 napi_property_descriptor property[] = {
127 DECLARE_NAPI_FUNCTION("getAllNetworkInterfaces", GetAllNetworkInterfaces),
128 DECLARE_NAPI_FUNCTION("getIpAddress", GetIpAddress),
129 DECLARE_NAPI_FUNCTION("getMac", GetMac),
130 DECLARE_NAPI_FUNCTION("setNetworkInterfaceDisabled", SetNetworkInterfaceDisabled),
131 DECLARE_NAPI_FUNCTION("isNetworkInterfaceDisabled", IsNetworkInterfaceDisabled),
132
133 DECLARE_NAPI_PROPERTY("Action", nFirewallAction),
134 DECLARE_NAPI_PROPERTY("Protocol", nFirewallProtocol),
135 DECLARE_NAPI_PROPERTY("Direction", nFirewallDirection),
136 DECLARE_NAPI_PROPERTY("AddMethod", nFirewallAddMethod),
137 DECLARE_NAPI_FUNCTION("addIptablesFilterRule", AddIptablesFilterRule),
138 DECLARE_NAPI_FUNCTION("removeIptablesFilterRule", RemoveIptablesFilterRule),
139 DECLARE_NAPI_FUNCTION("listIptablesFilterRules", ListIptablesFilterRules),
140
141 DECLARE_NAPI_FUNCTION("addFirewallRule", AddFirewallRule),
142 DECLARE_NAPI_FUNCTION("removeFirewallRule", RemoveFirewallRule),
143 DECLARE_NAPI_FUNCTION("getFirewallRules", GetFirewallRules),
144
145 DECLARE_NAPI_FUNCTION("addDomainFilterRule", AddDomainFilterRule),
146 DECLARE_NAPI_FUNCTION("removeDomainFilterRule", RemoveDomainFilterRule),
147 DECLARE_NAPI_FUNCTION("getDomainFilterRules", GetDomainFilterRules),
148
149 DECLARE_NAPI_FUNCTION("setGlobalProxy", SetGlobalHttpProxy),
150 DECLARE_NAPI_FUNCTION("getGlobalProxy", GetGlobalHttpProxy),
151
152 DECLARE_NAPI_FUNCTION("getAllNetworkInterfacesSync", GetAllNetworkInterfacesSync),
153 DECLARE_NAPI_FUNCTION("getIpAddressSync", GetIpAddressSync),
154 DECLARE_NAPI_FUNCTION("getMacSync", GetMacSync),
155 DECLARE_NAPI_FUNCTION("setNetworkInterfaceDisabledSync", SetNetworkInterfaceDisabledSync),
156 DECLARE_NAPI_FUNCTION("isNetworkInterfaceDisabledSync", IsNetworkInterfaceDisabledSync),
157 DECLARE_NAPI_FUNCTION("setGlobalProxySync", SetGlobalHttpProxySync),
158 DECLARE_NAPI_FUNCTION("getGlobalProxySync", GetGlobalHttpProxySync),
159 DECLARE_NAPI_FUNCTION("setGlobalProxyForAccount", SetGlobalHttpProxyForAccountSync),
160 DECLARE_NAPI_FUNCTION("getGlobalProxyForAccount", GetGlobalHttpProxyForAccountSync),
161 DECLARE_NAPI_FUNCTION("turnOnMobileData", TurnOnMobileData),
162 DECLARE_NAPI_FUNCTION("turnOffMobileData", TurnOffMobileData),
163 DECLARE_NAPI_FUNCTION("addApn", AddApn),
164 DECLARE_NAPI_FUNCTION("deleteApn", DeleteApn),
165 DECLARE_NAPI_FUNCTION("updateApn", UpdateApn),
166 DECLARE_NAPI_FUNCTION("setPreferredApn", SetPreferApn),
167 DECLARE_NAPI_FUNCTION("queryApn", QueryApn),
168 };
169 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
170 return exports;
171 }
172
GetAllNetworkInterfaces(napi_env env,napi_callback_info info)173 napi_value NetworkManagerAddon::GetAllNetworkInterfaces(napi_env env, napi_callback_info info)
174 {
175 AddonMethodSign addonMethodSign;
176 addonMethodSign.name = "GetAllNetworkInterfaces";
177 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
178 addonMethodSign.methodAttribute = MethodAttribute::GET;
179 addonMethodSign.apiVersionTag = EdmConstants::PERMISSION_TAG_VERSION_11;
180 return AddonMethodAdapter(env, info, addonMethodSign, NativeGetAllNetworkInterfaces,
181 NativeArrayStringCallbackComplete);
182 }
183
NativeGetAllNetworkInterfaces(napi_env env,void * data)184 void NetworkManagerAddon::NativeGetAllNetworkInterfaces(napi_env env, void *data)
185 {
186 EDMLOGI("NAPI_NativeGetAllNetworkInterfaces called");
187 if (data == nullptr) {
188 EDMLOGE("data is nullptr");
189 return;
190 }
191 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
192 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
193 if (networkManagerProxy == nullptr) {
194 EDMLOGE("can not get GetNetworkManagerProxy");
195 return;
196 }
197 asyncCallbackInfo->ret = networkManagerProxy->GetAllNetworkInterfaces(asyncCallbackInfo->data,
198 asyncCallbackInfo->arrayStringRet);
199 }
200
GetIpOrMacAddressCommon(AddonMethodSign & addonMethodSign,const std::string & apiVersionTag,int32_t policyCode)201 void NetworkManagerAddon::GetIpOrMacAddressCommon(AddonMethodSign &addonMethodSign, const std::string &apiVersionTag,
202 int32_t policyCode)
203 {
204 addonMethodSign.name = "GetIpOrMacAddress";
205 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING};
206 addonMethodSign.methodAttribute = MethodAttribute::GET;
207 addonMethodSign.apiVersionTag = apiVersionTag;
208 addonMethodSign.policyCode = policyCode;
209 }
210
GetIpAddress(napi_env env,napi_callback_info info)211 napi_value NetworkManagerAddon::GetIpAddress(napi_env env, napi_callback_info info)
212 {
213 EDMLOGI("NetworkManagerAddon::GetIpAddress called");
214 return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_IP_ADDRESS);
215 }
216
GetMac(napi_env env,napi_callback_info info)217 napi_value NetworkManagerAddon::GetMac(napi_env env, napi_callback_info info)
218 {
219 EDMLOGI("NetworkManagerAddon::GetMac called");
220 return GetIpOrMacAddress(env, info, EdmInterfaceCode::GET_MAC);
221 }
222
GetIpOrMacAddress(napi_env env,napi_callback_info info,int policyCode)223 napi_value NetworkManagerAddon::GetIpOrMacAddress(napi_env env, napi_callback_info info, int policyCode)
224 {
225 AddonMethodSign addonMethodSign;
226 GetIpOrMacAddressCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_11, policyCode);
227 return AddonMethodAdapter(env, info, addonMethodSign, NativeGetIpOrMacAddress, NativeStringCallbackComplete);
228 }
229
NativeGetIpOrMacAddress(napi_env env,void * data)230 void NetworkManagerAddon::NativeGetIpOrMacAddress(napi_env env, void *data)
231 {
232 EDMLOGI("NAPI_NativeGetIpOrMacAddress called");
233 if (data == nullptr) {
234 EDMLOGE("data is nullptr");
235 return;
236 }
237 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
238 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
239 if (networkManagerProxy == nullptr) {
240 EDMLOGE("can not get GetNetworkManagerProxy");
241 return;
242 }
243 asyncCallbackInfo->ret = networkManagerProxy->GetIpOrMacAddress(asyncCallbackInfo->data,
244 asyncCallbackInfo->policyCode, asyncCallbackInfo->stringRet);
245 }
246
IsNetworkInterfaceDisabledCommon(AddonMethodSign & addonMethodSign,const std::string & apiVersionTag)247 void NetworkManagerAddon::IsNetworkInterfaceDisabledCommon(AddonMethodSign &addonMethodSign,
248 const std::string &apiVersionTag)
249 {
250 addonMethodSign.name = "IsNetworkInterfaceDisabled";
251 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING};
252 addonMethodSign.methodAttribute = MethodAttribute::GET;
253 addonMethodSign.apiVersionTag = apiVersionTag;
254 }
255
SetNetworkInterfaceDisabledCommon(AddonMethodSign & addonMethodSign,const std::string & apiVersionTag)256 void NetworkManagerAddon::SetNetworkInterfaceDisabledCommon(AddonMethodSign &addonMethodSign,
257 const std::string &apiVersionTag)
258 {
259 auto convertNetworkInterface2Data = [](napi_env env, napi_value argv, MessageParcel &data,
260 const AddonMethodSign &methodSign) {
261 std::string networkInterface;
262 bool isUint = ParseString(env, networkInterface, argv);
263 if (!isUint) {
264 return false;
265 }
266 std::vector<std::string> key{networkInterface};
267 data.WriteStringVector(key);
268 return true;
269 };
270 auto convertBoolean2Data = [](napi_env env, napi_value argv, MessageParcel &data,
271 const AddonMethodSign &methodSign) {
272 bool isDisabled;
273 bool isUint = ParseBool(env, isDisabled, argv);
274 if (!isUint) {
275 return false;
276 }
277 std::vector<std::string> value{isDisabled ? "true" : "false"};
278 data.WriteStringVector(value);
279 return true;
280 };
281 addonMethodSign.name = "SetNetworkInterfaceDisabled";
282 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING, EdmAddonCommonType::BOOLEAN};
283 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
284 addonMethodSign.apiVersionTag = apiVersionTag;
285 addonMethodSign.argsConvert = {nullptr, convertNetworkInterface2Data, convertBoolean2Data};
286 }
287
SetNetworkInterfaceDisabled(napi_env env,napi_callback_info info)288 napi_value NetworkManagerAddon::SetNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
289 {
290 AddonMethodSign addonMethodSign;
291 SetNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_11);
292 return AddonMethodAdapter(env, info, addonMethodSign, NativeSetNetworkInterfaceDisabled,
293 NativeVoidCallbackComplete);
294 }
295
NativeSetNetworkInterfaceDisabled(napi_env env,void * data)296 void NetworkManagerAddon::NativeSetNetworkInterfaceDisabled(napi_env env, void *data)
297 {
298 EDMLOGI("NAPI_NativeSetNetworkInterfaceDisabled called");
299 if (data == nullptr) {
300 EDMLOGE("data is nullptr");
301 return;
302 }
303 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
304 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
305 if (networkManagerProxy == nullptr) {
306 EDMLOGE("can not get GetNetworkManagerProxy");
307 return;
308 }
309 asyncCallbackInfo->ret = networkManagerProxy->SetNetworkInterfaceDisabled(asyncCallbackInfo->data);
310 }
311
IsNetworkInterfaceDisabled(napi_env env,napi_callback_info info)312 napi_value NetworkManagerAddon::IsNetworkInterfaceDisabled(napi_env env, napi_callback_info info)
313 {
314 AddonMethodSign addonMethodSign;
315 IsNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_11);
316 return AddonMethodAdapter(env, info, addonMethodSign, NativeIsNetworkInterfaceDisabled,
317 NativeBoolCallbackComplete);
318 }
319
NativeIsNetworkInterfaceDisabled(napi_env env,void * data)320 void NetworkManagerAddon::NativeIsNetworkInterfaceDisabled(napi_env env, void *data)
321 {
322 EDMLOGI("NAPI_NativeIsNetworkInterfaceDisabled called");
323 if (data == nullptr) {
324 EDMLOGE("data is nullptr");
325 return;
326 }
327 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
328 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
329 if (networkManagerProxy == nullptr) {
330 EDMLOGE("can not get GetNetworkManagerProxy");
331 return;
332 }
333 asyncCallbackInfo->ret = networkManagerProxy->IsNetworkInterfaceDisabled(asyncCallbackInfo->data,
334 asyncCallbackInfo->boolRet);
335 }
336
AddIptablesFilterRule(napi_env env,napi_callback_info info)337 napi_value NetworkManagerAddon::AddIptablesFilterRule(napi_env env, napi_callback_info info)
338 {
339 EDMLOGI("NetworkManagerAddon::AddIptablesFilterRule called");
340 auto convertAddFilter2Data = [](napi_env env, napi_value argv, MessageParcel &data,
341 const AddonMethodSign &methodSign) {
342 IPTABLES::AddFilter filter;
343 bool isUint = JsObjToAddFirewallObject(env, argv, filter);
344 if (!isUint) {
345 return false;
346 }
347 IPTABLES::IptablesUtils::WriteAddFilterConfig(filter, data);
348 return true;
349 };
350 AddonMethodSign addonMethodSign;
351 addonMethodSign.name = "AddIptablesFilterRule";
352 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
353 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
354 addonMethodSign.argsConvert = {nullptr, convertAddFilter2Data};
355 return AddonMethodAdapter(env, info, addonMethodSign, NativeAddIptalbsFilterRule,
356 NativeVoidCallbackComplete);
357 }
358
JsObjToAddFirewallObject(napi_env env,napi_value object,IPTABLES::AddFilter & filter)359 bool NetworkManagerAddon::JsObjToAddFirewallObject(napi_env env, napi_value object, IPTABLES::AddFilter &filter)
360 {
361 JsObjectToUint(env, object, "ruleNo", false, filter.ruleNo);
362 JsObjectToString(env, object, "srcAddr", false, filter.srcAddr);
363 JsObjectToString(env, object, "destAddr", false, filter.destAddr);
364 JsObjectToString(env, object, "srcPort", false, filter.srcPort);
365 JsObjectToString(env, object, "destPort", false, filter.destPort);
366 JsObjectToString(env, object, "uid", false, filter.uid);
367 int32_t method = -1;
368 if (!JsObjectToInt(env, object, "method", true, method) ||
369 !IPTABLES::IptablesUtils::ProcessFirewallMethod(method, filter.method)) {
370 EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject method trans failed");
371 return false;
372 }
373 int32_t direction = -1;
374 if (!JsObjectToInt(env, object, "direction", true, direction) ||
375 !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, filter.direction)) {
376 EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject direction trans failed");
377 return false;
378 }
379 int32_t action = -1;
380 if (!JsObjectToInt(env, object, "action", true, action) ||
381 !IPTABLES::IptablesUtils::ProcessFirewallAction(action, filter.action)) {
382 EDMLOGE("NAPI_AddIptalbsFilterRule JsObjToAddFirewallObject action trans failed");
383 return false;
384 }
385 int32_t protocol = -1;
386 JsObjectToInt(env, object, "protocol", false, protocol);
387 IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, filter.protocol);
388 return true;
389 }
390
NativeAddIptalbsFilterRule(napi_env env,void * data)391 void NetworkManagerAddon::NativeAddIptalbsFilterRule(napi_env env, void *data)
392 {
393 EDMLOGI("NAPI_NativeAddIptalbsFilterRule called");
394 if (data == nullptr) {
395 EDMLOGE("data is nullptr");
396 return;
397 }
398 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
399 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddIptablesFilterRule(
400 asyncCallbackInfo->data);
401 }
402
RemoveIptablesFilterRule(napi_env env,napi_callback_info info)403 napi_value NetworkManagerAddon::RemoveIptablesFilterRule(napi_env env, napi_callback_info info)
404 {
405 EDMLOGI("NetworkManagerAddon::RemoveIptablesFilterRule called");
406 auto convertRemoveFilter2Data = [](napi_env env, napi_value argv, MessageParcel &data,
407 const AddonMethodSign &methodSign) {
408 IPTABLES::RemoveFilter filter;
409 bool isUint = JsObjToRemoveFirewallObject(env, argv, filter);
410 if (!isUint) {
411 return false;
412 }
413 IPTABLES::IptablesUtils::WriteRemoveFilterConfig(filter, data);
414 return true;
415 };
416 AddonMethodSign addonMethodSign;
417 addonMethodSign.name = "RemoveIptablesFilterRule";
418 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
419 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
420 addonMethodSign.argsConvert = {nullptr, convertRemoveFilter2Data};
421 return AddonMethodAdapter(env, info, addonMethodSign, NativeRemoveIptalbsFilterRule,
422 NativeVoidCallbackComplete);
423 }
424
JsObjToRemoveFirewallObject(napi_env env,napi_value object,IPTABLES::RemoveFilter & firewall)425 bool NetworkManagerAddon::JsObjToRemoveFirewallObject(napi_env env, napi_value object, IPTABLES::RemoveFilter &firewall)
426 {
427 JsObjectToString(env, object, "srcAddr", false, firewall.srcAddr);
428 JsObjectToString(env, object, "destAddr", false, firewall.destAddr);
429 JsObjectToString(env, object, "srcPort", false, firewall.srcPort);
430 JsObjectToString(env, object, "destPort", false, firewall.destPort);
431 JsObjectToString(env, object, "uid", false, firewall.uid);
432 int32_t direction = -1;
433 if (!JsObjectToInt(env, object, "direction", true, direction) ||
434 !IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, firewall.direction)) {
435 EDMLOGE("NAPI_removeIptalbsFilterRule JsObjToRemoveFirewallObject direction trans failed");
436 return false;
437 }
438 int32_t action = -1;
439 JsObjectToInt(env, object, "action", false, action);
440 IPTABLES::IptablesUtils::ProcessFirewallAction(action, firewall.action);
441 int32_t protocol = -1;
442 JsObjectToInt(env, object, "protocol", false, protocol);
443 IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, firewall.protocol);
444 return true;
445 }
446
NativeRemoveIptalbsFilterRule(napi_env env,void * data)447 void NetworkManagerAddon::NativeRemoveIptalbsFilterRule(napi_env env, void *data)
448 {
449 EDMLOGI("NAPI_NativeRemoveIptalbsFilterRule called");
450 if (data == nullptr) {
451 EDMLOGE("data is nullptr");
452 return;
453 }
454 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
455 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
456 asyncCallbackInfo->ret =
457 networkManagerProxy->RemoveIptablesFilterRule(asyncCallbackInfo->data);
458 }
459
ListIptablesFilterRules(napi_env env,napi_callback_info info)460 napi_value NetworkManagerAddon::ListIptablesFilterRules(napi_env env, napi_callback_info info)
461 {
462 AddonMethodSign addonMethodSign;
463 addonMethodSign.name = "ListIptablesFilterRules";
464 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
465 addonMethodSign.methodAttribute = MethodAttribute::GET;
466 return AddonMethodAdapter(env, info, addonMethodSign, NativeListIptablesFilterRules,
467 NativeStringCallbackComplete);
468 }
469
NativeListIptablesFilterRules(napi_env env,void * data)470 void NetworkManagerAddon::NativeListIptablesFilterRules(napi_env env, void *data)
471 {
472 EDMLOGI("NAPI_NativeListIptablesFilterRule called");
473 if (data == nullptr) {
474 EDMLOGE("data is nullptr");
475 return;
476 }
477 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
478 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->ListIptablesFilterRules(
479 asyncCallbackInfo->data, asyncCallbackInfo->stringRet);
480 }
481
AddFirewallRule(napi_env env,napi_callback_info info)482 napi_value NetworkManagerAddon::AddFirewallRule(napi_env env, napi_callback_info info)
483 {
484 EDMLOGI("AddFirewallRule start");
485 auto convertFirewallRule2Data = [](napi_env env, napi_value argv, MessageParcel &data,
486 const AddonMethodSign &methodSign) {
487 IPTABLES::FirewallRule rule;
488 bool isUint = JsObjToFirewallRule(env, argv, rule);
489 if (!isUint) {
490 return false;
491 }
492 IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
493 if (!firewallRuleParcel.Marshalling(data)) {
494 EDMLOGE("NetworkManagerAddon::AddOrRemoveFirewallRuleCommon Marshalling rule fail.");
495 return false;
496 }
497 return true;
498 };
499 AddonMethodSign addonMethodSign;
500 addonMethodSign.name = "AddFirewallRule";
501 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
502 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
503 addonMethodSign.argsConvert = {nullptr, convertFirewallRule2Data};
504 AdapterAddonData adapterAddonData{};
505 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
506 return nullptr;
507 }
508 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddFirewallRule(adapterAddonData.data);
509 if (FAILED(ret)) {
510 napi_throw(env, CreateError(env, ret));
511 }
512 return nullptr;
513 }
514
RemoveFirewallRule(napi_env env,napi_callback_info info)515 napi_value NetworkManagerAddon::RemoveFirewallRule(napi_env env, napi_callback_info info)
516 {
517 EDMLOGI("RemoveFirewallRule start");
518 size_t argc = ARGS_SIZE_TWO;
519 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
520 napi_value thisArg = nullptr;
521 void *data = nullptr;
522 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
523 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
524 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
525 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
526 if (argc >= ARGS_SIZE_TWO) {
527 bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
528 ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be FirewallRule.");
529 }
530 OHOS::AppExecFwk::ElementName elementName;
531 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
532 "element name param error");
533 IPTABLES::FirewallRule rule = {IPTABLES::Direction::INVALID, IPTABLES::Action::INVALID,
534 IPTABLES::Protocol::INVALID, "", "", "", "", ""};
535 if (argc >= ARGS_SIZE_TWO) {
536 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToFirewallRule(env, argv[ARR_INDEX_ONE], rule),
537 "firewallRule param error");
538 }
539 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->RemoveFirewallRule(elementName, rule);
540 if (FAILED(ret)) {
541 napi_throw(env, CreateError(env, ret));
542 }
543 return nullptr;
544 }
545
GetFirewallRules(napi_env env,napi_callback_info info)546 napi_value NetworkManagerAddon::GetFirewallRules(napi_env env, napi_callback_info info)
547 {
548 AddonMethodSign addonMethodSign;
549 addonMethodSign.name = "GetFirewallRules";
550 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
551 addonMethodSign.methodAttribute = MethodAttribute::GET;
552
553 AdapterAddonData adapterAddonData{};
554 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
555 return nullptr;
556 }
557 std::vector<IPTABLES::FirewallRule> result;
558 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetFirewallRules(adapterAddonData.data, result);
559 if (FAILED(ret)) {
560 napi_throw(env, CreateError(env, ret));
561 return nullptr;
562 }
563 napi_value jsList = nullptr;
564 NAPI_CALL(env, napi_create_array_with_length(env, result.size(), &jsList));
565 for (size_t i = 0; i < result.size(); i++) {
566 napi_value item = FirewallRuleToJsObj(env, result[i]);
567 NAPI_CALL(env, napi_set_element(env, jsList, i, item));
568 }
569 return jsList;
570 }
571
JsObjToFirewallRule(napi_env env,napi_value object,IPTABLES::FirewallRule & rule)572 bool NetworkManagerAddon::JsObjToFirewallRule(napi_env env, napi_value object, IPTABLES::FirewallRule &rule)
573 {
574 int32_t direction = -1;
575 JsObjectToInt(env, object, "direction", false, direction);
576 EDMLOGI("JsObjToFirewallRule direction %{public}d", direction);
577 IPTABLES::Direction directionEnum = IPTABLES::Direction::INVALID;
578 IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, directionEnum);
579
580 int32_t action = -1;
581 JsObjectToInt(env, object, "action", false, action);
582 EDMLOGI("JsObjToFirewallRule action %{public}d", action);
583 IPTABLES::Action actionEnum = IPTABLES::Action::INVALID;
584 IPTABLES::IptablesUtils::ProcessFirewallAction(action, actionEnum);
585
586 int32_t protocol = -1;
587 JsObjectToInt(env, object, "protocol", false, protocol);
588 EDMLOGI("JsObjToFirewallRule protocol %{public}d", protocol);
589 IPTABLES::Protocol protocolEnum = IPTABLES::Protocol::INVALID;
590 IPTABLES::IptablesUtils::ProcessFirewallProtocol(protocol, protocolEnum);
591
592 std::string srcAddr;
593 JsObjectToString(env, object, "srcAddr", false, srcAddr);
594
595 std::string destAddr;
596 JsObjectToString(env, object, "destAddr", false, destAddr);
597
598 std::string srcPort;
599 JsObjectToString(env, object, "srcPort", false, srcPort);
600
601 std::string destPort;
602 JsObjectToString(env, object, "destPort", false, destPort);
603
604 std::string appUid;
605 JsObjectToString(env, object, "appUid", false, appUid);
606 rule = {directionEnum, actionEnum, protocolEnum, srcAddr, destAddr, srcPort, destPort, appUid};
607 return true;
608 }
609
FirewallRuleToJsObj(napi_env env,const IPTABLES::FirewallRule & rule)610 napi_value NetworkManagerAddon::FirewallRuleToJsObj(napi_env env, const IPTABLES::FirewallRule &rule)
611 {
612 napi_value jsRule = nullptr;
613 NAPI_CALL(env, napi_create_object(env, &jsRule));
614
615 napi_value direction = nullptr;
616 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_DICECTION_IND>(rule)), &direction));
617 napi_value action = nullptr;
618 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_ACTION_IND>(rule)), &action));
619 napi_value protocol = nullptr;
620 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<FIREWALL_PROT_IND>(rule)), &protocol));
621 napi_value srcAddr = nullptr;
622 std::string srcAddrStr = std::get<FIREWALL_SRCADDR_IND>(rule);
623 NAPI_CALL(env, napi_create_string_utf8(env, srcAddrStr.c_str(), srcAddrStr.length(), &srcAddr));
624 napi_value destAddr = nullptr;
625 std::string destAddrStr = std::get<FIREWALL_DESTADDR_IND>(rule);
626 NAPI_CALL(env, napi_create_string_utf8(env, destAddrStr.c_str(), destAddrStr.length(), &destAddr));
627 napi_value srcPort = nullptr;
628 std::string srcPortStr = std::get<FIREWALL_SRCPORT_IND>(rule);
629 NAPI_CALL(env, napi_create_string_utf8(env, srcPortStr.c_str(), srcPortStr.length(), &srcPort));
630 napi_value destPort = nullptr;
631 std::string destPortStr = std::get<FIREWALL_DESTPORT_IND>(rule);
632 NAPI_CALL(env, napi_create_string_utf8(env, destPortStr.c_str(), destPortStr.length(), &destPort));
633 napi_value appUid = nullptr;
634 std::string appUidStr = std::get<FIREWALL_APPUID_IND>(rule);
635 NAPI_CALL(env, napi_create_string_utf8(env, appUidStr.c_str(), appUidStr.length(), &appUid));
636
637 NAPI_CALL(env, napi_set_named_property(env, jsRule, "direction", direction));
638 NAPI_CALL(env, napi_set_named_property(env, jsRule, "action", action));
639 NAPI_CALL(env, napi_set_named_property(env, jsRule, "protocol", protocol));
640 NAPI_CALL(env, napi_set_named_property(env, jsRule, "srcAddr", srcAddr));
641 NAPI_CALL(env, napi_set_named_property(env, jsRule, "destAddr", destAddr));
642 NAPI_CALL(env, napi_set_named_property(env, jsRule, "srcPort", srcPort));
643 NAPI_CALL(env, napi_set_named_property(env, jsRule, "destPort", destPort));
644 NAPI_CALL(env, napi_set_named_property(env, jsRule, "appUid", appUid));
645 return jsRule;
646 }
647
AddDomainFilterRule(napi_env env,napi_callback_info info)648 napi_value NetworkManagerAddon::AddDomainFilterRule(napi_env env, napi_callback_info info)
649 {
650 auto convertFirewallRule2Data = [](napi_env env, napi_value argv, MessageParcel &data,
651 const AddonMethodSign &methodSign) {
652 IPTABLES::DomainFilterRule rule = {IPTABLES::Action::INVALID, "", "", IPTABLES::Direction::INVALID};
653 bool isParseOk = JsObjToDomainFilterRule(env, argv, rule);
654 if (!isParseOk) {
655 return false;
656 }
657 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
658 if (!domainFilterRuleParcel.Marshalling(data)) {
659 EDMLOGE("NetworkManagerAddon::AddOrRemoveDomainFilterRuleCommon Marshalling rule fail.");
660 return false;
661 }
662 return true;
663 };
664 AddonMethodSign addonMethodSign;
665 addonMethodSign.name = "AddDomainFilterRule";
666 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
667 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
668 addonMethodSign.argsConvert = {nullptr, convertFirewallRule2Data};
669 AdapterAddonData adapterAddonData{};
670 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
671 return nullptr;
672 }
673 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddDomainFilterRule(adapterAddonData.data);
674 if (FAILED(ret)) {
675 napi_throw(env, CreateError(env, ret));
676 }
677 return nullptr;
678 }
679
RemoveDomainFilterRule(napi_env env,napi_callback_info info)680 napi_value NetworkManagerAddon::RemoveDomainFilterRule(napi_env env, napi_callback_info info)
681 {
682 size_t argc = ARGS_SIZE_TWO;
683 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
684 napi_value thisArg = nullptr;
685 void *data = nullptr;
686 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
687 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
688 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
689 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
690 if (argc >= ARGS_SIZE_TWO) {
691 bool hasRule = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
692 ASSERT_AND_THROW_PARAM_ERROR(env, hasRule, "The second parameter must be DomainFilterRule.");
693 }
694
695 OHOS::AppExecFwk::ElementName elementName;
696 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
697 "element name param error");
698 IPTABLES::DomainFilterRule rule = {IPTABLES::Action::INVALID, "", "", IPTABLES::Direction::INVALID};
699 if (argc >= ARGS_SIZE_TWO) {
700 ASSERT_AND_THROW_PARAM_ERROR(env, JsObjToDomainFilterRule(env, argv[ARR_INDEX_ONE], rule),
701 "DomainFilterRule param error");
702 }
703
704 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->RemoveDomainFilterRule(elementName, rule);
705 if (FAILED(ret)) {
706 napi_throw(env, CreateError(env, ret));
707 }
708 return nullptr;
709 }
710
GetDomainFilterRules(napi_env env,napi_callback_info info)711 napi_value NetworkManagerAddon::GetDomainFilterRules(napi_env env, napi_callback_info info)
712 {
713 AddonMethodSign addonMethodSign;
714 addonMethodSign.name = "GetDomainFilterRules";
715 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
716 addonMethodSign.methodAttribute = MethodAttribute::GET;
717
718 AdapterAddonData adapterAddonData{};
719 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
720 return nullptr;
721 }
722 std::vector<IPTABLES::DomainFilterRule> result;
723 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetDomainFilterRules(adapterAddonData.data, result);
724 if (FAILED(ret)) {
725 napi_throw(env, CreateError(env, ret));
726 return nullptr;
727 }
728 napi_value jsList = nullptr;
729 NAPI_CALL(env, napi_create_array_with_length(env, result.size(), &jsList));
730 for (size_t i = 0; i < result.size(); i++) {
731 napi_value item = DomainFilterRuleToJsObj(env, result[i]);
732 NAPI_CALL(env, napi_set_element(env, jsList, i, item));
733 }
734 return jsList;
735 }
736
JsObjToDomainFilterRule(napi_env env,napi_value object,IPTABLES::DomainFilterRule & rule)737 bool NetworkManagerAddon::JsObjToDomainFilterRule(napi_env env, napi_value object, IPTABLES::DomainFilterRule &rule)
738 {
739 int32_t action = -1;
740 JsObjectToInt(env, object, "action", false, action);
741 IPTABLES::Action actionEnum = IPTABLES::Action::INVALID;
742 IPTABLES::IptablesUtils::ProcessFirewallAction(action, actionEnum);
743
744 std::string appUid;
745 JsObjectToString(env, object, "appUid", false, appUid);
746
747 std::string domainName;
748 JsObjectToString(env, object, "domainName", false, domainName);
749
750 int32_t direction = -1;
751 JsObjectToInt(env, object, "direction", false, direction);
752 IPTABLES::Direction directionEnum = IPTABLES::Direction::INVALID;
753 IPTABLES::IptablesUtils::ProcessFirewallDirection(direction, directionEnum);
754 rule = {actionEnum, appUid, domainName, directionEnum};
755 return true;
756 }
757
DomainFilterRuleToJsObj(napi_env env,const IPTABLES::DomainFilterRule & rule)758 napi_value NetworkManagerAddon::DomainFilterRuleToJsObj(napi_env env, const IPTABLES::DomainFilterRule &rule)
759 {
760 napi_value jsRule = nullptr;
761 NAPI_CALL(env, napi_create_object(env, &jsRule));
762
763 napi_value direction = nullptr;
764 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<DOMAIN_DIRECTION_IND>(rule)), &direction));
765 napi_value action = nullptr;
766 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(std::get<DOMAIN_ACTION_IND>(rule)), &action));
767 napi_value appUid = nullptr;
768 std::string appUidStr = std::get<DOMAIN_APPUID_IND>(rule);
769 NAPI_CALL(env, napi_create_string_utf8(env, appUidStr.c_str(), appUidStr.length(), &appUid));
770 napi_value domainName = nullptr;
771 std::string domainNameStr = std::get<DOMAIN_DOMAINNAME_IND>(rule);
772 NAPI_CALL(env, napi_create_string_utf8(env, domainNameStr.c_str(), domainNameStr.length(), &domainName));
773 NAPI_CALL(env, napi_set_named_property(env, jsRule, "action", action));
774 NAPI_CALL(env, napi_set_named_property(env, jsRule, "appUid", appUid));
775 NAPI_CALL(env, napi_set_named_property(env, jsRule, "domainName", domainName));
776 NAPI_CALL(env, napi_set_named_property(env, jsRule, "direction", direction));
777 return jsRule;
778 }
779
SetGlobalHttpProxy(napi_env env,napi_callback_info info)780 napi_value NetworkManagerAddon::SetGlobalHttpProxy(napi_env env, napi_callback_info info)
781 {
782 #ifdef NETMANAGER_BASE_EDM_ENABLE
783 AddonMethodSign addonMethodSign;
784 SetGlobalHttpProxyCommon(addonMethodSign);
785 return AddonMethodAdapter(env, info, addonMethodSign, NativeSetGlobalHttpProxy, NativeVoidCallbackComplete);
786 #else
787 EDMLOGW("NetworkManagerAddon::SetGlobalHttpProxy Unsupported Capabilities.");
788 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
789 return nullptr;
790 #endif
791 }
792
793 #ifdef NETMANAGER_BASE_EDM_ENABLE
ParseHttpProxyParam(napi_env env,napi_value argv,NetManagerStandard::HttpProxy & httpProxy)794 bool NetworkManagerAddon::ParseHttpProxyParam(napi_env env, napi_value argv, NetManagerStandard::HttpProxy &httpProxy)
795 {
796 std::string host;
797 if (!JsObjectToString(env, argv, HOST_PROP_NAME, true, host)) {
798 EDMLOGE("error host value");
799 return false;
800 }
801 std::int32_t port = 0;
802 if (!JsObjectToInt(env, argv, PORT_PROP_NAME, true, port)) {
803 EDMLOGE("error port value");
804 return false;
805 }
806 OHOS::NetManagerStandard::SecureData username;
807 if (!JsObjectToSecureData(env, argv, PROXY_USER_NAME, username)) {
808 EDMLOGE("error username value");
809 return false;
810 }
811 OHOS::NetManagerStandard::SecureData password;
812 if (!JsObjectToSecureData(env, argv, PROXY_PASSWORD, password)) {
813 EDMLOGE("error password value");
814 return false;
815 }
816 if (!username.empty() && !password.empty()) {
817 EDMLOGD("NetworkManagerAddon username and password is not empty.");
818 } else {
819 EDMLOGD("NetworkManagerAddon username or password is empty.");
820 }
821 std::vector<std::string> exclusionList;
822 if (!JsObjectToStringVector(env, argv, EXCLUSION_LIST_PROP_NAME, true, exclusionList)) {
823 EDMLOGE("error exclusionList value");
824 return false;
825 }
826
827 httpProxy.SetHost(host.c_str());
828 httpProxy.SetPort(port);
829 httpProxy.SetUserName(username);
830 httpProxy.SetPassword(password);
831 std::list<std::string> dataList;
832 for (const auto &item : exclusionList) {
833 dataList.emplace_back(item);
834 }
835 httpProxy.SetExclusionList(dataList);
836 return true;
837 }
838
JsObjectToSecureData(napi_env env,napi_value object,const char * paramStr,OHOS::NetManagerStandard::SecureData & secureData)839 bool NetworkManagerAddon::JsObjectToSecureData(napi_env env, napi_value object, const char *paramStr,
840 OHOS::NetManagerStandard::SecureData &secureData)
841 {
842 bool hasProperty = false;
843 if (napi_has_named_property(env, object, paramStr, &hasProperty) != napi_ok) {
844 EDMLOGE("get js property failed.");
845 return false;
846 }
847 if (hasProperty) {
848 napi_value prop = nullptr;
849 return napi_get_named_property(env, object, paramStr, &prop) == napi_ok &&
850 ParseSecureData(env, secureData, prop);
851 }
852 return true;
853 }
854
ParseSecureData(napi_env env,OHOS::NetManagerStandard::SecureData & secureData,napi_value object)855 bool NetworkManagerAddon::ParseSecureData(napi_env env, OHOS::NetManagerStandard::SecureData &secureData,
856 napi_value object)
857 {
858 napi_valuetype valuetype;
859 if (napi_typeof(env, object, &valuetype) != napi_ok || valuetype != napi_string ||
860 !GetSecureDataFromNAPI(env, object, secureData)) {
861 EDMLOGE("can not get string value");
862 return false;
863 }
864 return true;
865 }
866
GetSecureDataFromNAPI(napi_env env,napi_value object,OHOS::NetManagerStandard::SecureData & secureData)867 bool NetworkManagerAddon::GetSecureDataFromNAPI(napi_env env, napi_value object,
868 OHOS::NetManagerStandard::SecureData &secureData)
869 {
870 OHOS::NetManagerStandard::SecureData result;
871 size_t size = 0;
872
873 if (napi_get_value_string_utf8(env, object, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
874 EDMLOGE("can not get string size");
875 return false;
876 }
877 result.reserve(size + NAPI_RETURN_ONE);
878 result.resize(size);
879 if (napi_get_value_string_utf8(env, object, result.data(), (size + NAPI_RETURN_ONE), &size) != napi_ok) {
880 EDMLOGE("can not get string value");
881 return false;
882 }
883 secureData = result;
884 return true;
885 }
886
NativeSetGlobalHttpProxy(napi_env env,void * data)887 void NetworkManagerAddon::NativeSetGlobalHttpProxy(napi_env env, void *data)
888 {
889 EDMLOGI("NAPI_NativeSetGlobalHttpProxycalled");
890 if (data == nullptr) {
891 EDMLOGE("data is nullptr");
892 return;
893 }
894 AdapterAddonData *asyncCallbackInfo = static_cast<AdapterAddonData *>(data);
895 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->SetGlobalHttpProxy(
896 asyncCallbackInfo->data);
897 }
898
ConvertHttpProxyToJS(napi_env env,const OHOS::NetManagerStandard::HttpProxy & httpProxy)899 napi_value NetworkManagerAddon::ConvertHttpProxyToJS(napi_env env, const OHOS::NetManagerStandard::HttpProxy &httpProxy)
900 {
901 napi_value proxy = nullptr;
902 NAPI_CALL(env, napi_create_object(env, &proxy));
903 napi_value host = nullptr;
904 NAPI_CALL(env, napi_create_string_utf8(env, httpProxy.GetHost().c_str(), httpProxy.GetHost().length(), &host));
905 napi_value port = nullptr;
906 NAPI_CALL(env, napi_create_int32(env, httpProxy.GetPort(), &port));
907 napi_value list = nullptr;
908 if (httpProxy.GetExclusionList().empty()) {
909 NAPI_CALL(env, napi_create_array(env, &list));
910 } else {
911 std::list<std::string> tempList = httpProxy.GetExclusionList();
912 NAPI_CALL(env, napi_create_array_with_length(env, tempList.size(), &list));
913 size_t index = 0;
914 for (const auto &item : tempList) {
915 napi_value ip = nullptr;
916 NAPI_CALL(env, napi_create_string_utf8(env, item.c_str(), item.length(), &ip));
917 NAPI_CALL(env, napi_set_element(env, list, index++, ip));
918 }
919 }
920 NAPI_CALL(env, napi_set_named_property(env, proxy, HOST_PROP_NAME, host));
921 NAPI_CALL(env, napi_set_named_property(env, proxy, PORT_PROP_NAME, port));
922 NAPI_CALL(env, napi_set_named_property(env, proxy, EXCLUSION_LIST_PROP_NAME, list));
923 return proxy;
924 }
925 #endif
926
GetGlobalHttpProxy(napi_env env,napi_callback_info info)927 napi_value NetworkManagerAddon::GetGlobalHttpProxy(napi_env env, napi_callback_info info)
928 {
929 #ifdef NETMANAGER_BASE_EDM_ENABLE
930 size_t argc = ARGS_SIZE_TWO;
931 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
932 napi_value thisArg = nullptr;
933 void *data = nullptr;
934 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
935 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
936 auto asyncCallbackInfo = new (std::nothrow) AsyncHttpProxyCallbackInfo();
937 if (asyncCallbackInfo == nullptr) {
938 return nullptr;
939 }
940 std::unique_ptr<AsyncHttpProxyCallbackInfo> callbackPtr{asyncCallbackInfo};
941 bool matchValue = false;
942 if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_null)) {
943 asyncCallbackInfo->hasAdmin = false;
944 matchValue = true;
945 } else if (MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object)) {
946 asyncCallbackInfo->hasAdmin = true;
947 matchValue = true;
948 }
949 if (argc > ARGS_SIZE_ONE) {
950 matchValue = matchValue && MatchValueType(env, argv[ARGS_SIZE_ONE], napi_function);
951 }
952 ASSERT_AND_THROW_PARAM_ERROR(env, matchValue, "parameter type error");
953 if (asyncCallbackInfo->hasAdmin) {
954 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
955 "element name param error");
956 EDMLOGD(
957 "GetGlobalHttpProxy: asyncCallbackInfo->elementName.bundlename %{public}s, "
958 "asyncCallbackInfo->abilityname:%{public}s",
959 asyncCallbackInfo->elementName.GetBundleName().c_str(),
960 asyncCallbackInfo->elementName.GetAbilityName().c_str());
961 }
962 if (argc > ARGS_SIZE_ONE) {
963 EDMLOGD("NAPI_GetGlobalHttpProxy argc == ARGS_SIZE_TWO");
964 napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
965 }
966 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "NativeGetGlobalHttpProxy",
967 NativeGetGlobalHttpProxy, NativeHttpProxyCallbackComplete);
968 callbackPtr.release();
969 return asyncWorkReturn;
970 #else
971 EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxy Unsupported Capabilities.");
972 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
973 return nullptr;
974 #endif
975 }
976
977 #ifdef NETMANAGER_BASE_EDM_ENABLE
NativeGetGlobalHttpProxy(napi_env env,void * data)978 void NetworkManagerAddon::NativeGetGlobalHttpProxy(napi_env env, void *data)
979 {
980 EDMLOGI("NAPI_NativeGetGlobalHttpProxy called");
981 if (data == nullptr) {
982 EDMLOGE("data is nullptr");
983 return;
984 }
985 AsyncHttpProxyCallbackInfo *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
986 int32_t accountId = -1;
987 if (asyncCallbackInfo->hasAdmin) {
988 asyncCallbackInfo->ret = NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(
989 &asyncCallbackInfo->elementName, asyncCallbackInfo->httpProxy, accountId);
990 } else {
991 asyncCallbackInfo->ret =
992 NetworkManagerProxy::GetNetworkManagerProxy()->GetGlobalHttpProxy(nullptr,
993 asyncCallbackInfo->httpProxy, accountId);
994 }
995 }
996
NativeHttpProxyCallbackComplete(napi_env env,napi_status status,void * data)997 void NetworkManagerAddon::NativeHttpProxyCallbackComplete(napi_env env, napi_status status, void *data)
998 {
999 EDMLOGD("NativeHttpProxyCallbackComplete start");
1000 if (data == nullptr) {
1001 EDMLOGE("data is nullptr");
1002 return;
1003 }
1004 auto *asyncCallbackInfo = static_cast<AsyncHttpProxyCallbackInfo *>(data);
1005 if (asyncCallbackInfo->deferred != nullptr) {
1006 EDMLOGD("asyncCallbackInfo->deferred != nullptr");
1007 if (asyncCallbackInfo->ret == ERR_OK) {
1008 napi_value jsHttpProxy = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
1009 napi_resolve_deferred(env, asyncCallbackInfo->deferred, jsHttpProxy);
1010 } else {
1011 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
1012 }
1013 } else {
1014 napi_value callbackValue[ARGS_SIZE_TWO] = {0};
1015 if (asyncCallbackInfo->ret == ERR_OK) {
1016 napi_get_null(env, &callbackValue[ARR_INDEX_ZERO]);
1017 callbackValue[ARR_INDEX_ONE] = ConvertHttpProxyToJS(env, asyncCallbackInfo->httpProxy);
1018 } else {
1019 callbackValue[ARR_INDEX_ZERO] = CreateError(env, asyncCallbackInfo->ret);
1020 napi_get_null(env, &callbackValue[ARR_INDEX_ONE]);
1021 }
1022 napi_value callback = nullptr;
1023 napi_value result = nullptr;
1024 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
1025 napi_call_function(env, nullptr, callback, std::size(callbackValue), callbackValue, &result);
1026 napi_delete_reference(env, asyncCallbackInfo->callback);
1027 }
1028 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1029 delete asyncCallbackInfo;
1030 }
1031 #endif
1032
GetAllNetworkInterfacesSync(napi_env env,napi_callback_info info)1033 napi_value NetworkManagerAddon::GetAllNetworkInterfacesSync(napi_env env, napi_callback_info info)
1034 {
1035 EDMLOGI("NAPI_GetAllNetworkInterfacesSync called");
1036 AddonMethodSign addonMethodSign;
1037 addonMethodSign.name = "GetAllNetworkInterfacesSync";
1038 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
1039 addonMethodSign.methodAttribute = MethodAttribute::GET;
1040 addonMethodSign.apiVersionTag = EdmConstants::PERMISSION_TAG_VERSION_12;
1041 AdapterAddonData adapterAddonData{};
1042 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1043 return nullptr;
1044 }
1045 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1046 if (networkManagerProxy == nullptr) {
1047 EDMLOGE("can not get GetNetworkManagerProxy");
1048 return nullptr;
1049 }
1050 std::vector<std::string> networkInterface;
1051 int32_t ret = networkManagerProxy->GetAllNetworkInterfaces(adapterAddonData.data, networkInterface);
1052 if (FAILED(ret)) {
1053 napi_throw(env, CreateError(env, ret));
1054 return nullptr;
1055 }
1056 napi_value result = nullptr;
1057 NAPI_CALL(env, napi_create_array(env, &result));
1058 ConvertStringVectorToJS(env, networkInterface, result);
1059 return result;
1060 }
1061
GetIpAddressSync(napi_env env,napi_callback_info info)1062 napi_value NetworkManagerAddon::GetIpAddressSync(napi_env env, napi_callback_info info)
1063 {
1064 EDMLOGI("NAPI_GetIpAddressSync called");
1065 return GetIpOrMacAddressSync(env, info, EdmInterfaceCode::GET_IP_ADDRESS);
1066 }
1067
GetMacSync(napi_env env,napi_callback_info info)1068 napi_value NetworkManagerAddon::GetMacSync(napi_env env, napi_callback_info info)
1069 {
1070 EDMLOGI("NAPI_GetMacSync called");
1071 return GetIpOrMacAddressSync(env, info, EdmInterfaceCode::GET_MAC);
1072 }
1073
GetIpOrMacAddressSync(napi_env env,napi_callback_info info,int policyCode)1074 napi_value NetworkManagerAddon::GetIpOrMacAddressSync(napi_env env, napi_callback_info info, int policyCode)
1075 {
1076 AddonMethodSign addonMethodSign;
1077 GetIpOrMacAddressCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_12, policyCode);
1078 AdapterAddonData adapterAddonData{};
1079 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1080 return nullptr;
1081 }
1082 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1083 if (networkManagerProxy == nullptr) {
1084 EDMLOGE("can not get GetNetworkManagerProxy");
1085 return nullptr;
1086 }
1087 std::string ipOrMacInfo;
1088 int32_t ret = networkManagerProxy->GetIpOrMacAddress(adapterAddonData.data, policyCode, ipOrMacInfo);
1089 if (FAILED(ret)) {
1090 napi_throw(env, CreateError(env, ret));
1091 return nullptr;
1092 }
1093 napi_value result = nullptr;
1094 NAPI_CALL(env, napi_create_string_utf8(env, ipOrMacInfo.c_str(), NAPI_AUTO_LENGTH, &result));
1095 return result;
1096 }
1097
SetNetworkInterfaceDisabledSync(napi_env env,napi_callback_info info)1098 napi_value NetworkManagerAddon::SetNetworkInterfaceDisabledSync(napi_env env, napi_callback_info info)
1099 {
1100 EDMLOGI("NAPI_SetNetworkInterfaceDisabledSync called");
1101 AddonMethodSign addonMethodSign;
1102 SetNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_12);
1103 AdapterAddonData adapterAddonData{};
1104 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1105 return nullptr;
1106 }
1107 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1108 if (networkManagerProxy == nullptr) {
1109 EDMLOGE("can not get GetNetworkManagerProxy");
1110 return nullptr;
1111 }
1112 int32_t ret = networkManagerProxy->SetNetworkInterfaceDisabled(adapterAddonData.data);
1113 if (FAILED(ret)) {
1114 napi_throw(env, CreateError(env, ret));
1115 return nullptr;
1116 }
1117 return nullptr;
1118 }
1119
IsNetworkInterfaceDisabledSync(napi_env env,napi_callback_info info)1120 napi_value NetworkManagerAddon::IsNetworkInterfaceDisabledSync(napi_env env, napi_callback_info info)
1121 {
1122 EDMLOGI("NAPI_IsNetworkInterfaceDisabledSync called");
1123 AddonMethodSign addonMethodSign;
1124 IsNetworkInterfaceDisabledCommon(addonMethodSign, EdmConstants::PERMISSION_TAG_VERSION_12);
1125 AdapterAddonData adapterAddonData{};
1126 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1127 return nullptr;
1128 }
1129 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1130 if (networkManagerProxy == nullptr) {
1131 EDMLOGE("can not get GetNetworkManagerProxy");
1132 return nullptr;
1133 }
1134 bool isDisabled = false;
1135 int32_t ret = networkManagerProxy->IsNetworkInterfaceDisabled(adapterAddonData.data, isDisabled);
1136 if (FAILED(ret)) {
1137 napi_throw(env, CreateError(env, ret));
1138 return nullptr;
1139 }
1140 napi_value result = nullptr;
1141 NAPI_CALL(env, napi_get_boolean(env, isDisabled, &result));
1142 return result;
1143 }
1144
SetGlobalHttpProxyCommon(AddonMethodSign & addonMethodSign)1145 void NetworkManagerAddon::SetGlobalHttpProxyCommon(AddonMethodSign &addonMethodSign)
1146 {
1147 #ifdef NETMANAGER_BASE_EDM_ENABLE
1148 auto convertHttpProxy2Data = [](napi_env env, napi_value argv, MessageParcel &data,
1149 const AddonMethodSign &methodSign) {
1150 NetManagerStandard::HttpProxy httpProxy;
1151 bool isParseOk = ParseHttpProxyParam(env, argv, httpProxy);
1152 if (!isParseOk) {
1153 return false;
1154 }
1155 if (!httpProxy.Marshalling(data)) {
1156 EDMLOGE("NetworkManagerAddon::SetGlobalHttpProxyCommon Marshalling proxy fail.");
1157 return false;
1158 }
1159 int32_t accountId = -1;
1160 data.WriteInt32(accountId);
1161 return true;
1162 };
1163 addonMethodSign.name = "SetGlobalHttpProxy";
1164 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
1165 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1166 addonMethodSign.argsConvert = {nullptr, convertHttpProxy2Data};
1167 #endif
1168 }
1169
SetGlobalHttpProxyCommonForAccount(AddonMethodSign & addonMethodSign)1170 void NetworkManagerAddon::SetGlobalHttpProxyCommonForAccount(AddonMethodSign &addonMethodSign)
1171 {
1172 #ifdef NETMANAGER_BASE_EDM_ENABLE
1173 auto convertHttpProxy2Data = [](napi_env env, napi_value argv, MessageParcel &data,
1174 const AddonMethodSign &methodSign) {
1175 NetManagerStandard::HttpProxy httpProxy;
1176 bool isParseOk = ParseHttpProxyParam(env, argv, httpProxy);
1177 if (!isParseOk) {
1178 return false;
1179 }
1180 if (!httpProxy.Marshalling(data)) {
1181 EDMLOGE("NetworkManagerAddon::SetGlobalHttpProxyCommonForAccount Marshalling proxy fail.");
1182 return false;
1183 }
1184 return true;
1185 };
1186 addonMethodSign.name = "SetGlobalHttpProxyForAccountSync";
1187 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM, EdmAddonCommonType::INT32};
1188 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1189 addonMethodSign.argsConvert = {nullptr, convertHttpProxy2Data, nullptr};
1190 #endif
1191 }
1192
SetGlobalHttpProxyCommonLogic(napi_env env,napi_callback_info info,AddonMethodSign & addonMethodSign)1193 napi_value NetworkManagerAddon::SetGlobalHttpProxyCommonLogic(napi_env env, napi_callback_info info,
1194 AddonMethodSign& addonMethodSign)
1195 {
1196 #ifdef NETMANAGER_BASE_EDM_ENABLE
1197 AdapterAddonData adapterAddonData{};
1198 if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
1199 return nullptr;
1200 }
1201
1202 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1203 if (networkManagerProxy == nullptr) {
1204 EDMLOGE("can not get GetNetworkManagerProxy");
1205 return nullptr;
1206 }
1207
1208 int32_t ret = networkManagerProxy->SetGlobalHttpProxy(adapterAddonData.data);
1209 if (FAILED(ret)) {
1210 napi_throw(env, CreateError(env, ret));
1211 return nullptr;
1212 }
1213 return nullptr;
1214 #endif
1215 }
1216
SetGlobalHttpProxySync(napi_env env,napi_callback_info info)1217 napi_value NetworkManagerAddon::SetGlobalHttpProxySync(napi_env env, napi_callback_info info)
1218 {
1219 EDMLOGI("NAPI_SetGlobalHttpProxySync called");
1220 #ifdef NETMANAGER_BASE_EDM_ENABLE
1221 AddonMethodSign addonMethodSign;
1222 SetGlobalHttpProxyCommon(addonMethodSign);
1223
1224 return SetGlobalHttpProxyCommonLogic(env, info, addonMethodSign);
1225 #else
1226 EDMLOGW("NetworkManagerAddon::SetGlobalHttpProxySync Unsupported Capabilities.");
1227 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1228 return nullptr;
1229 #endif
1230 }
1231
SetGlobalHttpProxyForAccountSync(napi_env env,napi_callback_info info)1232 napi_value NetworkManagerAddon::SetGlobalHttpProxyForAccountSync(napi_env env, napi_callback_info info)
1233 {
1234 EDMLOGI("NAPI_SetGlobalHttpProxyForAccountSync called");
1235 #if defined(FEATURE_PC_ONLY) && defined(NETMANAGER_BASE_EDM_ENABLE)
1236 AddonMethodSign addonMethodSign;
1237 SetGlobalHttpProxyCommonForAccount(addonMethodSign);
1238
1239 return SetGlobalHttpProxyCommonLogic(env, info, addonMethodSign);
1240 #else
1241 EDMLOGW("NetworkManagerAddon::SetGlobalHttpProxyForAccountSync Unsupported Capabilities.");
1242 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1243 return nullptr;
1244 #endif
1245 }
1246
GetGlobalHttpProxyCommon(napi_env env,napi_value * argv,size_t argc,bool hasAdmin,OHOS::AppExecFwk::ElementName & elementName,int32_t accountId)1247 napi_value NetworkManagerAddon::GetGlobalHttpProxyCommon(
1248 napi_env env, napi_value *argv, size_t argc, bool hasAdmin,
1249 OHOS::AppExecFwk::ElementName &elementName, int32_t accountId)
1250 {
1251 #ifdef NETMANAGER_BASE_EDM_ENABLE
1252 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
1253 ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
1254 "param admin need be null or want");
1255
1256 if (hasAdmin) {
1257 EDMLOGD("GetGlobalHttpProxySync: elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
1258 elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
1259 } else {
1260 EDMLOGD("GetGlobalHttpProxySync: elementName is null");
1261 }
1262
1263 auto networkManagerProxy = NetworkManagerProxy::GetNetworkManagerProxy();
1264 if (networkManagerProxy == nullptr) {
1265 EDMLOGE("can not get GetNetworkManagerProxy");
1266 return nullptr;
1267 }
1268
1269 NetManagerStandard::HttpProxy httpProxy;
1270 int32_t ret = ERR_OK;
1271 if (hasAdmin) {
1272 ret = networkManagerProxy->GetGlobalHttpProxy(&elementName, httpProxy, accountId);
1273 } else {
1274 ret = networkManagerProxy->GetGlobalHttpProxy(nullptr, httpProxy, accountId);
1275 }
1276
1277 if (FAILED(ret)) {
1278 napi_throw(env, CreateError(env, ret));
1279 return nullptr;
1280 }
1281
1282 return ConvertHttpProxyToJS(env, httpProxy);
1283 #else
1284 EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxyCommon Unsupported Capabilities.");
1285 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1286 return nullptr;
1287 #endif
1288 }
1289
GetGlobalHttpProxySync(napi_env env,napi_callback_info info)1290 napi_value NetworkManagerAddon::GetGlobalHttpProxySync(napi_env env, napi_callback_info info)
1291 {
1292 EDMLOGI("NAPI_GetGlobalHttpProxySync called");
1293 #ifdef NETMANAGER_BASE_EDM_ENABLE
1294 size_t argc = ARGS_SIZE_ONE;
1295 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
1296 napi_value thisArg = nullptr;
1297 void *data = nullptr;
1298 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1299
1300 bool hasAdmin = false;
1301 OHOS::AppExecFwk::ElementName elementName;
1302 return GetGlobalHttpProxyCommon(env, argv, argc, hasAdmin, elementName, -1);
1303 #else
1304 EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxy Unsupported Capabilities.");
1305 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1306 return nullptr;
1307 #endif
1308 }
1309
GetGlobalHttpProxyForAccountSync(napi_env env,napi_callback_info info)1310 napi_value NetworkManagerAddon::GetGlobalHttpProxyForAccountSync(napi_env env, napi_callback_info info)
1311 {
1312 EDMLOGI("NAPI_GetGlobalHttpProxyForAccountSync called");
1313 #if defined(FEATURE_PC_ONLY) && defined(NETMANAGER_BASE_EDM_ENABLE)
1314 size_t argc = ARGS_SIZE_TWO;
1315 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1316 napi_value thisArg = nullptr;
1317 void *data = nullptr;
1318 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1319 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1320
1321 bool hasAdmin = false;
1322 int32_t accountId = -1;
1323 OHOS::AppExecFwk::ElementName elementName;
1324 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
1325 "parameter accountId error");
1326 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
1327 "parameter accountId parse error");
1328
1329 return GetGlobalHttpProxyCommon(env, argv, argc, hasAdmin, elementName, accountId);
1330 #else
1331 EDMLOGW("NetworkManagerAddon::GetGlobalHttpProxyForAccountSync Unsupported Capabilities.");
1332 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1333 return nullptr;
1334 #endif
1335 }
1336
TurnOnMobileData(napi_env env,napi_callback_info info)1337 napi_value NetworkManagerAddon::TurnOnMobileData(napi_env env, napi_callback_info info)
1338 {
1339 EDMLOGI("NAPI_TurnOnMobileData called");
1340 #if defined(CELLULAR_DATA_EDM_ENABLE)
1341 size_t argc = ARGS_SIZE_TWO;
1342 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1343 napi_value thisArg = nullptr;
1344 void *data = nullptr;
1345 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1346 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1347 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
1348 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
1349 bool hasIsForce = MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean);
1350 ASSERT_AND_THROW_PARAM_ERROR(env, hasIsForce, "The second parameter must be boolean.");
1351
1352 OHOS::AppExecFwk::ElementName elementName;
1353 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
1354 "element name param error");
1355 bool isForce;
1356 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, isForce, argv[ARR_INDEX_ONE]),
1357 "isForce name param error");
1358 if (isForce) {
1359 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->ForceTurnOnMobileData(elementName);
1360 if (FAILED(ret)) {
1361 napi_throw(env, CreateError(env, ret));
1362 }
1363 } else {
1364 AddonMethodSign addonMethodSign;
1365 addonMethodSign.name = "TurnOnMobileData";
1366 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::BOOLEAN};
1367 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1368 AdapterAddonData adapterAddonData{};
1369 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
1370 if (result == nullptr) {
1371 return nullptr;
1372 }
1373 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->TurnOnMobileData(adapterAddonData.data);
1374 if (FAILED(ret)) {
1375 napi_throw(env, CreateError(env, ret));
1376 }
1377 }
1378 return nullptr;
1379 #else
1380 EDMLOGW("NetworkManagerAddon::TurnOnMobileData Unsupported Capabilities.");
1381 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1382 return nullptr;
1383 #endif
1384 }
1385
TurnOffMobileData(napi_env env,napi_callback_info info)1386 napi_value NetworkManagerAddon::TurnOffMobileData(napi_env env, napi_callback_info info)
1387 {
1388 EDMLOGI("NAPI_TurnOffMobileData called");
1389 #if defined(CELLULAR_DATA_EDM_ENABLE)
1390 AddonMethodSign addonMethodSign;
1391 addonMethodSign.name = "TurnOffMobileData";
1392 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
1393 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1394 AdapterAddonData adapterAddonData{};
1395 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
1396 if (result == nullptr) {
1397 return nullptr;
1398 }
1399 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->TurnOffMobileData(adapterAddonData.data);
1400 if (FAILED(ret)) {
1401 napi_throw(env, CreateError(env, ret));
1402 }
1403 return nullptr;
1404 #else
1405 EDMLOGW("NetworkManagerAddon::TurnOffMobileData Unsupported Capabilities.");
1406 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1407 return nullptr;
1408 #endif
1409 }
1410
CheckParameters(const std::map<std::string,std::string> & parameters)1411 bool NetworkManagerAddon::CheckParameters(const std::map<std::string, std::string> ¶meters)
1412 {
1413 for (auto &ele : REQUIRED_APN_INFO_KEYS) {
1414 if (parameters.find(ele) == parameters.end() || parameters.at(ele) == "") {
1415 EDMLOGE("CheckParameters::Required is null.");
1416 return false;
1417 }
1418 }
1419 bool allValid = std::all_of(parameters.begin(), parameters.end(), [](auto &i) {
1420 bool valid = ALL_APN_INFO_KEYS.find(i.first) != ALL_APN_INFO_KEYS.end();
1421 if (!valid) {
1422 EDMLOGE("invalid key: %{public}s", i.first.c_str());
1423 }
1424 return valid;
1425 });
1426 return allValid;
1427 }
1428
KeyToField(const std::map<std::string,std::string> & parameters,std::map<std::string,std::string> & results)1429 void KeyToField(const std::map<std::string, std::string> ¶meters, std::map<std::string, std::string> &results)
1430 {
1431 for (const auto &[key, value] : KEY_TO_FIELD) {
1432 auto it = parameters.find(key);
1433 if (it != parameters.end()) {
1434 results[value] = it->second;
1435 }
1436 }
1437 }
1438
FieldToKey(const std::map<std::string,std::string> & parameters,std::map<std::string,std::string> & results)1439 void FieldToKey(const std::map<std::string, std::string> ¶meters, std::map<std::string, std::string> &results)
1440 {
1441 for (const auto &[key, value] : KEY_TO_FIELD) {
1442 auto it = parameters.find(value);
1443 if (it != parameters.end()) {
1444 results[key] = it->second;
1445 }
1446 }
1447 }
1448
ParametersTransform(const std::map<std::string,std::string> & parameters,std::map<std::string,std::string> & results)1449 void ParametersTransform(const std::map<std::string, std::string> ¶meters,
1450 std::map<std::string, std::string> &results)
1451 {
1452 results = {
1453 {"profile_name", parameters.at("profile_name")},
1454 {"mcc", parameters.at("mcc")},
1455 {"mnc", parameters.at("mnc")},
1456 {"apn", parameters.at("apn")},
1457 {"edited", "1"}
1458 };
1459
1460 std::set<std::string> optionalKeys;
1461 std::set_difference(
1462 ALL_APN_INFO_KEYS.begin(), ALL_APN_INFO_KEYS.end(),
1463 REQUIRED_APN_INFO_KEYS.begin(), REQUIRED_APN_INFO_KEYS.end(),
1464 std::inserter(optionalKeys, optionalKeys.begin())
1465 );
1466 for (const auto& ele : optionalKeys) {
1467 std::string field = KEY_TO_FIELD.at(ele);
1468 if (parameters.find(field) != parameters.end()) {
1469 results[field] = parameters.at(field);
1470 }
1471 }
1472
1473 if (parameters.find("apn_types") == parameters.end()) {
1474 results["apn_types"] = "default";
1475 }
1476 if (results.find("auth_type") == results.end() ||
1477 (results.at("auth_type") != "0" && results.at("auth_type") != "1" &&
1478 results.at("auth_type") != "2" && results.at("auth_type") != "3")) {
1479 results["auth_type"] = "-1";
1480 }
1481 }
1482
1483 #ifdef CELLULAR_DATA_EDM_ENABLE
ParsePwd(napi_env env,napi_value args,ApnPassword & apnPassword)1484 static bool ParsePwd(napi_env env, napi_value args, ApnPassword &apnPassword)
1485 {
1486 napi_valuetype valueType;
1487 if (napi_typeof(env, args, &valueType) != napi_ok || valueType != napi_object) {
1488 EDMLOGE("Parameter 'args' must be an object.");
1489 return false;
1490 }
1491
1492 bool hasProperty = false;
1493 if (napi_has_named_property(env, args, "password", &hasProperty) != napi_ok || !hasProperty) {
1494 return true;
1495 }
1496
1497 napi_value pwdValue;
1498 if (napi_get_named_property(env, args, "password", &pwdValue) != napi_ok) {
1499 EDMLOGE("ParsePwd: napi_get_named_property failed.");
1500 return false;
1501 }
1502
1503 if (napi_get_value_string_utf8(env, pwdValue, nullptr, 0, &apnPassword.passwordSize) != napi_ok) {
1504 EDMLOGE("ParsePwd: napi_get_value_string_utf8 failed.");
1505 return false;
1506 }
1507
1508 if (apnPassword.passwordSize > ApnPassword::MAX_PASSWORD_SIZE) {
1509 EDMLOGE("ParsePwd: The password length exceeds the limit.");
1510 return false;
1511 }
1512
1513 apnPassword.password = static_cast<char *>(calloc(apnPassword.passwordSize + 1, 1));
1514 if (!apnPassword.password) {
1515 EDMLOGE("ParsePwd: calloc failed.");
1516 return false;
1517 }
1518
1519 if (napi_get_value_string_utf8(env, pwdValue, apnPassword.password, apnPassword.passwordSize + 1, nullptr)
1520 != napi_ok) {
1521 EDMLOGE("ParsePwd: napi_get_value_string_utf8 failed.");
1522 return false;
1523 }
1524
1525 napi_value pwdKey;
1526 if (napi_create_string_utf8(env, "password", PASSWORD_KEY_LENGTH, &pwdKey) != napi_ok) {
1527 EDMLOGE("ParsePwd: napi_create_string_utf8 failed.");
1528 return false;
1529 }
1530
1531 bool deleteSuccess = false;
1532 if (napi_delete_property(env, args, pwdKey, &deleteSuccess) != napi_ok || !deleteSuccess) {
1533 EDMLOGE("ParsePwd: napi_delete_property failed.");
1534 return false;
1535 }
1536
1537 return true;
1538 }
1539 #endif
1540
AddApn(napi_env env,napi_callback_info info)1541 napi_value NetworkManagerAddon::AddApn(napi_env env, napi_callback_info info)
1542 {
1543 EDMLOGI("NAPI_AddApn called");
1544 #if defined(CELLULAR_DATA_EDM_ENABLE)
1545 size_t argc = ARGS_SIZE_TWO;
1546 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1547 napi_value thisArg = nullptr;
1548 void *data = nullptr;
1549 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1550 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1551 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
1552 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
1553 bool hasApnInfo = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
1554 ASSERT_AND_THROW_PARAM_ERROR(env, hasApnInfo, "The second parameter must be ApnInfo.");
1555
1556 OHOS::AppExecFwk::ElementName elementName;
1557 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
1558 "element name param error");
1559 ApnPassword apnPassword;
1560 if (!ParsePwd(env, argv[ARR_INDEX_ONE], apnPassword)) {
1561 return nullptr;
1562 }
1563 std::map<std::string, std::string> apnInfoMap;
1564 ASSERT_AND_THROW_PARAM_ERROR(env, ParseMapStringAndString(env, apnInfoMap, argv[ARR_INDEX_ONE]),
1565 "apnInfo name param error");
1566
1567 ASSERT_AND_THROW_PARAM_ERROR(env, CheckParameters(apnInfoMap), "Required fields is null");
1568 std::map<std::string, std::string> apnInfoMapEx;
1569 KeyToField(apnInfoMap, apnInfoMapEx);
1570
1571 std::map<std::string, std::string> apnInfoMapTf;
1572 ParametersTransform(apnInfoMapEx, apnInfoMapTf);
1573
1574 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->AddApn(elementName, apnInfoMapTf, apnPassword);
1575 if (FAILED(ret)) {
1576 napi_throw(env, CreateError(env, ret));
1577 }
1578 return nullptr;
1579 #else
1580 EDMLOGW("NetworkManagerAddon::AddApn Unsupported Capabilities.");
1581 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1582 return nullptr;
1583 #endif
1584 }
1585
DeleteApn(napi_env env,napi_callback_info info)1586 napi_value NetworkManagerAddon::DeleteApn(napi_env env, napi_callback_info info)
1587 {
1588 EDMLOGI("NAPI_DeleteApn called");
1589 #if defined(CELLULAR_DATA_EDM_ENABLE)
1590 auto checkStringIsNull = [](napi_env env, napi_value argv, MessageParcel &data, const AddonMethodSign &methodSign) {
1591 std::string apnId;
1592 if (!ParseString(env, apnId, argv) || apnId.empty()) {
1593 return false;
1594 }
1595 return data.WriteString(apnId);
1596 };
1597 AddonMethodSign addonMethodSign;
1598 addonMethodSign.name = "DeleteApn";
1599 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::STRING};
1600 addonMethodSign.argsConvert = {nullptr, checkStringIsNull};
1601 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
1602 AdapterAddonData adapterAddonData{};
1603 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
1604 if (result == nullptr) {
1605 return nullptr;
1606 }
1607 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->DeleteApn(adapterAddonData.data);
1608 if (FAILED(ret)) {
1609 napi_throw(env, CreateError(env, ret));
1610 }
1611 return nullptr;
1612 #else
1613 EDMLOGW("NetworkManagerAddon::DeleteApn Unsupported Capabilities.");
1614 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1615 return nullptr;
1616 #endif
1617 }
1618
UpdateApn(napi_env env,napi_callback_info info)1619 napi_value NetworkManagerAddon::UpdateApn(napi_env env, napi_callback_info info)
1620 {
1621 EDMLOGI("NAPI_UpdateApn called");
1622 #if defined(CELLULAR_DATA_EDM_ENABLE)
1623 size_t argc = ARGS_SIZE_THREE;
1624 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
1625 napi_value thisArg = nullptr;
1626 void *data = nullptr;
1627 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1628 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
1629 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
1630 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
1631 bool hasApnInfo = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
1632 ASSERT_AND_THROW_PARAM_ERROR(env, hasApnInfo, "The second parameter must be ApnInfo.");
1633 bool hasApnId = MatchValueType(env, argv[ARR_INDEX_TWO], napi_string);
1634 ASSERT_AND_THROW_PARAM_ERROR(env, hasApnId, "The thrid parameter must be ApnId.");
1635
1636 OHOS::AppExecFwk::ElementName elementName;
1637 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
1638 "element name param error");
1639 ApnPassword apnPassword;
1640 if (!ParsePwd(env, argv[ARR_INDEX_ONE], apnPassword)) {
1641 return nullptr;
1642 }
1643 std::map<std::string, std::string> apnInfoMap;
1644 ASSERT_AND_THROW_PARAM_ERROR(env, ParseMapStringAndString(env, apnInfoMap, argv[ARR_INDEX_ONE]),
1645 "apnInfo param error");
1646 std::map<std::string, std::string> apnInfoMapEx;
1647 KeyToField(apnInfoMap, apnInfoMapEx);
1648 ASSERT_AND_THROW_PARAM_ERROR(env, apnInfoMapEx.size() != 0 || apnPassword.password != nullptr,
1649 "No parameters to update");
1650 std::string apnId;
1651 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, apnId, argv[ARR_INDEX_TWO]) && !apnId.empty(),
1652 "apnId param error");
1653
1654 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->UpdateApn(elementName, apnInfoMapEx, apnId,
1655 apnPassword);
1656 if (FAILED(ret)) {
1657 napi_throw(env, CreateError(env, ret));
1658 }
1659 return nullptr;
1660 #else
1661 EDMLOGW("NetworkManagerAddon::UpdateApn Unsupported Capabilities.");
1662 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1663 return nullptr;
1664 #endif
1665 }
1666
SetPreferApn(napi_env env,napi_callback_info info)1667 napi_value NetworkManagerAddon::SetPreferApn(napi_env env, napi_callback_info info)
1668 {
1669 EDMLOGI("NAPI_SetPreferApn called");
1670 #if defined(CELLULAR_DATA_EDM_ENABLE)
1671 size_t argc = ARGS_SIZE_TWO;
1672 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1673 napi_value thisArg = nullptr;
1674 void *data = nullptr;
1675 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1676 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1677 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
1678 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
1679 bool hasApnId = MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
1680 ASSERT_AND_THROW_PARAM_ERROR(env, hasApnId, "The second parameter must be ApnId.");
1681
1682 OHOS::AppExecFwk::ElementName elementName;
1683 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
1684 "element name param error");
1685
1686 std::string apnId;
1687 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, apnId, argv[ARR_INDEX_ONE]) && !apnId.empty(),
1688 "apnId param error");
1689
1690 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->SetPreferApn(elementName, apnId);
1691 if (FAILED(ret)) {
1692 napi_throw(env, CreateError(env, ret));
1693 }
1694 return nullptr;
1695 #else
1696 EDMLOGW("NetworkManagerAddon::SetPreferApn Unsupported Capabilities.");
1697 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1698 return nullptr;
1699 #endif
1700 }
1701
ConvertApnInfoToJS(napi_env env,const std::map<std::string,std::string> & apnInfo)1702 napi_value NetworkManagerAddon::ConvertApnInfoToJS(napi_env env, const std::map<std::string, std::string> &apnInfo)
1703 {
1704 std::map<std::string, std::string> apnInfoEx;
1705 FieldToKey(apnInfo, apnInfoEx);
1706 napi_value info = nullptr;
1707 NAPI_CALL(env, napi_create_object(env, &info));
1708
1709 for (const auto& iter : apnInfoEx) {
1710 napi_value napiValue = nullptr;
1711 std::string key = iter.first;
1712 std::string value = iter.second;
1713 NAPI_CALL(env, napi_create_string_utf8(env, value.c_str(), value.length(), &napiValue));
1714 NAPI_CALL(env, napi_set_named_property(env, info, key.c_str(), napiValue));
1715 }
1716
1717 return info;
1718 }
1719
QueryApnInfoById(napi_env env,const OHOS::AppExecFwk::ElementName & admin,napi_value param)1720 napi_value NetworkManagerAddon::QueryApnInfoById(napi_env env, const OHOS::AppExecFwk::ElementName &admin,
1721 napi_value param)
1722 {
1723 std::string apnId;
1724 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, apnId, param) && !apnId.empty(), "apnId param error");
1725 std::map<std::string, std::string> apnInfo;
1726 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->QueryApn(admin, apnId, apnInfo);
1727 if (FAILED(ret)) {
1728 napi_throw(env, CreateError(env, ret));
1729 return nullptr;
1730 }
1731
1732 return ConvertApnInfoToJS(env, apnInfo);
1733 }
1734
QueryApnIds(napi_env env,const OHOS::AppExecFwk::ElementName & admin,napi_value param)1735 napi_value NetworkManagerAddon::QueryApnIds(napi_env env, const OHOS::AppExecFwk::ElementName &admin, napi_value param)
1736 {
1737 std::map<std::string, std::string> apnInfo;
1738 ASSERT_AND_THROW_PARAM_ERROR(env, ParseMapStringAndString(env, apnInfo, param),
1739 "apnInfo param error");
1740 ASSERT_AND_THROW_PARAM_ERROR(env, apnInfo.find("password") == apnInfo.end(), "pwd can't be used when querying");
1741 std::map<std::string, std::string> apnInfoEx;
1742 KeyToField(apnInfo, apnInfoEx);
1743
1744 std::vector<std::string> apnIds;
1745 int32_t ret = NetworkManagerProxy::GetNetworkManagerProxy()->QueryApnIds(admin, apnInfoEx, apnIds);
1746 if (FAILED(ret)) {
1747 napi_throw(env, CreateError(env, ret));
1748 return nullptr;
1749 }
1750
1751 napi_value jsList = nullptr;
1752 NAPI_CALL(env, napi_create_array_with_length(env, apnIds.size(), &jsList));
1753 ConvertStringVectorToJS(env, apnIds, jsList);
1754 return jsList;
1755 }
1756
QueryApn(napi_env env,napi_callback_info info)1757 napi_value NetworkManagerAddon::QueryApn(napi_env env, napi_callback_info info)
1758 {
1759 EDMLOGI("NAPI_QueryApn called");
1760 #if defined(CELLULAR_DATA_EDM_ENABLE)
1761 size_t argc = ARGS_SIZE_TWO;
1762 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1763 napi_value thisArg = nullptr;
1764 void *data = nullptr;
1765 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1766 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
1767 bool hasAdmin = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object);
1768 ASSERT_AND_THROW_PARAM_ERROR(env, hasAdmin, "The first parameter must be want.");
1769 bool hasApnId = MatchValueType(env, argv[ARR_INDEX_ONE], napi_string);
1770 bool hasApnInfo = MatchValueType(env, argv[ARR_INDEX_ONE], napi_object);
1771 ASSERT_AND_THROW_PARAM_ERROR(env, (hasApnId || hasApnInfo), "The second parameter must be ApnId.");
1772
1773 OHOS::AppExecFwk::ElementName elementName;
1774 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
1775 "element name param error");
1776
1777 if (hasApnId) {
1778 return QueryApnInfoById(env, elementName, argv[ARR_INDEX_ONE]);
1779 } else if (hasApnInfo) {
1780 return QueryApnIds(env, elementName, argv[ARR_INDEX_ONE]);
1781 }
1782 return nullptr;
1783 #else
1784 EDMLOGW("NetworkManagerAddon::SetPreferApn Unsupported Capabilities.");
1785 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
1786 return nullptr;
1787 #endif
1788 }
1789
1790 static napi_module g_networkManagerModule = {
1791 .nm_version = 1,
1792 .nm_flags = 0,
1793 .nm_filename = nullptr,
1794 .nm_register_func = NetworkManagerAddon::Init,
1795 .nm_modname = "enterprise.networkManager",
1796 .nm_priv = ((void *)0),
1797 .reserved = {0},
1798 };
1799
NetworkManagerRegister()1800 extern "C" __attribute__((constructor)) void NetworkManagerRegister()
1801 {
1802 napi_module_register(&g_networkManagerModule);
1803 }