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 <memory>
17 
18 #include "networkvpn_service_stub.h"
19 #include "net_manager_constants.h"
20 #include "netmanager_base_permission.h"
21 #include "netmgr_ext_log_wrapper.h"
22 
23 namespace OHOS {
24 namespace NetManagerStandard {
25 
NetworkVpnServiceStub()26 NetworkVpnServiceStub::NetworkVpnServiceStub()
27 {
28     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_PREPARE] = {
29         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyPrepare};
30     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_START_VPN] = {
31         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplySetUpVpn};
32     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_PROTECT] = {
33         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyProtect};
34     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_STOP_VPN] = {
35         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyDestroyVpn};
36 #ifdef SUPPORT_SYSVPN
37     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_SETUP_SYS_VPN] = {
38         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplySetUpSysVpn};
39     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_ADD_SYS_VPN_CONFIG] = {
40         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyAddSysVpnConfig};
41     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_DELETE_SYS_VPN_CONFIG] = {
42         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyDeleteSysVpnConfig};
43     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_GET_SYS_VPN_CONFIG_LIST] = {
44         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyGetSysVpnConfigList};
45     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_GET_SYS_VPN_CONFIG] = {
46         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyGetSysVpnConfig};
47     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_GET_CONNECTED_SYS_VPN_CONFIG] = {
48         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyGetConnectedSysVpnConfig};
49     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_NOTIFY_CONNECT_STAGE] = {
50         "", &NetworkVpnServiceStub::ReplyNotifyConnectStage};
51     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_GET_SYS_VPN_CERT_URI] = {
52         "", &NetworkVpnServiceStub::ReplyGetSysVpnCertUri};
53 #endif // SUPPORT_SYSVPN
54     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_REGISTER_EVENT_CALLBACK] = {
55         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyRegisterVpnEvent};
56     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_UNREGISTER_EVENT_CALLBACK] = {
57         Permission::MANAGE_VPN, &NetworkVpnServiceStub::ReplyUnregisterVpnEvent};
58     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_CREATE_VPN_CONNECTION] = {
59         "", &NetworkVpnServiceStub::ReplyCreateVpnConnection};
60     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_FACTORYRESET_VPN] = {
61         "", &NetworkVpnServiceStub::ReplyFactoryResetVpn};
62     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_CREATE_VPN_CONNECTION_EXT] = {
63         "", &NetworkVpnServiceStub::ReplyCreateVpnConnection};
64     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_START_VPN_EXT] = {
65         "", &NetworkVpnServiceStub::ReplySetUpVpn};
66     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_PROTECT_EXT] = {
67         "", &NetworkVpnServiceStub::ReplyProtect};
68     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_STOP_VPN_EXT] = {
69         "", &NetworkVpnServiceStub::ReplyDestroyVpn};
70     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_REGISTER_BUNDLENAME] = {
71         "", &NetworkVpnServiceStub::ReplyRegisterBundleName};
72     permissionAndFuncMap_[INetworkVpnService::MessageCode::CMD_GET_SELF_APP_NAME] = {
73         "", &NetworkVpnServiceStub::ReplyGetSelfAppName};
74 }
75 
CheckVpnPermission(std::string &strPermission)76 int32_t NetworkVpnServiceStub::CheckVpnPermission(std::string &strPermission)
77 {
78     if (!NetManagerPermission::IsSystemCaller()) {
79         NETMGR_EXT_LOG_E("is not system call");
80         return NETMANAGER_ERR_NOT_SYSTEM_CALL;
81     }
82     if (!strPermission.empty() && !NetManagerPermission::CheckPermission(strPermission)) {
83         NETMGR_EXT_LOG_E("Permission denied permission: %{public}s", strPermission.c_str());
84         return NETMANAGER_ERR_PERMISSION_DENIED;
85     }
86     return NETMANAGER_SUCCESS;
87 }
88 
OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)89 int32_t NetworkVpnServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
90                                                MessageOption &option)
91 {
92     if (NetworkVpnServiceStub::GetDescriptor() != data.ReadInterfaceToken()) {
93         NETMGR_EXT_LOG_E("descriptor checked failed");
94         return NETMANAGER_EXT_ERR_DESCRIPTOR_MISMATCH;
95     }
96     auto itr = permissionAndFuncMap_.find(static_cast<INetworkVpnService::MessageCode>(code));
97     if (itr != permissionAndFuncMap_.end()) {
98         if (itr->first >= INetworkVpnService::MessageCode::CMD_START_VPN_EXT &&
99                 itr->first <= INetworkVpnService::MessageCode::CMD_GET_SELF_APP_NAME) {
100             NETMGR_EXT_LOG_I("enter OnRemoteRequest code %{public}d:", code);
101             auto serviceFunc = itr->second.serviceFunc;
102             if (serviceFunc != nullptr) {
103                 return (this->*serviceFunc)(data, reply);
104             }
105         } else {
106             NETMGR_EXT_LOG_I("enter OnRemoteRequest code %{public}d:", code);
107             int32_t checkResult = CheckVpnPermission(itr->second.strPermission);
108             if (checkResult != NETMANAGER_SUCCESS) {
109                 return checkResult;
110             }
111             auto serviceFunc = itr->second.serviceFunc;
112             if (serviceFunc != nullptr) {
113                 return (this->*serviceFunc)(data, reply);
114             }
115         }
116     }
117 
118     NETMGR_EXT_LOG_I("stub default case, need check");
119     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
120 }
121 
ReplyPrepare(MessageParcel &data, MessageParcel &reply)122 int32_t NetworkVpnServiceStub::ReplyPrepare(MessageParcel &data, MessageParcel &reply)
123 {
124     bool isExist = false;
125     bool isRun = false;
126     std::string pkg;
127     int32_t ret = Prepare(isExist, isRun, pkg);
128     bool allOK = reply.WriteInt32(ret) && reply.WriteBool(isExist) && reply.WriteBool(isRun) && reply.WriteString(pkg);
129     return allOK ? NETMANAGER_EXT_SUCCESS : NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
130 }
131 
ReplySetUpVpn(MessageParcel &data, MessageParcel &reply)132 int32_t NetworkVpnServiceStub::ReplySetUpVpn(MessageParcel &data, MessageParcel &reply)
133 {
134     sptr<VpnConfig> config = VpnConfig::Unmarshalling(data);
135     if (config == nullptr) {
136         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
137     }
138 
139     int32_t result = SetUpVpn(config);
140     if (!reply.WriteInt32(result)) {
141         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
142     }
143     return NETMANAGER_EXT_SUCCESS;
144 }
145 
ReplyProtect(MessageParcel &data, MessageParcel &reply)146 int32_t NetworkVpnServiceStub::ReplyProtect(MessageParcel &data, MessageParcel &reply)
147 {
148     int32_t result = Protect();
149     if (!reply.WriteInt32(result)) {
150         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
151     }
152     return NETMANAGER_EXT_SUCCESS;
153 }
154 
ReplyDestroyVpn(MessageParcel &data, MessageParcel &reply)155 int32_t NetworkVpnServiceStub::ReplyDestroyVpn(MessageParcel &data, MessageParcel &reply)
156 {
157     int32_t result = DestroyVpn();
158     if (!reply.WriteInt32(result)) {
159         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
160     }
161     return NETMANAGER_EXT_SUCCESS;
162 }
163 
164 #ifdef SUPPORT_SYSVPN
ReplySetUpSysVpn(MessageParcel &data, MessageParcel &reply)165 int32_t NetworkVpnServiceStub::ReplySetUpSysVpn(MessageParcel &data, MessageParcel &reply)
166 {
167     sptr<SysVpnConfig> config = new (std::nothrow) SysVpnConfig();
168     if (config == nullptr) {
169         NETMGR_EXT_LOG_E("ReplySetUpSysVpn failed, config is null");
170         return NETMANAGER_EXT_ERR_INTERNAL;
171     }
172     if (!(data.ReadString(config->vpnId_) && data.ReadInt32(config->vpnType_))) {
173         NETMGR_EXT_LOG_E("ReplySetUpSysVpn read data failed");
174         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
175     }
176     NETMGR_EXT_LOG_I("ReplySetUpSysVpn id=%{public}s", config->vpnId_.c_str());
177     int32_t result = SetUpVpn(config);
178     if (!reply.WriteInt32(result)) {
179         NETMGR_EXT_LOG_E("ReplySetUpSysVpn write reply failed");
180         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
181     }
182     return NETMANAGER_EXT_SUCCESS;
183 }
184 
ReplyAddSysVpnConfig(MessageParcel &data, MessageParcel &reply)185 int32_t NetworkVpnServiceStub::ReplyAddSysVpnConfig(MessageParcel &data, MessageParcel &reply)
186 {
187     NETMGR_EXT_LOG_I("NetworkVpnServiceStub ReplyAddSysVpnConfig");
188     sptr<SysVpnConfig> config = SysVpnConfig::Unmarshalling(data);
189     if (config == nullptr) {
190         NETMGR_EXT_LOG_E("ReplyAddSysVpnConfig read data failed");
191         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
192     }
193     int32_t result = AddSysVpnConfig(config);
194     if (!reply.WriteInt32(result)) {
195         NETMGR_EXT_LOG_E("ReplyAddSysVpnConfig write reply failed");
196         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
197     }
198     return NETMANAGER_EXT_SUCCESS;
199 }
200 
ReplyDeleteSysVpnConfig(MessageParcel &data, MessageParcel &reply)201 int32_t NetworkVpnServiceStub::ReplyDeleteSysVpnConfig(MessageParcel &data, MessageParcel &reply)
202 {
203     NETMGR_EXT_LOG_I("NetworkVpnServiceStub ReplyDeleteSysVpnConfig");
204     std::string vpnId;
205     if (!data.ReadString(vpnId)) {
206         NETMGR_EXT_LOG_E("ReplyDeleteSysVpnConfig read data failed");
207         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
208     }
209     int32_t result = DeleteSysVpnConfig(vpnId);
210     if (!reply.WriteInt32(result)) {
211         NETMGR_EXT_LOG_E("ReplyDeleteSysVpnConfig write reply failed");
212         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
213     }
214     return NETMANAGER_EXT_SUCCESS;
215 }
216 
ReplyGetSysVpnConfigList(MessageParcel &data, MessageParcel &reply)217 int32_t NetworkVpnServiceStub::ReplyGetSysVpnConfigList(MessageParcel &data, MessageParcel &reply)
218 {
219     NETMGR_EXT_LOG_I("NetworkVpnServiceStub ReplyGetSysVpnConfigList");
220     std::vector<SysVpnConfig> vpnList;
221     int32_t result = GetSysVpnConfigList(vpnList);
222     if (result != NETMANAGER_EXT_SUCCESS) {
223         NETMGR_EXT_LOG_E("ReplyGetSysVpnConfigList failed, result=%{public}d", result);
224         return result;
225     }
226     int32_t vpnListSize = static_cast<int32_t>(vpnList.size());
227     if (!reply.WriteInt32(vpnListSize)) {
228         NETMGR_EXT_LOG_E("ReplyGetSysVpnConfigList write reply failed");
229         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
230     }
231     for (auto &config : vpnList) {
232         if (!(reply.WriteString(config.vpnId_) && reply.WriteString(config.vpnName_) &&
233             reply.WriteInt32(config.vpnType_))) {
234             NETMGR_EXT_LOG_E("ReplyGetSysVpnConfigList write reply failed");
235             return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
236         }
237     }
238     return NETMANAGER_EXT_SUCCESS;
239 }
240 
ReplyGetSysVpnConfig(MessageParcel &data, MessageParcel &reply)241 int32_t NetworkVpnServiceStub::ReplyGetSysVpnConfig(MessageParcel &data, MessageParcel &reply)
242 {
243     NETMGR_EXT_LOG_I("NetworkVpnServiceStub ReplyGetSysVpnConfig");
244     std::string vpnId;
245     if (!data.ReadString(vpnId)) {
246         NETMGR_EXT_LOG_E("ReplyGetSysVpnConfig read data failed");
247         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
248     }
249     sptr<SysVpnConfig> config = nullptr;
250     int32_t result = GetSysVpnConfig(config, vpnId);
251     if (result != NETMANAGER_EXT_SUCCESS) {
252         NETMGR_EXT_LOG_E("ReplyGetSysVpnConfig failed, result=%{public}d", result);
253         return result;
254     }
255     if (config != nullptr && !config->Marshalling(reply)) {
256         NETMGR_EXT_LOG_E("ReplyGetSysVpnConfig write reply failed");
257         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
258     }
259     return NETMANAGER_EXT_SUCCESS;
260 }
261 
ReplyGetConnectedSysVpnConfig(MessageParcel &data, MessageParcel &reply)262 int32_t NetworkVpnServiceStub::ReplyGetConnectedSysVpnConfig(MessageParcel &data, MessageParcel &reply)
263 {
264     NETMGR_EXT_LOG_I("NetworkVpnServiceStub ReplyGetConnectedSysVpnConfig");
265     sptr<SysVpnConfig> config = nullptr;
266     int32_t result = GetConnectedSysVpnConfig(config);
267     if (result != NETMANAGER_EXT_SUCCESS) {
268         NETMGR_EXT_LOG_E("ReplyGetConnectedSysVpnConfig failed, result=%{public}d", result);
269         return result;
270     }
271     if (config != nullptr && !config->Marshalling(reply)) {
272         NETMGR_EXT_LOG_E("ReplyGetConnectedSysVpnConfig write reply failed");
273         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
274     }
275     return NETMANAGER_EXT_SUCCESS;
276 }
277 
ReplyNotifyConnectStage(MessageParcel &data, MessageParcel &reply)278 int32_t NetworkVpnServiceStub::ReplyNotifyConnectStage(MessageParcel &data, MessageParcel &reply)
279 {
280     NETMGR_EXT_LOG_I("NetworkVpnServiceStub ReplyNotifyConnectStage");
281     std::string stage;
282     if (!data.ReadString(stage)) {
283         NETMGR_EXT_LOG_E("ReplyNotifyConnectStage read data failed");
284         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
285     }
286     int32_t result;
287     if (!data.ReadInt32(result)) {
288         NETMGR_EXT_LOG_E("ReplyNotifyConnectStage read data failed");
289         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
290     }
291     int32_t ret = NotifyConnectStage(stage, result);
292     if (!reply.WriteInt32(ret)) {
293         NETMGR_EXT_LOG_E("ReplyNotifyConnectStage write reply failed");
294         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
295     }
296     return NETMANAGER_EXT_SUCCESS;
297 }
298 
ReplyGetSysVpnCertUri(MessageParcel &data, MessageParcel &reply)299 int32_t NetworkVpnServiceStub::ReplyGetSysVpnCertUri(MessageParcel &data, MessageParcel &reply)
300 {
301     int32_t certType;
302     if (!data.ReadInt32(certType)) {
303         NETMGR_EXT_LOG_E("ReplyGetSysVpnCertUri read data failed");
304         return NETMANAGER_EXT_ERR_READ_DATA_FAIL;
305     }
306     std::string certUri;
307     int32_t ret = GetSysVpnCertUri(certType, certUri);
308     if (ret != NETMANAGER_EXT_SUCCESS) {
309         NETMGR_EXT_LOG_E("ReplyGetSysVpnCertUri failed, ret=%{public}d", ret);
310         return ret;
311     }
312     if (!reply.WriteString(certUri)) {
313         NETMGR_EXT_LOG_E("ReplyGetSysVpnCertUri write reply failed");
314         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
315     }
316     return NETMANAGER_EXT_SUCCESS;
317 }
318 #endif // SUPPORT_SYSVPN
319 
ReplyRegisterVpnEvent(MessageParcel &data, MessageParcel &reply)320 int32_t NetworkVpnServiceStub::ReplyRegisterVpnEvent(MessageParcel &data, MessageParcel &reply)
321 {
322     sptr<IVpnEventCallback> callback = iface_cast<IVpnEventCallback>(data.ReadRemoteObject());
323     if (callback == nullptr) {
324         NETMGR_EXT_LOG_E("ReplyRegisterVpnEvent callback is null.");
325         return NETMANAGER_EXT_ERR_LOCAL_PTR_NULL;
326     }
327 
328     int32_t result = RegisterVpnEvent(callback);
329     if (!reply.WriteInt32(result)) {
330         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
331     }
332     return NETMANAGER_EXT_SUCCESS;
333 }
334 
ReplyUnregisterVpnEvent(MessageParcel &data, MessageParcel &reply)335 int32_t NetworkVpnServiceStub::ReplyUnregisterVpnEvent(MessageParcel &data, MessageParcel &reply)
336 {
337     sptr<IVpnEventCallback> callback = iface_cast<IVpnEventCallback>(data.ReadRemoteObject());
338     if (callback == nullptr) {
339         NETMGR_EXT_LOG_E("ReplyUnregisterVpnEvent callback is null.");
340         return NETMANAGER_EXT_ERR_LOCAL_PTR_NULL;
341     }
342 
343     int32_t result = UnregisterVpnEvent(callback);
344     if (!reply.WriteInt32(result)) {
345         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
346     }
347     return NETMANAGER_EXT_SUCCESS;
348 }
349 
ReplyCreateVpnConnection(MessageParcel &data, MessageParcel &reply)350 int32_t NetworkVpnServiceStub::ReplyCreateVpnConnection(MessageParcel &data, MessageParcel &reply)
351 {
352     int32_t result = CreateVpnConnection();
353     if (!reply.WriteInt32(result)) {
354         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
355     }
356     return NETMANAGER_EXT_SUCCESS;
357 }
358 
ReplyFactoryResetVpn(MessageParcel &data, MessageParcel &reply)359 int32_t NetworkVpnServiceStub::ReplyFactoryResetVpn(MessageParcel &data, MessageParcel &reply)
360 {
361     return NETMANAGER_EXT_SUCCESS;
362 }
363 
ReplyRegisterBundleName(MessageParcel &data, MessageParcel &reply)364 int32_t NetworkVpnServiceStub::ReplyRegisterBundleName(MessageParcel &data, MessageParcel &reply)
365 {
366     return NETMANAGER_EXT_SUCCESS;
367 }
368 
ReplyGetSelfAppName(MessageParcel &data, MessageParcel &reply)369 int32_t NetworkVpnServiceStub::ReplyGetSelfAppName(MessageParcel &data, MessageParcel &reply)
370 {
371     std::string selfAppName;
372     int32_t result = GetSelfAppName(selfAppName);
373     if (result != ERR_NONE) {
374         NETMGR_EXT_LOG_E("GetSelfAppName failed on service");
375         return result;
376     }
377     if (!reply.WriteString(selfAppName)) {
378         return NETMANAGER_EXT_ERR_WRITE_REPLY_FAIL;
379     }
380     return NETMANAGER_EXT_SUCCESS;
381 }
382 } // namespace NetManagerStandard
383 } // namespace OHOS
384