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