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
16 #include "network_manager_proxy.h"
17
18 #include "edm_constants.h"
19 #include "edm_ipc_interface_code.h"
20 #include "edm_log.h"
21 #include "func_code.h"
22
23 namespace OHOS {
24 namespace EDM {
25 std::shared_ptr<NetworkManagerProxy> NetworkManagerProxy::instance_ = nullptr;
26 std::once_flag NetworkManagerProxy::flag_;
27 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
28
NetworkManagerProxy()29 NetworkManagerProxy::NetworkManagerProxy() {}
30
~NetworkManagerProxy()31 NetworkManagerProxy::~NetworkManagerProxy() {}
32
GetNetworkManagerProxy()33 std::shared_ptr<NetworkManagerProxy> NetworkManagerProxy::GetNetworkManagerProxy()
34 {
35 std::call_once(flag_, []() {
36 if (instance_ == nullptr) {
37 instance_ = std::make_shared<NetworkManagerProxy>();
38 }
39 });
40 return instance_;
41 }
42
GetAllNetworkInterfaces(const AppExecFwk::ElementName & admin,std::vector<std::string> & networkInterface,bool isSync)43 int32_t NetworkManagerProxy::GetAllNetworkInterfaces(const AppExecFwk::ElementName &admin,
44 std::vector<std::string> &networkInterface, bool isSync)
45 {
46 #ifdef NETMANAGER_BASE_EDM_ENABLE
47 EDMLOGD("NetworkManagerProxy::GetAllNetworkInterfaces");
48 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
49 MessageParcel data;
50 MessageParcel reply;
51 data.WriteInterfaceToken(DESCRIPTOR);
52 data.WriteInt32(WITHOUT_USERID);
53 data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
54 data.WriteInt32(HAS_ADMIN);
55 data.WriteParcelable(&admin);
56 proxy->GetPolicy(EdmInterfaceCode::GET_NETWORK_INTERFACES, data, reply);
57 int32_t ret = ERR_INVALID_VALUE;
58 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
59 if (!blRes) {
60 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
61 return ret;
62 }
63 reply.ReadStringVector(&networkInterface);
64 return ERR_OK;
65 #else
66 EDMLOGW("NetworkManagerProxy::GetAllNetworkInterfaces Unsupported Capabilities.");
67 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
68 #endif
69 }
70
GetAllNetworkInterfaces(MessageParcel & data,std::vector<std::string> & networkInterface)71 int32_t NetworkManagerProxy::GetAllNetworkInterfaces(MessageParcel &data,
72 std::vector<std::string> &networkInterface)
73 {
74 #ifdef NETMANAGER_BASE_EDM_ENABLE
75 EDMLOGD("NetworkManagerProxy::GetAllNetworkInterfaces");
76 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
77 MessageParcel reply;
78 proxy->GetPolicy(EdmInterfaceCode::GET_NETWORK_INTERFACES, data, reply);
79 int32_t ret = ERR_INVALID_VALUE;
80 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
81 if (!blRes) {
82 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
83 return ret;
84 }
85 reply.ReadStringVector(&networkInterface);
86 return ERR_OK;
87 #else
88 EDMLOGW("NetworkManagerProxy::GetAllNetworkInterfaces Unsupported Capabilities.");
89 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
90 #endif
91 }
92
GetIpOrMacAddress(const AppExecFwk::ElementName & admin,const std::string & networkInterface,int policyCode,std::string & info,bool isSync)93 int32_t NetworkManagerProxy::GetIpOrMacAddress(const AppExecFwk::ElementName &admin,
94 const std::string &networkInterface, int policyCode, std::string &info, bool isSync)
95 {
96 #ifdef NETMANAGER_BASE_EDM_ENABLE
97 EDMLOGD("NetworkManagerProxy::GetIpOrMacAddress");
98 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
99 MessageParcel data;
100 MessageParcel reply;
101 data.WriteInterfaceToken(DESCRIPTOR);
102 data.WriteInt32(WITHOUT_USERID);
103 data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
104 data.WriteInt32(HAS_ADMIN);
105 data.WriteParcelable(&admin);
106 data.WriteString(networkInterface);
107 proxy->GetPolicy(policyCode, data, reply);
108 int32_t ret = ERR_INVALID_VALUE;
109 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
110 if (!blRes) {
111 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
112 return ret;
113 }
114 reply.ReadString(info);
115 return ERR_OK;
116 #else
117 EDMLOGW("NetworkManagerProxy::GetIpOrMacAddress Unsupported Capabilities.");
118 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
119 #endif
120 }
121
GetIpOrMacAddress(MessageParcel & data,int policyCode,std::string & info)122 int32_t NetworkManagerProxy::GetIpOrMacAddress(MessageParcel &data, int policyCode, std::string &info)
123 {
124 #ifdef NETMANAGER_BASE_EDM_ENABLE
125 EDMLOGD("NetworkManagerProxy::GetIpOrMacAddress");
126 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
127 MessageParcel reply;
128 proxy->GetPolicy(policyCode, data, reply);
129 int32_t ret = ERR_INVALID_VALUE;
130 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
131 if (!blRes) {
132 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
133 return ret;
134 }
135 reply.ReadString(info);
136 return ERR_OK;
137 #else
138 EDMLOGW("NetworkManagerProxy::GetIpOrMacAddress Unsupported Capabilities.");
139 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
140 #endif
141 }
142
SetNetworkInterfaceDisabled(const AppExecFwk::ElementName & admin,const std::string & networkInterface,bool isDisabled,bool isSync)143 int32_t NetworkManagerProxy::SetNetworkInterfaceDisabled(const AppExecFwk::ElementName &admin,
144 const std::string &networkInterface, bool isDisabled, bool isSync)
145 {
146 #ifdef NETMANAGER_BASE_EDM_ENABLE
147 EDMLOGD("NetworkManagerProxy::SetNetworkInterfaceDisabled");
148 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
149 MessageParcel data;
150 std::uint32_t funcCode =
151 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_NETWORK_INTERFACE);
152 data.WriteInterfaceToken(DESCRIPTOR);
153 data.WriteInt32(WITHOUT_USERID);
154 data.WriteParcelable(&admin);
155 data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
156 std::vector<std::string> key{networkInterface};
157 std::vector<std::string> value{isDisabled ? "true" : "false"};
158 data.WriteStringVector(key);
159 data.WriteStringVector(value);
160 return proxy->HandleDevicePolicy(funcCode, data);
161 #else
162 EDMLOGW("NetworkManagerProxy::SetNetworkInterfaceDisabled Unsupported Capabilities.");
163 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
164 #endif
165 }
166
SetNetworkInterfaceDisabled(MessageParcel & data)167 int32_t NetworkManagerProxy::SetNetworkInterfaceDisabled(MessageParcel &data)
168 {
169 #ifdef NETMANAGER_BASE_EDM_ENABLE
170 EDMLOGD("NetworkManagerProxy::SetNetworkInterfaceDisabled");
171 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
172 std::uint32_t funcCode =
173 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_NETWORK_INTERFACE);
174 return proxy->HandleDevicePolicy(funcCode, data);
175 #else
176 EDMLOGW("NetworkManagerProxy::SetNetworkInterfaceDisabled Unsupported Capabilities.");
177 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
178 #endif
179 }
180
IsNetworkInterfaceDisabled(const AppExecFwk::ElementName & admin,const std::string & networkInterface,bool & status,bool isSync)181 int32_t NetworkManagerProxy::IsNetworkInterfaceDisabled(const AppExecFwk::ElementName &admin,
182 const std::string &networkInterface, bool &status, bool isSync)
183 {
184 #ifdef NETMANAGER_BASE_EDM_ENABLE
185 EDMLOGD("NetworkManagerProxy::IsNetworkInterfaceDisabled");
186 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
187 MessageParcel data;
188 MessageParcel reply;
189 data.WriteInterfaceToken(DESCRIPTOR);
190 data.WriteInt32(WITHOUT_USERID);
191 data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
192 data.WriteInt32(HAS_ADMIN);
193 data.WriteParcelable(&admin);
194 data.WriteString(networkInterface);
195 proxy->GetPolicy(EdmInterfaceCode::DISABLED_NETWORK_INTERFACE, data, reply);
196 int32_t ret = ERR_INVALID_VALUE;
197 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
198 if (!blRes) {
199 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
200 return ret;
201 }
202 reply.ReadBool(status);
203 return ERR_OK;
204 #else
205 EDMLOGW("NetworkManagerProxy::IsNetworkInterfaceDisabled Unsupported Capabilities.");
206 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
207 #endif
208 }
209
IsNetworkInterfaceDisabled(MessageParcel & data,bool & status)210 int32_t NetworkManagerProxy::IsNetworkInterfaceDisabled(MessageParcel &data, bool &status)
211 {
212 #ifdef NETMANAGER_BASE_EDM_ENABLE
213 EDMLOGD("NetworkManagerProxy::IsNetworkInterfaceDisabled");
214 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
215 MessageParcel reply;
216 proxy->GetPolicy(EdmInterfaceCode::DISABLED_NETWORK_INTERFACE, data, reply);
217 int32_t ret = ERR_INVALID_VALUE;
218 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
219 if (!blRes) {
220 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
221 return ret;
222 }
223 reply.ReadBool(status);
224 return ERR_OK;
225 #else
226 EDMLOGW("NetworkManagerProxy::IsNetworkInterfaceDisabled Unsupported Capabilities.");
227 return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
228 #endif
229 }
230
AddIptablesFilterRule(MessageParcel & data)231 int32_t NetworkManagerProxy::AddIptablesFilterRule(MessageParcel &data)
232 {
233 EDMLOGD("NetworkManagerProxy::AddIptablesFilterRule");
234 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::SET),
235 EdmInterfaceCode::IPTABLES_RULE);
236 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
237 }
238
RemoveIptablesFilterRule(MessageParcel & data)239 int32_t NetworkManagerProxy::RemoveIptablesFilterRule(MessageParcel &data)
240 {
241 EDMLOGD("NetworkManagerProxy::RemoveIptablesFilterRule");
242 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::REMOVE),
243 EdmInterfaceCode::IPTABLES_RULE);
244 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
245 }
246
ListIptablesFilterRules(MessageParcel & data,std::string & result)247 int32_t NetworkManagerProxy::ListIptablesFilterRules(MessageParcel &data, std::string &result)
248 {
249 EDMLOGD("NetworkManagerProxy::ListIptablesFilterRules");
250 MessageParcel reply;
251 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::IPTABLES_RULE, data, reply);
252 int32_t ret = ERR_INVALID_VALUE;
253 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
254 if (!blRes) {
255 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
256 return ret;
257 }
258 reply.ReadString(result);
259 return ERR_OK;
260 }
261
AddFirewallRule(MessageParcel & data)262 int32_t NetworkManagerProxy::AddFirewallRule(MessageParcel &data)
263 {
264 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::SET),
265 EdmInterfaceCode::FIREWALL_RULE);
266 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
267 }
268
RemoveFirewallRule(const AppExecFwk::ElementName & admin,const IPTABLES::FirewallRule & rule)269 int32_t NetworkManagerProxy::RemoveFirewallRule(const AppExecFwk::ElementName &admin,
270 const IPTABLES::FirewallRule &rule)
271 {
272 MessageParcel data;
273 data.WriteInterfaceToken(DESCRIPTOR);
274 data.WriteInt32(WITHOUT_USERID);
275 data.WriteParcelable(&admin);
276 data.WriteString(WITHOUT_PERMISSION_TAG);
277 IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
278 if (!firewallRuleParcel.Marshalling(data)) {
279 EDMLOGE("NetworkManagerProxy::RemoveFirewallRule Marshalling rule fail.");
280 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
281 }
282 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::REMOVE),
283 EdmInterfaceCode::FIREWALL_RULE);
284 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
285 }
286
GetFirewallRules(MessageParcel & data,std::vector<IPTABLES::FirewallRule> & result)287 int32_t NetworkManagerProxy::GetFirewallRules(MessageParcel &data,
288 std::vector<IPTABLES::FirewallRule> &result)
289 {
290 MessageParcel reply;
291 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::FIREWALL_RULE, data, reply);
292 int32_t ret = ERR_INVALID_VALUE;
293 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
294 if (!blRes) {
295 EDMLOGE("EnterpriseDeviceMgrProxy:GetFirewallRules fail. %{public}d", ret);
296 return ret;
297 }
298 int32_t size = reply.ReadInt32();
299 if (size > EdmConstants::DEFAULT_LOOP_MAX_SIZE) {
300 EDMLOGE("EnterpriseDeviceMgrProxy:GetFirewallRules size overlimit. size: %{public}d", size);
301 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
302 }
303 for (int32_t i = 0; i < size; i++) {
304 IPTABLES::FirewallRuleParcel firewallRuleParcel;
305 if (!IPTABLES::FirewallRuleParcel::Unmarshalling(reply, firewallRuleParcel)) {
306 EDMLOGE("NetworkManagerProxy::GetFirewallRules Unmarshalling rule fail.");
307 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
308 }
309 result.push_back(firewallRuleParcel.GetRule());
310 }
311 EDMLOGD("EnterpriseDeviceMgrProxy:GetFirewallRules success. %{public}d", size);
312 return ERR_OK;
313 }
314
AddDomainFilterRule(MessageParcel & data)315 int32_t NetworkManagerProxy::AddDomainFilterRule(MessageParcel &data)
316 {
317 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::SET),
318 EdmInterfaceCode::DOMAIN_FILTER_RULE);
319 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
320 }
321
RemoveDomainFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::DomainFilterRule & rule)322 int32_t NetworkManagerProxy::RemoveDomainFilterRule(const AppExecFwk::ElementName &admin,
323 const IPTABLES::DomainFilterRule &rule)
324 {
325 MessageParcel data;
326 data.WriteInterfaceToken(DESCRIPTOR);
327 data.WriteInt32(WITHOUT_USERID);
328 data.WriteParcelable(&admin);
329 data.WriteString(WITHOUT_PERMISSION_TAG);
330 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
331 if (!domainFilterRuleParcel.Marshalling(data)) {
332 EDMLOGE("NetworkManagerProxy::RemoveDomainFilterRule Marshalling rule fail.");
333 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
334 }
335 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::REMOVE),
336 EdmInterfaceCode::DOMAIN_FILTER_RULE);
337 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
338 }
339
GetDomainFilterRules(MessageParcel & data,std::vector<IPTABLES::DomainFilterRule> & result)340 int32_t NetworkManagerProxy::GetDomainFilterRules(MessageParcel &data,
341 std::vector<IPTABLES::DomainFilterRule> &result)
342 {
343 MessageParcel reply;
344 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::DOMAIN_FILTER_RULE, data, reply);
345 int32_t ret = ERR_INVALID_VALUE;
346 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
347 if (!blRes) {
348 EDMLOGE("EnterpriseDeviceMgrProxy:GetDomainFilterRules fail. %{public}d", ret);
349 return ret;
350 }
351 int32_t size = reply.ReadInt32();
352 if (size > EdmConstants::DEFAULT_LOOP_MAX_SIZE) {
353 EDMLOGE("EnterpriseDeviceMgrProxy:GetDomainFilterRules size overlimit. size: %{public}d", size);
354 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
355 }
356 for (int32_t i = 0; i < size; i++) {
357 IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel;
358 if (!IPTABLES::DomainFilterRuleParcel::Unmarshalling(reply, domainFilterRuleParcel)) {
359 EDMLOGE("NetworkManagerProxy::GetDomainFilterRules Unmarshalling rule fail.");
360 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
361 }
362 result.push_back(domainFilterRuleParcel.GetRule());
363 }
364 EDMLOGD("EnterpriseDeviceMgrProxy:GetDomainFilterRules success. %{public}d", size);
365 return ERR_OK;
366 }
367
TurnOnMobileData(MessageParcel & data)368 int32_t NetworkManagerProxy::TurnOnMobileData(MessageParcel &data)
369 {
370 EDMLOGD("NetworkManagerProxy::TurnOnMobileData");
371 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET,
372 EdmInterfaceCode::TURNONOFF_MOBILE_DATA);
373 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
374 }
375
TurnOffMobileData(MessageParcel & data)376 int32_t NetworkManagerProxy::TurnOffMobileData(MessageParcel &data)
377 {
378 EDMLOGD("NetworkManagerProxy::TurnOffMobileData");
379 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE,
380 EdmInterfaceCode::TURNONOFF_MOBILE_DATA);
381 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
382 }
383
ForceTurnOnMobileData(const AppExecFwk::ElementName & admin)384 int32_t NetworkManagerProxy::ForceTurnOnMobileData(const AppExecFwk::ElementName &admin)
385 {
386 EDMLOGD("NetworkManagerProxy::ForceTurnOnMobileData");
387 MessageParcel data;
388 data.WriteInterfaceToken(DESCRIPTOR);
389 data.WriteInt32(WITHOUT_USERID);
390 data.WriteParcelable(&admin);
391 data.WriteString(WITHOUT_PERMISSION_TAG);
392 data.WriteString(EdmConstants::MobileData::FORCE_FLAG);
393 data.WriteInt32(EdmConstants::MobileData::FORCE_OPEN);
394 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET,
395 EdmInterfaceCode::DISALLOWED_MOBILE_DATA);
396 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
397 }
398
AddApn(const AppExecFwk::ElementName & admin,const std::map<std::string,std::string> & apnInfoMap,ApnPassword & apnPassword)399 int32_t NetworkManagerProxy::AddApn(const AppExecFwk::ElementName &admin,
400 const std::map<std::string, std::string> &apnInfoMap, ApnPassword &apnPassword)
401 {
402 MessageParcel data;
403 data.WriteInterfaceToken(DESCRIPTOR);
404 data.WriteInt32(WITHOUT_USERID);
405 data.WriteParcelable(&admin);
406 data.WriteString(WITHOUT_PERMISSION_TAG);
407 data.WriteString(EdmConstants::SetApn::ADD_FLAG);
408 if (apnInfoMap.size() > EdmConstants::SetApn::MAX_MAP_SIZE) {
409 return ERR_INVALID_VALUE;
410 }
411 data.WriteInt32(apnInfoMap.size());
412 for (const auto& iter : apnInfoMap) {
413 data.WriteString(iter.first);
414 }
415 for (const auto& iter : apnInfoMap) {
416 data.WriteString(iter.second);
417 }
418 if (apnPassword.password == nullptr) {
419 data.WriteInt32(-1);
420 } else {
421 data.WriteInt32(static_cast<int32_t>(apnPassword.passwordSize));
422 data.WriteCString(apnPassword.password);
423 }
424 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::SET),
425 EdmInterfaceCode::SET_APN_INFO);
426 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
427 }
428
DeleteApn(MessageParcel & data)429 int32_t NetworkManagerProxy::DeleteApn(MessageParcel &data)
430 {
431 EDMLOGD("NetworkManagerProxy::DeleteApn");
432 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::SET_APN_INFO);
433 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
434 }
435
UpdateApn(const AppExecFwk::ElementName & admin,const std::map<std::string,std::string> & apnInfoMap,const std::string & apnId,ApnPassword & apnPassword)436 int32_t NetworkManagerProxy::UpdateApn(const AppExecFwk::ElementName &admin,
437 const std::map<std::string, std::string> &apnInfoMap, const std::string &apnId, ApnPassword &apnPassword)
438 {
439 MessageParcel data;
440 data.WriteInterfaceToken(DESCRIPTOR);
441 data.WriteInt32(WITHOUT_USERID);
442 data.WriteParcelable(&admin);
443 data.WriteString(WITHOUT_PERMISSION_TAG);
444 data.WriteString(EdmConstants::SetApn::UPDATE_FLAG);
445 data.WriteString(apnId);
446 data.WriteInt32(apnInfoMap.size());
447 for (const auto& iter : apnInfoMap) {
448 data.WriteString(iter.first);
449 }
450 for (const auto& iter : apnInfoMap) {
451 data.WriteString(iter.second);
452 }
453 if (apnPassword.password == nullptr) {
454 data.WriteInt32(-1);
455 } else {
456 data.WriteInt32(static_cast<int32_t>(apnPassword.passwordSize));
457 data.WriteCString(apnPassword.password);
458 }
459 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::SET),
460 EdmInterfaceCode::SET_APN_INFO);
461 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
462 }
463
SetPreferApn(const AppExecFwk::ElementName & admin,const std::string & apnId)464 int32_t NetworkManagerProxy::SetPreferApn(const AppExecFwk::ElementName &admin, const std::string &apnId)
465 {
466 MessageParcel data;
467 data.WriteInterfaceToken(DESCRIPTOR);
468 data.WriteInt32(WITHOUT_USERID);
469 data.WriteParcelable(&admin);
470 data.WriteString(WITHOUT_PERMISSION_TAG);
471 data.WriteString(EdmConstants::SetApn::SET_PREFER_FLAG);
472 data.WriteString(apnId);
473
474 std::uint32_t funcCode = POLICY_FUNC_CODE(static_cast<std::uint32_t>(FuncOperateType::SET),
475 EdmInterfaceCode::SET_APN_INFO);
476 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
477 }
478
QueryApn(const AppExecFwk::ElementName & admin,const std::string & apnId,std::map<std::string,std::string> & apnInfoMap)479 int32_t NetworkManagerProxy::QueryApn(const AppExecFwk::ElementName &admin, const std::string &apnId,
480 std::map<std::string, std::string> &apnInfoMap)
481 {
482 MessageParcel data;
483 MessageParcel reply;
484 data.WriteInterfaceToken(DESCRIPTOR);
485 data.WriteInt32(WITHOUT_USERID);
486 data.WriteString(WITHOUT_PERMISSION_TAG);
487 data.WriteInt32(HAS_ADMIN);
488 data.WriteParcelable(&admin);
489 data.WriteString(EdmConstants::SetApn::QUERY_INFO_FLAG);
490 data.WriteString(apnId);
491 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::SET_APN_INFO, data, reply);
492 int32_t ret = reply.ReadInt32();
493 if (ret != ERR_OK) {
494 EDMLOGE("EnterpriseDeviceMgrProxy:QueryApn error: %{public}d", ret);
495 return ret;
496 }
497
498 int32_t size = reply.ReadInt32();
499 if (size > EdmConstants::POLICIES_MAX_SIZE) {
500 EDMLOGE("EnterpriseDeviceMgrProxy:QueryApn invalid size: %{public}d", size);
501 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
502 }
503 std::vector<std::string> keys;
504 std::vector<std::string> values;
505 for (int32_t i = 0; i < size; i++) {
506 std::string key = reply.ReadString();
507 keys.push_back(key);
508 }
509 for (int32_t i = 0; i < size; i++) {
510 std::string value = reply.ReadString();
511 values.push_back(value);
512 }
513 for (int32_t i = 0; i < size; i++) {
514 apnInfoMap[keys[i]] = values[i];
515 }
516
517 EDMLOGD("EnterpriseDeviceMgrProxy:QueryApn success");
518 return ERR_OK;
519 }
520
QueryApnIds(const AppExecFwk::ElementName & admin,const std::map<std::string,std::string> & apnInfoMap,std::vector<std::string> & apnIds)521 int32_t NetworkManagerProxy::QueryApnIds(const AppExecFwk::ElementName &admin,
522 const std::map<std::string, std::string> &apnInfoMap, std::vector<std::string> &apnIds)
523 {
524 MessageParcel data;
525 MessageParcel reply;
526 data.WriteInterfaceToken(DESCRIPTOR);
527 data.WriteInt32(WITHOUT_USERID);
528 data.WriteString(WITHOUT_PERMISSION_TAG);
529 data.WriteInt32(HAS_ADMIN);
530 data.WriteParcelable(&admin);
531 data.WriteString(EdmConstants::SetApn::QUERY_ID_FLAG);
532 data.WriteInt32(apnInfoMap.size());
533 for (const auto& iter : apnInfoMap) {
534 data.WriteString(iter.first);
535 }
536 for (const auto& iter : apnInfoMap) {
537 data.WriteString(iter.second);
538 }
539 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::SET_APN_INFO, data, reply);
540 int32_t ret = reply.ReadInt32();
541 if (ret != ERR_OK) {
542 EDMLOGE("EnterpriseDeviceMgrProxy:QueryApnIds error: %{public}d", ret);
543 return ret;
544 }
545
546 int32_t size = reply.ReadInt32();
547 if (size > EdmConstants::POLICIES_MAX_SIZE) {
548 EDMLOGE("EnterpriseDeviceMgrProxy:QueryApnIds invalid size: %{public}d", size);
549 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
550 }
551 for (int32_t i = 0; i < size; i++) {
552 std::string id = reply.ReadString();
553 apnIds.push_back(id);
554 }
555 EDMLOGD("EnterpriseDeviceMgrProxy:QueryApnIds success. %{public}d", size);
556 return ERR_OK;
557 }
558
559 #ifdef NETMANAGER_BASE_EDM_ENABLE
SetGlobalHttpProxy(MessageParcel & data)560 int32_t NetworkManagerProxy::SetGlobalHttpProxy(MessageParcel &data)
561 {
562 EDMLOGD("NetworkManagerProxy::SetGlobalHttpProxy");
563 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::GLOBAL_PROXY);
564 int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
565 EDMLOGI("NetworkManagerProxy::SetGlobalHttpProxy ret = %{public}d", ret);
566 return ret;
567 }
568
GetGlobalHttpProxy(const AppExecFwk::ElementName * admin,NetManagerStandard::HttpProxy & httpProxy,int32_t accountId)569 int32_t NetworkManagerProxy::GetGlobalHttpProxy(const AppExecFwk::ElementName *admin,
570 NetManagerStandard::HttpProxy &httpProxy, int32_t accountId)
571 {
572 EDMLOGD("NetworkManagerProxy::GetGlobalHttpProxy");
573 MessageParcel data;
574 MessageParcel reply;
575 data.WriteInterfaceToken(DESCRIPTOR);
576 data.WriteInt32(WITHOUT_USERID);
577 data.WriteString(WITHOUT_PERMISSION_TAG);
578 if (admin != nullptr) {
579 data.WriteInt32(HAS_ADMIN);
580 data.WriteParcelable(admin);
581 } else {
582 if (!EnterpriseDeviceMgrProxy::GetInstance()->IsEdmEnabled()) {
583 return ERR_OK;
584 }
585 data.WriteInt32(WITHOUT_ADMIN);
586 }
587 data.WriteInt32(accountId);
588 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::GLOBAL_PROXY, data, reply);
589 int32_t ret = ERR_INVALID_VALUE;
590 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
591 if (!blRes) {
592 EDMLOGE("GetGlobalHttpProxy:GetPolicy fail. %{public}d", ret);
593 return ret;
594 }
595 if (!NetManagerStandard::HttpProxy::Unmarshalling(reply, httpProxy)) {
596 EDMLOGE("NetworkManagerProxy::GetGlobalHttpProxy Unmarshalling proxy fail.");
597 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
598 }
599 return ERR_OK;
600 }
601 #endif
602 } // namespace EDM
603 } // namespace OHOS
604