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::mutex NetworkManagerProxy::mutexLock_;
27 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
28 #ifdef NETMANAGER_BASE_EDM_ENABLE
29 constexpr int32_t MAX_SIZE = 16;
30 #endif
31 
NetworkManagerProxy()32 NetworkManagerProxy::NetworkManagerProxy() {}
33 
~NetworkManagerProxy()34 NetworkManagerProxy::~NetworkManagerProxy() {}
35 
GetNetworkManagerProxy()36 std::shared_ptr<NetworkManagerProxy> NetworkManagerProxy::GetNetworkManagerProxy()
37 {
38     if (instance_ == nullptr) {
39         std::lock_guard<std::mutex> lock(mutexLock_);
40         if (instance_ == nullptr) {
41             std::shared_ptr<NetworkManagerProxy> temp = std::make_shared<NetworkManagerProxy>();
42             instance_ = temp;
43         }
44     }
45     return instance_;
46 }
47 
GetAllNetworkInterfaces(const AppExecFwk::ElementName & admin,std::vector<std::string> & networkInterface,bool isSync)48 int32_t NetworkManagerProxy::GetAllNetworkInterfaces(const AppExecFwk::ElementName &admin,
49     std::vector<std::string> &networkInterface, bool isSync)
50 {
51 #ifdef NETMANAGER_BASE_EDM_ENABLE
52     EDMLOGD("NetworkManagerProxy::GetAllNetworkInterfaces");
53     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
54     MessageParcel data;
55     MessageParcel reply;
56     data.WriteInterfaceToken(DESCRIPTOR);
57     data.WriteInt32(WITHOUT_USERID);
58     data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
59     data.WriteInt32(HAS_ADMIN);
60     data.WriteParcelable(&admin);
61     proxy->GetPolicy(EdmInterfaceCode::GET_NETWORK_INTERFACES, data, reply);
62     int32_t ret = ERR_INVALID_VALUE;
63     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
64     if (!blRes) {
65         EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
66         return ret;
67     }
68     int32_t size = reply.ReadInt32();
69     if (size > MAX_SIZE) {
70         EDMLOGE("networkInterface size=[%{public}d] is too large", size);
71         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
72     }
73     reply.ReadStringVector(&networkInterface);
74     return ERR_OK;
75 #else
76     EDMLOGW("NetworkManagerProxy::GetAllNetworkInterfaces Unsupported Capabilities.");
77     return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
78 #endif
79 }
80 
GetIpOrMacAddress(const AppExecFwk::ElementName & admin,const std::string & networkInterface,int policyCode,std::string & info,bool isSync)81 int32_t NetworkManagerProxy::GetIpOrMacAddress(const AppExecFwk::ElementName &admin,
82     const std::string &networkInterface, int policyCode, std::string &info, bool isSync)
83 {
84 #ifdef NETMANAGER_BASE_EDM_ENABLE
85     EDMLOGD("NetworkManagerProxy::GetIpOrMacAddress");
86     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
87     MessageParcel data;
88     MessageParcel reply;
89     data.WriteInterfaceToken(DESCRIPTOR);
90     data.WriteInt32(WITHOUT_USERID);
91     data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
92     data.WriteInt32(HAS_ADMIN);
93     data.WriteParcelable(&admin);
94     data.WriteString(networkInterface);
95     proxy->GetPolicy(policyCode, data, reply);
96     int32_t ret = ERR_INVALID_VALUE;
97     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
98     if (!blRes) {
99         EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
100         return ret;
101     }
102     reply.ReadString(info);
103     return ERR_OK;
104 #else
105     EDMLOGW("NetworkManagerProxy::GetIpOrMacAddress Unsupported Capabilities.");
106     return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
107 #endif
108 }
109 
SetNetworkInterfaceDisabled(const AppExecFwk::ElementName & admin,const std::string & networkInterface,bool isDisabled,bool isSync)110 int32_t NetworkManagerProxy::SetNetworkInterfaceDisabled(const AppExecFwk::ElementName &admin,
111     const std::string &networkInterface, bool isDisabled, bool isSync)
112 {
113 #ifdef NETMANAGER_BASE_EDM_ENABLE
114     EDMLOGD("NetworkManagerProxy::SetNetworkInterfaceDisabled");
115     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
116     MessageParcel data;
117     std::uint32_t funcCode =
118         POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_NETWORK_INTERFACE);
119     data.WriteInterfaceToken(DESCRIPTOR);
120     data.WriteInt32(WITHOUT_USERID);
121     data.WriteParcelable(&admin);
122     data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
123     std::vector<std::string> key{networkInterface};
124     std::vector<std::string> value{isDisabled ? "true" : "false"};
125     data.WriteStringVector(key);
126     data.WriteStringVector(value);
127     return proxy->HandleDevicePolicy(funcCode, data);
128 #else
129     EDMLOGW("NetworkManagerProxy::SetNetworkInterfaceDisabled Unsupported Capabilities.");
130     return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
131 #endif
132 }
133 
IsNetworkInterfaceDisabled(const AppExecFwk::ElementName & admin,const std::string & networkInterface,bool & status,bool isSync)134 int32_t NetworkManagerProxy::IsNetworkInterfaceDisabled(const AppExecFwk::ElementName &admin,
135     const std::string &networkInterface, bool &status, bool isSync)
136 {
137 #ifdef NETMANAGER_BASE_EDM_ENABLE
138     EDMLOGD("NetworkManagerProxy::IsNetworkInterfaceDisabled");
139     auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
140     MessageParcel data;
141     MessageParcel reply;
142     data.WriteInterfaceToken(DESCRIPTOR);
143     data.WriteInt32(WITHOUT_USERID);
144     data.WriteString(isSync ? EdmConstants::PERMISSION_TAG_VERSION_12 : EdmConstants::PERMISSION_TAG_VERSION_11);
145     data.WriteInt32(HAS_ADMIN);
146     data.WriteParcelable(&admin);
147     data.WriteString(networkInterface);
148     proxy->GetPolicy(EdmInterfaceCode::DISABLED_NETWORK_INTERFACE, data, reply);
149     int32_t ret = ERR_INVALID_VALUE;
150     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
151     if (!blRes) {
152         EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
153         return ret;
154     }
155     reply.ReadBool(status);
156     return ERR_OK;
157 #else
158     EDMLOGW("NetworkManagerProxy::IsNetworkInterfaceDisabled Unsupported Capabilities.");
159     return EdmReturnErrCode::INTERFACE_UNSUPPORTED;
160 #endif
161 }
162 
AddIptablesFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::AddFilter & filter)163 int32_t NetworkManagerProxy::AddIptablesFilterRule(const AppExecFwk::ElementName &admin,
164     const IPTABLES::AddFilter &filter)
165 {
166     EDMLOGD("NetworkManagerProxy::AddIptablesFilterRule");
167     MessageParcel data;
168     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::IPTABLES_RULE);
169     data.WriteInterfaceToken(DESCRIPTOR);
170     data.WriteInt32(WITHOUT_USERID);
171     data.WriteParcelable(&admin);
172     data.WriteString(WITHOUT_PERMISSION_TAG);
173     IPTABLES::IptablesUtils::WriteAddFilterConfig(filter, data);
174     return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
175 }
176 
RemoveIptablesFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::RemoveFilter & filter)177 int32_t NetworkManagerProxy::RemoveIptablesFilterRule(const AppExecFwk::ElementName &admin,
178     const IPTABLES::RemoveFilter &filter)
179 {
180     EDMLOGD("NetworkManagerProxy::RemoveIptablesFilterRule");
181     MessageParcel data;
182     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::IPTABLES_RULE);
183     data.WriteInterfaceToken(DESCRIPTOR);
184     data.WriteInt32(WITHOUT_USERID);
185     data.WriteParcelable(&admin);
186     data.WriteString(WITHOUT_PERMISSION_TAG);
187     IPTABLES::IptablesUtils::WriteRemoveFilterConfig(filter, data);
188     return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
189 }
190 
ListIptablesFilterRules(const AppExecFwk::ElementName & admin,std::string & result)191 int32_t NetworkManagerProxy::ListIptablesFilterRules(const AppExecFwk::ElementName &admin, std::string &result)
192 {
193     EDMLOGD("NetworkManagerProxy::ListIptablesFilterRules");
194     MessageParcel data;
195     MessageParcel reply;
196     data.WriteInterfaceToken(DESCRIPTOR);
197     data.WriteInt32(WITHOUT_USERID);
198     data.WriteString(WITHOUT_PERMISSION_TAG);
199     data.WriteInt32(HAS_ADMIN);
200     data.WriteParcelable(&admin);
201     EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::IPTABLES_RULE, data, reply);
202     int32_t ret = ERR_INVALID_VALUE;
203     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
204     if (!blRes) {
205         EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
206         return ret;
207     }
208     reply.ReadString(result);
209     return ERR_OK;
210 }
211 
AddFirewallRule(const AppExecFwk::ElementName & admin,const IPTABLES::FirewallRule & rule)212 int32_t NetworkManagerProxy::AddFirewallRule(const AppExecFwk::ElementName &admin,
213     const IPTABLES::FirewallRule &rule)
214 {
215     MessageParcel data;
216     data.WriteInterfaceToken(DESCRIPTOR);
217     data.WriteInt32(WITHOUT_USERID);
218     data.WriteParcelable(&admin);
219     data.WriteString(WITHOUT_PERMISSION_TAG);
220     IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
221     if (!firewallRuleParcel.Marshalling(data)) {
222         EDMLOGE("NetworkManagerProxy::AddFirewallRule Marshalling rule fail.");
223         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
224     }
225     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::FIREWALL_RULE);
226     return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
227 }
228 
RemoveFirewallRule(const AppExecFwk::ElementName & admin,const IPTABLES::FirewallRule & rule)229 int32_t NetworkManagerProxy::RemoveFirewallRule(const AppExecFwk::ElementName &admin,
230     const IPTABLES::FirewallRule &rule)
231 {
232     MessageParcel data;
233     data.WriteInterfaceToken(DESCRIPTOR);
234     data.WriteInt32(WITHOUT_USERID);
235     data.WriteParcelable(&admin);
236     data.WriteString(WITHOUT_PERMISSION_TAG);
237     IPTABLES::FirewallRuleParcel firewallRuleParcel{rule};
238     if (!firewallRuleParcel.Marshalling(data)) {
239         EDMLOGE("NetworkManagerProxy::RemoveFirewallRule Marshalling rule fail.");
240         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
241     }
242     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::FIREWALL_RULE);
243     return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
244 }
245 
GetFirewallRules(const AppExecFwk::ElementName & admin,std::vector<IPTABLES::FirewallRule> & result)246 int32_t NetworkManagerProxy::GetFirewallRules(const AppExecFwk::ElementName &admin,
247     std::vector<IPTABLES::FirewallRule> &result)
248 {
249     MessageParcel data;
250     MessageParcel reply;
251     data.WriteInterfaceToken(DESCRIPTOR);
252     data.WriteInt32(WITHOUT_USERID);
253     data.WriteString(WITHOUT_PERMISSION_TAG);
254     data.WriteInt32(HAS_ADMIN);
255     data.WriteParcelable(&admin);
256     EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::FIREWALL_RULE, data, reply);
257     int32_t ret = ERR_INVALID_VALUE;
258     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
259     if (!blRes) {
260         EDMLOGE("EnterpriseDeviceMgrProxy:GetFirewallRules fail. %{public}d", ret);
261         return ret;
262     }
263     int32_t size = reply.ReadInt32();
264     for (int32_t i = 0; i < size; i++) {
265         IPTABLES::FirewallRuleParcel firewallRuleParcel;
266         if (!IPTABLES::FirewallRuleParcel::Unmarshalling(reply, firewallRuleParcel)) {
267             EDMLOGE("NetworkManagerProxy::GetFirewallRules Unmarshalling rule fail.");
268             return EdmReturnErrCode::SYSTEM_ABNORMALLY;
269         }
270         result.push_back(firewallRuleParcel.GetRule());
271     }
272     EDMLOGD("EnterpriseDeviceMgrProxy:GetFirewallRules success. %{public}d", size);
273     return ERR_OK;
274 }
275 
AddDomainFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::DomainFilterRule & rule)276 int32_t NetworkManagerProxy::AddDomainFilterRule(const AppExecFwk::ElementName &admin,
277     const IPTABLES::DomainFilterRule &rule)
278 {
279     MessageParcel data;
280     data.WriteInterfaceToken(DESCRIPTOR);
281     data.WriteInt32(WITHOUT_USERID);
282     data.WriteParcelable(&admin);
283     data.WriteString(WITHOUT_PERMISSION_TAG);
284     IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
285     if (!domainFilterRuleParcel.Marshalling(data)) {
286         EDMLOGE("NetworkManagerProxy::AddDomainFilterRule Marshalling rule fail.");
287         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
288     }
289     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET,
290         EdmInterfaceCode::DOMAIN_FILTER_RULE);
291     return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
292 }
293 
RemoveDomainFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::DomainFilterRule & rule)294 int32_t NetworkManagerProxy::RemoveDomainFilterRule(const AppExecFwk::ElementName &admin,
295     const IPTABLES::DomainFilterRule &rule)
296 {
297     MessageParcel data;
298     data.WriteInterfaceToken(DESCRIPTOR);
299     data.WriteInt32(WITHOUT_USERID);
300     data.WriteParcelable(&admin);
301     data.WriteString(WITHOUT_PERMISSION_TAG);
302     IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel{rule};
303     if (!domainFilterRuleParcel.Marshalling(data)) {
304         EDMLOGE("NetworkManagerProxy::RemoveDomainFilterRule Marshalling rule fail.");
305         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
306     }
307     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE,
308         EdmInterfaceCode::DOMAIN_FILTER_RULE);
309     return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
310 }
311 
GetDomainFilterRules(const AppExecFwk::ElementName & admin,std::vector<IPTABLES::DomainFilterRule> & result)312 int32_t NetworkManagerProxy::GetDomainFilterRules(const AppExecFwk::ElementName &admin,
313     std::vector<IPTABLES::DomainFilterRule> &result)
314 {
315     MessageParcel data;
316     MessageParcel reply;
317     data.WriteInterfaceToken(DESCRIPTOR);
318     data.WriteInt32(WITHOUT_USERID);
319     data.WriteString(WITHOUT_PERMISSION_TAG);
320     data.WriteInt32(HAS_ADMIN);
321     data.WriteParcelable(&admin);
322     EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::DOMAIN_FILTER_RULE, data, reply);
323     int32_t ret = ERR_INVALID_VALUE;
324     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
325     if (!blRes) {
326         EDMLOGE("EnterpriseDeviceMgrProxy:GetFirewallRules fail. %{public}d", ret);
327         return ret;
328     }
329     int32_t size = reply.ReadInt32();
330     for (int32_t i = 0; i < size; i++) {
331         IPTABLES::DomainFilterRuleParcel domainFilterRuleParcel;
332         if (!IPTABLES::DomainFilterRuleParcel::Unmarshalling(reply, domainFilterRuleParcel)) {
333             EDMLOGE("NetworkManagerProxy::GetDomainFilterRules Unmarshalling rule fail.");
334             return EdmReturnErrCode::SYSTEM_ABNORMALLY;
335         }
336         result.push_back(domainFilterRuleParcel.GetRule());
337     }
338     EDMLOGD("EnterpriseDeviceMgrProxy:GetDomainFilterRules success. %{public}d", size);
339     return ERR_OK;
340 }
341 
342 #ifdef NETMANAGER_BASE_EDM_ENABLE
SetGlobalHttpProxy(const AppExecFwk::ElementName & admin,const NetManagerStandard::HttpProxy & httpProxy)343 int32_t NetworkManagerProxy::SetGlobalHttpProxy(const AppExecFwk::ElementName &admin,
344     const NetManagerStandard::HttpProxy &httpProxy)
345 {
346     EDMLOGD("NetworkManagerProxy::SetGlobalHttpProxy");
347     MessageParcel data;
348     std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::GLOBAL_PROXY);
349     data.WriteInterfaceToken(DESCRIPTOR);
350     data.WriteInt32(WITHOUT_USERID);
351     data.WriteParcelable(&admin);
352     data.WriteString(WITHOUT_PERMISSION_TAG);
353     if (!httpProxy.Marshalling(data)) {
354         EDMLOGE("NetworkManagerProxy::SetGlobalHttpProxy Marshalling proxy fail.");
355         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
356     }
357     int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
358     EDMLOGI("NetworkManagerProxy::SetGlobalHttpProxy ret = %{public}d", ret);
359     return ret;
360 }
361 
GetGlobalHttpProxy(const AppExecFwk::ElementName * admin,NetManagerStandard::HttpProxy & httpProxy)362 int32_t NetworkManagerProxy::GetGlobalHttpProxy(const AppExecFwk::ElementName *admin,
363     NetManagerStandard::HttpProxy &httpProxy)
364 {
365     EDMLOGD("NetworkManagerProxy::GetGlobalHttpProxy");
366     MessageParcel data;
367     MessageParcel reply;
368     data.WriteInterfaceToken(DESCRIPTOR);
369     data.WriteInt32(WITHOUT_USERID);
370     data.WriteString(WITHOUT_PERMISSION_TAG);
371     if (admin != nullptr) {
372         data.WriteInt32(HAS_ADMIN);
373         data.WriteParcelable(admin);
374     } else {
375         if (!EnterpriseDeviceMgrProxy::GetInstance()->IsEdmEnabled()) {
376             return ERR_OK;
377         }
378         data.WriteInt32(WITHOUT_ADMIN);
379     }
380     EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::GLOBAL_PROXY, data, reply);
381     int32_t ret = ERR_INVALID_VALUE;
382     bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
383     if (!blRes) {
384         EDMLOGE("GetGlobalHttpProxy:GetPolicy fail. %{public}d", ret);
385         return ret;
386     }
387     if (!NetManagerStandard::HttpProxy::Unmarshalling(reply, httpProxy)) {
388         EDMLOGE("NetworkManagerProxy::GetGlobalHttpProxy Unmarshalling proxy fail.");
389         return EdmReturnErrCode::SYSTEM_ABNORMALLY;
390     }
391     return ERR_OK;
392 }
393 #endif
394 } // namespace EDM
395 } // namespace OHOS
396