1 /*
2  * Copyright (c) 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 
16 #include "vpn_database_helper.h"
17 
18 #include <cstdlib>
19 #include <filesystem>
20 
21 #include "net_manager_constants.h"
22 #include "net_manager_ext_constants.h"
23 #include "netmgr_ext_log_wrapper.h"
24 #include "vpn_database_defines.h"
25 
26 namespace OHOS {
27 namespace NetManagerStandard {
28 using namespace VpnDatabaseDefines;
29 
GetInstance()30 VpnDatabaseHelper &VpnDatabaseHelper::GetInstance()
31 {
32     static VpnDatabaseHelper instance;
33     return instance;
34 }
35 
VpnDatabaseHelper()36 VpnDatabaseHelper::VpnDatabaseHelper()
37 {
38     if (!std::filesystem::exists(VPN_DATABASE_PATH)) {
39         std::error_code ec;
40         if (std::filesystem::create_directories(VPN_DATABASE_PATH, ec)) {
41             NETMGR_EXT_LOG_D("create_directories success :%{public}s", VPN_DATABASE_PATH.c_str());
42         } else {
43             NETMGR_EXT_LOG_E("create_directories error :%{public}s : %s", VPN_DATABASE_PATH.c_str(),
44                 ec.message().c_str());
45         }
46     }
47     std::string vpnDatabaseName = VPN_DATABASE_PATH + VPN_DB_NAME;
48     int32_t errCode = OHOS::NativeRdb::E_OK;
49     OHOS::NativeRdb::RdbStoreConfig config(vpnDatabaseName);
50     config.SetSecurityLevel(NativeRdb::SecurityLevel::S1);
51     VpnDataBaseCallBack sqliteOpenHelperCallback;
52     store_ = OHOS::NativeRdb::RdbHelper::GetRdbStore(config, DATABASE_OPEN_VERSION, sqliteOpenHelperCallback, errCode);
53     if (errCode != OHOS::NativeRdb::E_OK && errCode != OHOS::NativeRdb::E_SQLITE_CORRUPT) {
54         NETMGR_EXT_LOG_E("GetRdbStore failed. errCode :%{public}d", errCode);
55     } else {
56         NETMGR_EXT_LOG_I("GetRdbStore success");
57     }
58 }
59 
OnCreate(OHOS::NativeRdb::RdbStore &store)60 int32_t VpnDataBaseCallBack::OnCreate(OHOS::NativeRdb::RdbStore &store)
61 {
62     NETMGR_EXT_LOG_I("DB OnCreate Enter");
63     std::string sql =
64         "CREATE TABLE IF NOT EXISTS " + VPN_CONFIG_TABLE + "(" + std::string(VPN_CONFIG_TABLE_CREATE_PARAM) + ");";
65     int32_t ret = store.ExecuteSql(sql);
66     if (ret != OHOS::NativeRdb::E_OK) {
67         NETMGR_EXT_LOG_E("Create table failed: %{public}d", ret);
68         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
69     }
70     return NETMANAGER_EXT_SUCCESS;
71 }
72 
OnUpgrade(OHOS::NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)73 int32_t VpnDataBaseCallBack::OnUpgrade(OHOS::NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)
74 {
75     NETMGR_EXT_LOG_I("DB OnUpgrade Enter");
76     return NETMANAGER_EXT_SUCCESS;
77 }
78 
OnDowngrade(OHOS::NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)79 int32_t VpnDataBaseCallBack::OnDowngrade(OHOS::NativeRdb::RdbStore &store, int32_t oldVersion, int32_t newVersion)
80 {
81     NETMGR_EXT_LOG_I("DB OnDowngrade Enter");
82     return NETMANAGER_EXT_SUCCESS;
83 }
84 
InsertOrUpdateData(const sptr<VpnDataBean> &vpnBean)85 int32_t VpnDatabaseHelper::InsertOrUpdateData(const sptr<VpnDataBean> &vpnBean)
86 {
87     if (vpnBean == nullptr) {
88         NETMGR_EXT_LOG_E("InsertOrUpdateData vpnBean is nullptr");
89         return NETMANAGER_EXT_ERR_INVALID_PARAMETER;
90     }
91 
92     if (IsVpnInfoExists(vpnBean->vpnId_)) {
93         return UpdateData(vpnBean);
94     }
95     return InsertData(vpnBean);
96 }
97 
IsVpnInfoExists(const std::string &vpnId)98 bool VpnDatabaseHelper::IsVpnInfoExists(const std::string &vpnId)
99 {
100     if (vpnId.empty()) {
101         NETMGR_EXT_LOG_E("IsVpnInfoExists vpnId is empty");
102         return false;
103     }
104     if (store_ == nullptr) {
105         NETMGR_EXT_LOG_E("IsVpnInfoExists store_ is nullptr");
106         return false;
107     }
108 
109     std::vector<std::string> columns;
110     OHOS::NativeRdb::RdbPredicates rdbPredicate{ VPN_CONFIG_TABLE };
111     rdbPredicate.EqualTo(VPN_ID, vpnId);
112     auto queryResultSet = store_->Query(rdbPredicate, columns);
113     if (queryResultSet == nullptr) {
114         NETMGR_EXT_LOG_E("Query error");
115         return false;
116     }
117 
118     int32_t rowCount = 0;
119     int32_t ret = queryResultSet->GetRowCount(rowCount);
120     if (ret != OHOS::NativeRdb::E_OK) {
121         NETMGR_EXT_LOG_E("get row count failed, ret:%{public}d", ret);
122         return false;
123     }
124     return rowCount == 1;
125 }
126 
BindVpnData(NativeRdb::ValuesBucket &values, const sptr<VpnDataBean> &info)127 void VpnDatabaseHelper::BindVpnData(NativeRdb::ValuesBucket &values, const sptr<VpnDataBean> &info)
128 {
129     if (info == nullptr) {
130         NETMGR_EXT_LOG_E("BindVpnData info is nullptr");
131         return;
132     }
133     values.PutString(VPN_ID, info->vpnId_);
134     values.PutString(VPN_NAME, info->vpnName_);
135     values.PutInt(VPN_TYPE, info->vpnType_);
136     values.PutString(VPN_ADDRESS, info->vpnAddress_);
137     values.PutString(USER_NAME, info->userName_);
138     values.PutString(PASSWORD, info->password_);
139     values.PutInt(USER_ID, info->userId_);
140     values.PutInt(VPN_IS_LEGACY, info->isLegacy_);
141     values.PutInt(VPN_SAVE_LOGIN, info->saveLogin_);
142     values.PutString(VPN_FORWARDED_ROUTES, info->forwardingRoutes_);
143     values.PutString(VPN_DNS_ADDRESSES, info->dnsAddresses_);
144     values.PutString(VPN_SEARCH_DOMAINS, info->searchDomains_);
145 
146     values.PutString(OPENVPN_PORT, info->ovpnPort_);
147     values.PutInt(OPENVPN_PROTOCOL, info->ovpnProtocol_);
148     values.PutString(OPENVPN_CFG, info->ovpnConfig_);
149     values.PutInt(OPENVPN_AUTH_TYPE, info->ovpnAuthType_);
150     values.PutString(OPENVPN_ASKPASS, info->askpass_);
151     values.PutString(OPENVPN_CFG_FILE_PATH, info->ovpnConfigFilePath_);
152     values.PutString(OPENVPN_CA_CERT_FILE_PATH, info->ovpnCaCertFilePath_);
153     values.PutString(OPENVPN_USER_CERT_FILE_PATH, info->ovpnUserCertFilePath_);
154     values.PutString(OPENVPN_PRIVATE_KEY_FILE_PATH, info->ovpnPrivateKeyFilePath_);
155 
156     values.PutString(IPSEC_PRE_SHARE_KEY, info->ipsecPreSharedKey_);
157     values.PutString(IPSEC_IDENTIFIER, info->ipsecIdentifier_);
158     values.PutString(SWANCTL_CONF, info->swanctlConf_);
159     values.PutString(STRONGSWAN_CONF, info->strongswanConf_);
160     values.PutString(IPSEC_CA_CERT_CONF, info->ipsecCaCertConf_);
161     values.PutString(IPSEC_PRIVATE_USER_CERT_CONF, info->ipsecPrivateUserCertConf_);
162     values.PutString(IPSEC_PUBLIC_USER_CERT_CONF, info->ipsecPublicUserCertConf_);
163     values.PutString(IPSEC_PRIVATE_SERVER_CERT_CONF, info->ipsecPrivateServerCertConf_);
164     values.PutString(IPSEC_PUBLIC_SERVER_CERT_CONF, info->ipsecPublicServerCertConf_);
165     values.PutString(IPSEC_CA_CERT_FILE_PATH, info->ipsecCaCertFilePath_);
166     values.PutString(IPSEC_PRIVATE_USER_CERT_FILE_PATH, info->ipsecPrivateUserCertFilePath_);
167     values.PutString(IPSEC_PUBLIC_USER_CERT_FILE_PATH, info->ipsecPublicUserCertFilePath_);
168     values.PutString(IPSEC_PRIVATE_SERVER_CERT_FILE_PATH, info->ipsecPrivateServerCertFilePath_);
169     values.PutString(IPSEC_PUBLIC_SERVER_CERT_FILE_PATH, info->ipsecPublicServerCertFilePath_);
170     values.PutString(IPSEC_CONF, info->ipsecConf_);
171     values.PutString(IPSEC_SECRETS, info->ipsecSecrets_);
172     values.PutString(OPTIONS_L2TPD_CLIENT, info->optionsL2tpdClient_);
173     values.PutString(XL2TPD_CONF, info->xl2tpdConf_);
174     values.PutString(L2TP_SHARED_KEY, info->l2tpSharedKey_);
175 }
176 
InsertData(const sptr<VpnDataBean> &vpnBean)177 int32_t VpnDatabaseHelper::InsertData(const sptr<VpnDataBean> &vpnBean)
178 {
179     NETMGR_EXT_LOG_I("InsertData");
180     if (vpnBean == nullptr) {
181         NETMGR_EXT_LOG_E("InsertData vpnBean is nullptr");
182         return NETMANAGER_EXT_ERR_INVALID_PARAMETER;
183     }
184     if (store_ == nullptr) {
185         NETMGR_EXT_LOG_E("InsertData store_ is nullptr");
186         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
187     }
188 
189     NativeRdb::ValuesBucket values;
190     BindVpnData(values, vpnBean);
191     int64_t rowId = 0;
192     int ret = store_->Insert(rowId, VPN_CONFIG_TABLE, values);
193     if (ret != NativeRdb::E_OK) {
194         NETMGR_EXT_LOG_E("InsertData failed, result is %{public}d", ret);
195         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
196     }
197     return NETMANAGER_EXT_SUCCESS;
198 }
199 
UpdateData(const sptr<VpnDataBean> &vpnBean)200 int32_t VpnDatabaseHelper::UpdateData(const sptr<VpnDataBean> &vpnBean)
201 {
202     if (store_ == nullptr) {
203         NETMGR_EXT_LOG_E("UpdateData store_ is nullptr");
204         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
205     }
206     if (vpnBean == nullptr) {
207         NETMGR_EXT_LOG_E("UpdateData vpnBean is nullptr");
208         return NETMANAGER_EXT_ERR_INVALID_PARAMETER;
209     }
210     NETMGR_EXT_LOG_I("UpdateData");
211     OHOS::NativeRdb::RdbPredicates rdbPredicate{ VPN_CONFIG_TABLE };
212     rdbPredicate.EqualTo(VPN_ID, vpnBean->vpnId_);
213     NativeRdb::ValuesBucket values;
214     BindVpnData(values, vpnBean);
215     int32_t rowId = -1;
216     int32_t ret = store_->Update(rowId, values, rdbPredicate);
217     if (ret != OHOS::NativeRdb::E_OK) {
218         NETMGR_EXT_LOG_E("UpdateData ret :%{public}d", ret);
219         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
220     }
221     return NETMANAGER_EXT_SUCCESS;
222 }
223 
GetVpnDataFromResultSet(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &queryResultSet, sptr<VpnDataBean> &vpnBean)224 void VpnDatabaseHelper::GetVpnDataFromResultSet(const std::shared_ptr<OHOS::NativeRdb::ResultSet> &queryResultSet,
225     sptr<VpnDataBean> &vpnBean)
226 {
227     queryResultSet->GetString(INDEX_VPN_ID, vpnBean->vpnId_);
228     queryResultSet->GetString(INDEX_VPN_NAME, vpnBean->vpnName_);
229     queryResultSet->GetInt(INDEX_VPN_TYPE, vpnBean->vpnType_);
230     queryResultSet->GetString(INDEX_VPN_ADDRESS, vpnBean->vpnAddress_);
231     queryResultSet->GetString(INDEX_USER_NAME, vpnBean->userName_);
232     queryResultSet->GetString(INDEX_PASSWORD, vpnBean->password_);
233     queryResultSet->GetInt(INDEX_USER_ID, vpnBean->userId_);
234     queryResultSet->GetInt(INDEX_VPN_IS_LEGACY, vpnBean->isLegacy_);
235     queryResultSet->GetInt(INDEX_VPN_SAVE_LOGIN, vpnBean->saveLogin_);
236     queryResultSet->GetString(INDEX_VPN_FORWARDED_ROUTES, vpnBean->forwardingRoutes_);
237     queryResultSet->GetString(INDEX_VPN_DNS_ADDRESSES, vpnBean->dnsAddresses_);
238     queryResultSet->GetString(INDEX_VPN_SEARCH_DOMAINS, vpnBean->searchDomains_);
239     queryResultSet->GetString(INDEX_OPENVPN_PORT, vpnBean->ovpnPort_);
240     queryResultSet->GetInt(INDEX_OPENVPN_PROTOCOL, vpnBean->ovpnProtocol_);
241     queryResultSet->GetString(INDEX_OPENVPN_CFG, vpnBean->ovpnConfig_);
242     queryResultSet->GetInt(INDEX_OPENVPN_AUTH_TYPE, vpnBean->ovpnAuthType_);
243     queryResultSet->GetString(INDEX_OPENVPN_ASKPASS, vpnBean->askpass_);
244     queryResultSet->GetString(INDEX_OPENVPN_CFG_FILE_PATH, vpnBean->ovpnConfigFilePath_);
245     queryResultSet->GetString(INDEX_OPENVPN_CA_CERT_FILE_PATH, vpnBean->ovpnCaCertFilePath_);
246     queryResultSet->GetString(INDEX_OPENVPN_USER_CERT_FILE_PATH, vpnBean->ovpnUserCertFilePath_);
247     queryResultSet->GetString(INDEX_OPENVPN_PRIVATE_KEY_FILE_PATH, vpnBean->ovpnPrivateKeyFilePath_);
248 
249     queryResultSet->GetString(INDEX_IPSEC_PRE_SHARE_KEY, vpnBean->ipsecPreSharedKey_);
250     queryResultSet->GetString(INDEX_IPSEC_IDENTIFIER, vpnBean->ipsecIdentifier_);
251     queryResultSet->GetString(INDEX_SWANCTL_CONF, vpnBean->swanctlConf_);
252     queryResultSet->GetString(INDEX_STRONGSWAN_CONF, vpnBean->strongswanConf_);
253     queryResultSet->GetString(INDEX_IPSEC_CA_CERT_CONF, vpnBean->ipsecCaCertConf_);
254     queryResultSet->GetString(INDEX_IPSEC_PRIVATE_USER_CERT_CONF, vpnBean->ipsecPrivateUserCertConf_);
255     queryResultSet->GetString(INDEX_IPSEC_PUBLIC_USER_CERT_CONF, vpnBean->ipsecPublicUserCertConf_);
256     queryResultSet->GetString(INDEX_IPSEC_PRIVATE_SERVER_CERT_CONF, vpnBean->ipsecPrivateServerCertConf_);
257     queryResultSet->GetString(INDEX_IPSEC_PUBLIC_SERVER_CERT_CONF, vpnBean->ipsecPublicServerCertConf_);
258     queryResultSet->GetString(INDEX_IPSEC_CA_CERT_FILE_PATH, vpnBean->ipsecCaCertFilePath_);
259     queryResultSet->GetString(INDEX_IPSEC_PRIVATE_USER_CERT_FILE_PATH, vpnBean->ipsecPrivateUserCertFilePath_);
260     queryResultSet->GetString(INDEX_IPSEC_PUBLIC_USER_CERT_FILE_PATH, vpnBean->ipsecPublicUserCertFilePath_);
261     queryResultSet->GetString(INDEX_IPSEC_PRIVATE_SERVER_CERT_FILE_PATH, vpnBean->ipsecPrivateServerCertFilePath_);
262     queryResultSet->GetString(INDEX_IPSEC_PUBLIC_SERVER_CERT_FILE_PATH, vpnBean->ipsecPublicServerCertFilePath_);
263     queryResultSet->GetString(INDEX_IPSEC_CONF, vpnBean->ipsecConf_);
264     queryResultSet->GetString(INDEX_IPSEC_SECRETS, vpnBean->ipsecSecrets_);
265     queryResultSet->GetString(INDEX_OPTIONS_L2TPD_CLIENT, vpnBean->optionsL2tpdClient_);
266     queryResultSet->GetString(INDEX_XL2TPD_CONF, vpnBean->xl2tpdConf_);
267     queryResultSet->GetString(INDEX_L2TP_SHARED_KEY, vpnBean->l2tpSharedKey_);
268 }
269 
QueryVpnData(sptr<VpnDataBean> &vpnBean, const std::string &vpnUuid)270 int32_t VpnDatabaseHelper::QueryVpnData(sptr<VpnDataBean> &vpnBean, const std::string &vpnUuid)
271 {
272     if (vpnBean == nullptr) {
273         NETMGR_EXT_LOG_E("QueryVpnData vpnBean is nullptr");
274         return NETMANAGER_EXT_ERR_INVALID_PARAMETER;
275     }
276     if (vpnUuid.empty()) {
277         NETMGR_EXT_LOG_E("QueryVpnData vpnUuid is empty");
278         return NETMANAGER_EXT_ERR_INVALID_PARAMETER;
279     }
280 
281     NETMGR_EXT_LOG_I("QueryVpnData vpnUuid=%{public}s", vpnUuid.c_str());
282     if (store_ == nullptr) {
283         NETMGR_EXT_LOG_E("QueryVpnData store_ is nullptr");
284         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
285     }
286 
287     std::vector<std::string> columns;
288     OHOS::NativeRdb::RdbPredicates rdbPredicate{ VPN_CONFIG_TABLE };
289     rdbPredicate.EqualTo(VPN_ID, vpnUuid);
290     auto queryResultSet = store_->Query(rdbPredicate, columns);
291     if (queryResultSet == nullptr) {
292         NETMGR_EXT_LOG_E("QueryVpnData error");
293         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
294     }
295     int32_t rowCount = 0;
296     int ret = queryResultSet->GetRowCount(rowCount);
297     if (ret != OHOS::NativeRdb::E_OK) {
298         NETMGR_EXT_LOG_E("QueryVpnData failed, get row count failed, ret:%{public}d", ret);
299         return ret;
300     }
301     if (rowCount == 0) {
302         NETMGR_EXT_LOG_E("QueryVpnData result num is 0");
303         return NETMANAGER_EXT_SUCCESS;
304     }
305     while (!queryResultSet->GoToNextRow()) {
306         GetVpnDataFromResultSet(queryResultSet, vpnBean);
307         if (vpnBean->vpnId_ == vpnUuid) {
308             return NETMANAGER_SUCCESS;
309         }
310     }
311     return NETMANAGER_EXT_SUCCESS;
312 }
313 
QueryAllData(std::vector<SysVpnConfig> &infos, const int32_t userId)314 int32_t VpnDatabaseHelper::QueryAllData(std::vector<SysVpnConfig> &infos, const int32_t userId)
315 {
316     NETMGR_EXT_LOG_I("QueryAllData");
317     if (store_ == nullptr) {
318         NETMGR_EXT_LOG_E("QueryAllData store_ is nullptr");
319         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
320     }
321     infos.clear();
322     std::vector<std::string> columns;
323     OHOS::NativeRdb::RdbPredicates rdbPredicate{ VPN_CONFIG_TABLE };
324     rdbPredicate.EqualTo(USER_ID, userId);
325     auto queryResultSet = store_->Query(rdbPredicate, columns);
326     if (queryResultSet == nullptr) {
327         NETMGR_EXT_LOG_E("QueryAllData error");
328         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
329     }
330     int32_t rowCount = 0;
331     int ret = queryResultSet->GetRowCount(rowCount);
332     if (ret != OHOS::NativeRdb::E_OK) {
333         NETMGR_EXT_LOG_E("QueryAllData failed, get row count failed, ret:%{public}d", ret);
334         return ret;
335     }
336     if (rowCount == 0) {
337         NETMGR_EXT_LOG_E("QueryAllData result num is 0");
338         return NETMANAGER_EXT_SUCCESS;
339     }
340     while (!queryResultSet->GoToNextRow()) {
341         SysVpnConfig info;
342         queryResultSet->GetString(INDEX_VPN_ID, info.vpnId_);
343         queryResultSet->GetString(INDEX_VPN_NAME, info.vpnName_);
344         infos.emplace_back(info);
345     }
346     return NETMANAGER_EXT_SUCCESS;
347 }
348 
DeleteVpnData(const std::string &vpnUuid)349 int32_t VpnDatabaseHelper::DeleteVpnData(const std::string &vpnUuid)
350 {
351     NETMGR_EXT_LOG_I("DeleteVpnData");
352     if (vpnUuid.empty()) {
353         NETMGR_EXT_LOG_E("DeleteVpnData vpnUuid is empty");
354         return NETMANAGER_EXT_ERR_INVALID_PARAMETER;
355     }
356 
357     if (store_ == nullptr) {
358         NETMGR_EXT_LOG_E("DeleteVpnData store_ is nullptr");
359         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
360     }
361     int32_t deletedRows = -1;
362     OHOS::NativeRdb::RdbPredicates rdbPredicate{ VPN_CONFIG_TABLE };
363     rdbPredicate.EqualTo(VPN_ID, vpnUuid);
364     int32_t result = store_->Delete(deletedRows, rdbPredicate);
365     if (result != NativeRdb::E_OK) {
366         NETMGR_EXT_LOG_E("DeleteVpnData failed, result is %{public}d", result);
367         return NETMANAGER_EXT_ERR_OPERATION_FAILED;
368     }
369     return NETMANAGER_EXT_SUCCESS;
370 }
371 } // namespace NetManagerStandard
372 } // namespace OHOS
373