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_ipc_interface_code.h"
19 #include "edm_log.h"
20 #include "func_code.h"
21
22 namespace OHOS {
23 namespace EDM {
24 std::shared_ptr<NetworkManagerProxy> NetworkManagerProxy::instance_ = nullptr;
25 std::mutex NetworkManagerProxy::mutexLock_;
26 const std::u16string DESCRIPTOR = u"ohos.edm.IEnterpriseDeviceMgr";
27 constexpr int32_t MAX_SIZE = 16;
28
NetworkManagerProxy()29 NetworkManagerProxy::NetworkManagerProxy() {}
30
~NetworkManagerProxy()31 NetworkManagerProxy::~NetworkManagerProxy() {}
32
GetNetworkManagerProxy()33 std::shared_ptr<NetworkManagerProxy> NetworkManagerProxy::GetNetworkManagerProxy()
34 {
35 if (instance_ == nullptr) {
36 std::lock_guard<std::mutex> lock(mutexLock_);
37 if (instance_ == nullptr) {
38 std::shared_ptr<NetworkManagerProxy> temp = std::make_shared<NetworkManagerProxy>();
39 instance_ = temp;
40 }
41 }
42 return instance_;
43 }
44
GetAllNetworkInterfaces(const AppExecFwk::ElementName & admin,std::vector<std::string> & networkInterface)45 int32_t NetworkManagerProxy::GetAllNetworkInterfaces(const AppExecFwk::ElementName &admin,
46 std::vector<std::string> &networkInterface)
47 {
48 EDMLOGD("NetworkManagerProxy::GetAllNetworkInterfaces");
49 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
50 if (proxy == nullptr) {
51 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
52 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
53 }
54 MessageParcel data;
55 MessageParcel reply;
56 data.WriteInterfaceToken(DESCRIPTOR);
57 data.WriteInt32(WITHOUT_USERID);
58 data.WriteInt32(HAS_ADMIN);
59 data.WriteParcelable(&admin);
60 proxy->GetPolicy(EdmInterfaceCode::GET_NETWORK_INTERFACES, data, reply);
61 int32_t ret = ERR_INVALID_VALUE;
62 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
63 if (!blRes) {
64 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
65 return ret;
66 }
67 int32_t size = reply.ReadInt32();
68 if (size > MAX_SIZE) {
69 EDMLOGE("networkInterface size=[%{public}d] is too large", size);
70 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
71 }
72 reply.ReadStringVector(&networkInterface);
73 return ERR_OK;
74 }
75
GetIpOrMacAddress(const AppExecFwk::ElementName & admin,const std::string & networkInterface,int policyCode,std::string & info)76 int32_t NetworkManagerProxy::GetIpOrMacAddress(const AppExecFwk::ElementName &admin,
77 const std::string &networkInterface, int policyCode, std::string &info)
78 {
79 EDMLOGD("NetworkManagerProxy::GetIpOrMacAddress");
80 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
81 if (proxy == nullptr) {
82 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
83 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
84 }
85 MessageParcel data;
86 MessageParcel reply;
87 data.WriteInterfaceToken(DESCRIPTOR);
88 data.WriteInt32(WITHOUT_USERID);
89 data.WriteInt32(HAS_ADMIN);
90 data.WriteParcelable(&admin);
91 data.WriteString(networkInterface);
92 proxy->GetPolicy(policyCode, data, reply);
93 int32_t ret = ERR_INVALID_VALUE;
94 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
95 if (!blRes) {
96 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
97 return ret;
98 }
99 reply.ReadString(info);
100 return ERR_OK;
101 }
102
SetNetworkInterfaceDisabled(const AppExecFwk::ElementName & admin,const std::string & networkInterface,bool isDisabled)103 int32_t NetworkManagerProxy::SetNetworkInterfaceDisabled(const AppExecFwk::ElementName &admin,
104 const std::string &networkInterface, bool isDisabled)
105 {
106 EDMLOGD("NetworkManagerProxy::SetNetworkInterfaceDisabled");
107 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
108 if (proxy == nullptr) {
109 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
110 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
111 }
112 MessageParcel data;
113 std::uint32_t funcCode =
114 POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::DISABLED_NETWORK_INTERFACE);
115 data.WriteInterfaceToken(DESCRIPTOR);
116 data.WriteInt32(WITHOUT_USERID);
117 data.WriteParcelable(&admin);
118 std::vector<std::string> key{networkInterface};
119 std::vector<std::string> value{isDisabled ? "true" : "false"};
120 data.WriteStringVector(key);
121 data.WriteStringVector(value);
122 return proxy->HandleDevicePolicy(funcCode, data);
123 }
124
IsNetworkInterfaceDisabled(const AppExecFwk::ElementName & admin,const std::string & networkInterface,bool & status)125 int32_t NetworkManagerProxy::IsNetworkInterfaceDisabled(const AppExecFwk::ElementName &admin,
126 const std::string &networkInterface, bool &status)
127 {
128 EDMLOGD("NetworkManagerProxy::IsNetworkInterfaceDisabled");
129 auto proxy = EnterpriseDeviceMgrProxy::GetInstance();
130 if (proxy == nullptr) {
131 EDMLOGE("can not get EnterpriseDeviceMgrProxy");
132 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
133 }
134 MessageParcel data;
135 MessageParcel reply;
136 data.WriteInterfaceToken(DESCRIPTOR);
137 data.WriteInt32(WITHOUT_USERID);
138 data.WriteInt32(HAS_ADMIN);
139 data.WriteParcelable(&admin);
140 data.WriteString(networkInterface);
141 proxy->GetPolicy(EdmInterfaceCode::DISABLED_NETWORK_INTERFACE, data, reply);
142 int32_t ret = ERR_INVALID_VALUE;
143 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
144 if (!blRes) {
145 EDMLOGW("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
146 return ret;
147 }
148 reply.ReadBool(status);
149 return ERR_OK;
150 }
151
AddIptablesFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::AddFilter & filter)152 int32_t NetworkManagerProxy::AddIptablesFilterRule(const AppExecFwk::ElementName &admin,
153 const IPTABLES::AddFilter &filter)
154 {
155 EDMLOGD("NetworkManagerProxy::AddIptablesFilterRule");
156 MessageParcel data;
157 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::IPTABLES_RULE);
158 data.WriteInterfaceToken(DESCRIPTOR);
159 data.WriteInt32(WITHOUT_USERID);
160 data.WriteParcelable(&admin);
161 IPTABLES::IptablesUtils::WriteAddFilterConfig(filter, data);
162 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
163 }
164
RemoveIptablesFilterRule(const AppExecFwk::ElementName & admin,const IPTABLES::RemoveFilter & filter)165 int32_t NetworkManagerProxy::RemoveIptablesFilterRule(const AppExecFwk::ElementName &admin,
166 const IPTABLES::RemoveFilter &filter)
167 {
168 EDMLOGD("NetworkManagerProxy::RemoveIptablesFilterRule");
169 MessageParcel data;
170 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::REMOVE, EdmInterfaceCode::IPTABLES_RULE);
171 data.WriteInterfaceToken(DESCRIPTOR);
172 data.WriteInt32(WITHOUT_USERID);
173 data.WriteParcelable(&admin);
174 IPTABLES::IptablesUtils::WriteRemoveFilterConfig(filter, data);
175 return EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
176 }
177
ListIptablesFilterRules(const AppExecFwk::ElementName & admin,std::string & result)178 int32_t NetworkManagerProxy::ListIptablesFilterRules(const AppExecFwk::ElementName &admin, std::string &result)
179 {
180 EDMLOGD("NetworkManagerProxy::ListIptablesFilterRules");
181 MessageParcel data;
182 MessageParcel reply;
183 data.WriteInterfaceToken(DESCRIPTOR);
184 data.WriteInt32(WITHOUT_USERID);
185 data.WriteInt32(HAS_ADMIN);
186 data.WriteParcelable(&admin);
187 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::IPTABLES_RULE, data, reply);
188 int32_t ret = ERR_INVALID_VALUE;
189 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
190 if (!blRes) {
191 EDMLOGE("EnterpriseDeviceMgrProxy:GetPolicy fail. %{public}d", ret);
192 return ret;
193 }
194 reply.ReadString(result);
195 return ERR_OK;
196 }
197
SetGlobalHttpProxy(const AppExecFwk::ElementName & admin,const NetManagerStandard::HttpProxy & httpProxy)198 int32_t NetworkManagerProxy::SetGlobalHttpProxy(const AppExecFwk::ElementName &admin,
199 const NetManagerStandard::HttpProxy &httpProxy)
200 {
201 EDMLOGD("NetworkManagerProxy::SetGlobalHttpProxy");
202 MessageParcel data;
203 std::uint32_t funcCode = POLICY_FUNC_CODE((std::uint32_t)FuncOperateType::SET, EdmInterfaceCode::GLOBAL_PROXY);
204 data.WriteInterfaceToken(DESCRIPTOR);
205 data.WriteInt32(WITHOUT_USERID);
206 data.WriteParcelable(&admin);
207 if (!httpProxy.Marshalling(data)) {
208 EDMLOGE("NetworkManagerProxy::SetGlobalHttpProxy Marshalling proxy fail.");
209 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
210 }
211 int32_t ret = EnterpriseDeviceMgrProxy::GetInstance()->HandleDevicePolicy(funcCode, data);
212 EDMLOGI("NetworkManagerProxy::SetGlobalHttpProxy ret = %{public}d", ret);
213 return ret;
214 }
215
GetGlobalHttpProxy(const AppExecFwk::ElementName * admin,NetManagerStandard::HttpProxy & httpProxy)216 int32_t NetworkManagerProxy::GetGlobalHttpProxy(const AppExecFwk::ElementName *admin,
217 NetManagerStandard::HttpProxy &httpProxy)
218 {
219 EDMLOGD("NetworkManagerProxy::GetGlobalHttpProxy");
220 MessageParcel data;
221 MessageParcel reply;
222 data.WriteInterfaceToken(DESCRIPTOR);
223 data.WriteInt32(WITHOUT_USERID);
224 if (admin != nullptr) {
225 data.WriteInt32(HAS_ADMIN);
226 data.WriteParcelable(admin);
227 } else {
228 if (!EnterpriseDeviceMgrProxy::GetInstance()->IsEdmEnabled()) {
229 return ERR_OK;
230 }
231 data.WriteInt32(WITHOUT_ADMIN);
232 }
233 EnterpriseDeviceMgrProxy::GetInstance()->GetPolicy(EdmInterfaceCode::GLOBAL_PROXY, data, reply);
234 int32_t ret = ERR_INVALID_VALUE;
235 bool blRes = reply.ReadInt32(ret) && (ret == ERR_OK);
236 if (!blRes) {
237 EDMLOGE("GetGlobalHttpProxy:GetPolicy fail. %{public}d", ret);
238 return ret;
239 }
240 if (!NetManagerStandard::HttpProxy::Unmarshalling(reply, httpProxy)) {
241 EDMLOGE("NetworkManagerProxy::GetGlobalHttpProxy Unmarshalling proxy fail.");
242 return EdmReturnErrCode::SYSTEM_ABNORMALLY;
243 }
244 return ERR_OK;
245 }
246 } // namespace EDM
247 } // namespace OHOS
248