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 "app_provision_info_rdb.h"
17 #include "app_log_wrapper.h"
18 #include "scope_guard.h"
19 
20 namespace OHOS {
21 namespace AppExecFwk {
22 namespace {
23 const std::string APP_PROVISION_INFO_RDB_TABLE_NAME = "app_provision_info";
24 // app provision info table key
25 const std::string BUNDLE_NAME = "BUNDLE_NAME";
26 const std::string VERSION_CODE = "VERSION_CODE";
27 const std::string VERSION_NAME = "VERSION_NAME";
28 const std::string UUID = "UUID";
29 const std::string TYPE = "TYPE";
30 const std::string APP_DISTRIBUTION_TYPE = "APP_DISTRIBUTION_TYPE";
31 const std::string DEVELOPER_ID = "DEVELOPER_ID";
32 const std::string CERTIFICATE = "CERTIFICATE";
33 const std::string APL = "APL";
34 const std::string ISSUER = "ISSUER";
35 const std::string VALIDITY_NOT_BEFORE = "VALIDITY_NOT_BEFORE";
36 const std::string VALIDITY_NOT_AFTER = "VALIDITY_NOT_AFTER";
37 const std::string SPECIFIED_DISTRIBUTED_TYPE = "SPECIFIED_DISTRIBUTED_TYPE";
38 const std::string ADDITIONAL_INFO = "ADDITIONAL_INFO";
39 const std::string DEFAULT_VALUE = "";
40 const std::string APP_IDENTIFIER = "APP_IDENTIFIER";
41 const std::string APP_SERVICE_CAPABILITIES = "APP_SERVICE_CAPABILITIES";
42 const std::string ORGANIZATION = "ORGANIZATION";
43 const int32_t INDEX_BUNDLE_NAME = 0;
44 const int32_t INDEX_VERSION_CODE = 1;
45 const int32_t INDEX_VERSION_NAME = 2;
46 const int32_t INDEX_UUID = 3;
47 const int32_t INDEX_TYPE = 4;
48 const int32_t INDEX_APP_DISTRIBUTION_TYPE = 5;
49 const int32_t INDEX_DEVELOPER_ID = 6;
50 const int32_t INDEX_CERTIFICATE = 7;
51 const int32_t INDEX_APL = 8;
52 const int32_t INDEX_ISSUER = 9;
53 const int32_t INDEX_VALIDITY_NOT_BEFORE = 10;
54 const int32_t INDEX_VALIDITY_NOT_AFTER = 11;
55 const int32_t INDEX_SPECIFIED_DISTRIBUTED_TYPE = 12;
56 const int32_t INDEX_ADDITIONAL_INFO = 13;
57 const int32_t INDEX_APP_IDENTIFIER = 14;
58 const int32_t INDEX_APP_SERVICE_CAPABILITIES = 15;
59 const int32_t INDEX_ORGANIZATION = 16;
60 }
61 
AppProvisionInfoManagerRdb()62 AppProvisionInfoManagerRdb::AppProvisionInfoManagerRdb()
63 {
64     APP_LOGD("create AppProvisionInfoManagerRdb");
65     BmsRdbConfig bmsRdbConfig;
66     bmsRdbConfig.dbName = ServiceConstants::BUNDLE_RDB_NAME;
67     bmsRdbConfig.tableName = APP_PROVISION_INFO_RDB_TABLE_NAME;
68     bmsRdbConfig.createTableSql = std::string(
69         "CREATE TABLE IF NOT EXISTS "
70         + APP_PROVISION_INFO_RDB_TABLE_NAME
71         + "(BUNDLE_NAME TEXT PRIMARY KEY NOT NULL, "
72         + "VERSION_CODE INTEGER, VERSION_NAME TEXT, UUID TEXT, "
73         + "TYPE TEXT, APP_DISTRIBUTION_TYPE TEXT, DEVELOPER_ID TEXT, CERTIFICATE TEXT, "
74         + "APL TEXT, ISSUER TEXT, VALIDITY_NOT_BEFORE INTEGER, VALIDITY_NOT_AFTER INTEGER);");
75     // SPECIFIED_DISTRIBUTED_TYPE and ADDITIONAL_INFO insert to old database
76     bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " + APP_PROVISION_INFO_RDB_TABLE_NAME +
77         " ADD SPECIFIED_DISTRIBUTED_TYPE TEXT;"));
78     bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " + APP_PROVISION_INFO_RDB_TABLE_NAME +
79         " ADD ADDITIONAL_INFO TEXT;"));
80     bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " + APP_PROVISION_INFO_RDB_TABLE_NAME +
81         " ADD APP_IDENTIFIER TEXT;"));
82     bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " + APP_PROVISION_INFO_RDB_TABLE_NAME +
83         " ADD APP_SERVICE_CAPABILITIES TEXT;"));
84     bmsRdbConfig.insertColumnSql.push_back(std::string("ALTER TABLE " + APP_PROVISION_INFO_RDB_TABLE_NAME +
85         " ADD ORGANIZATION TEXT;"));
86     rdbDataManager_ = std::make_shared<RdbDataManager>(bmsRdbConfig);
87     rdbDataManager_->CreateTable();
88 }
89 
~AppProvisionInfoManagerRdb()90 AppProvisionInfoManagerRdb::~AppProvisionInfoManagerRdb()
91 {
92     APP_LOGD("destroy AppProvisionInfoManagerRdb");
93 }
94 
AddAppProvisionInfo(const std::string & bundleName,const AppProvisionInfo & appProvisionInfo)95 bool AppProvisionInfoManagerRdb::AddAppProvisionInfo(const std::string &bundleName,
96     const AppProvisionInfo &appProvisionInfo)
97 {
98     if (bundleName.empty()) {
99         APP_LOGE("AddAppProvisionInfo failed, bundleName is empty");
100         return false;
101     }
102     NativeRdb::ValuesBucket valuesBucket;
103     valuesBucket.PutString(BUNDLE_NAME, bundleName);
104     valuesBucket.PutLong(VERSION_CODE, static_cast<int64_t>(appProvisionInfo.versionCode));
105     valuesBucket.PutString(VERSION_NAME, appProvisionInfo.versionName);
106     valuesBucket.PutString(UUID, appProvisionInfo.uuid);
107     valuesBucket.PutString(TYPE, appProvisionInfo.type);
108     valuesBucket.PutString(APP_DISTRIBUTION_TYPE, appProvisionInfo.appDistributionType);
109     valuesBucket.PutString(DEVELOPER_ID, appProvisionInfo.developerId);
110     valuesBucket.PutString(CERTIFICATE, appProvisionInfo.certificate);
111     valuesBucket.PutString(APL, appProvisionInfo.apl);
112     valuesBucket.PutString(ISSUER, appProvisionInfo.issuer);
113     valuesBucket.PutLong(VALIDITY_NOT_BEFORE, appProvisionInfo.validity.notBefore);
114     valuesBucket.PutLong(VALIDITY_NOT_AFTER, appProvisionInfo.validity.notAfter);
115     valuesBucket.PutString(SPECIFIED_DISTRIBUTED_TYPE, DEFAULT_VALUE);
116     valuesBucket.PutString(ADDITIONAL_INFO, DEFAULT_VALUE);
117     valuesBucket.PutString(APP_IDENTIFIER, appProvisionInfo.appIdentifier);
118     valuesBucket.PutString(APP_SERVICE_CAPABILITIES, appProvisionInfo.appServiceCapabilities);
119     valuesBucket.PutString(ORGANIZATION, appProvisionInfo.organization);
120 
121     return rdbDataManager_->InsertData(valuesBucket);
122 }
123 
DeleteAppProvisionInfo(const std::string & bundleName)124 bool AppProvisionInfoManagerRdb::DeleteAppProvisionInfo(const std::string &bundleName)
125 {
126     if (bundleName.empty()) {
127         APP_LOGE("DeleteAppProvisionInfo failed, bundleName is empty");
128         return false;
129     }
130     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
131     absRdbPredicates.EqualTo(BUNDLE_NAME, bundleName);
132     return rdbDataManager_->DeleteData(absRdbPredicates);
133 }
134 
GetAppProvisionInfo(const std::string & bundleName,AppProvisionInfo & appProvisionInfo)135 bool AppProvisionInfoManagerRdb::GetAppProvisionInfo(const std::string &bundleName,
136     AppProvisionInfo &appProvisionInfo)
137 {
138     if (bundleName.empty()) {
139         APP_LOGE("GetAppProvisionInfo failed, bundleName is empty");
140         return false;
141     }
142     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
143     absRdbPredicates.EqualTo(BUNDLE_NAME, bundleName);
144     auto absSharedResultSet = rdbDataManager_->QueryData(absRdbPredicates);
145     if (absSharedResultSet == nullptr) {
146         APP_LOGE("AppProvisionInfoManagerRdb GetAppProvisionInfo failed");
147         return false;
148     }
149     ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
150     return ConvertToAppProvision(absSharedResultSet, appProvisionInfo);
151 }
152 
GetAllAppProvisionInfoBundleName(std::unordered_set<std::string> & bundleNames)153 bool AppProvisionInfoManagerRdb::GetAllAppProvisionInfoBundleName(std::unordered_set<std::string> &bundleNames)
154 {
155     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
156     auto absSharedResultSet = rdbDataManager_->QueryData(absRdbPredicates);
157     if (absSharedResultSet == nullptr) {
158         APP_LOGE("GetAppProvisionInfo failed");
159         return false;
160     }
161     ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
162 
163     auto ret = absSharedResultSet->GoToFirstRow();
164     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GoToFirstRow failed, ret: %{public}d");
165     do {
166         std::string name;
167         ret = absSharedResultSet->GetString(INDEX_BUNDLE_NAME, name);
168         CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString bundleName failed, ret: %{public}d");
169         bundleNames.insert(name);
170     } while (absSharedResultSet->GoToNextRow() == NativeRdb::E_OK);
171     return true;
172 }
173 
ConvertToAppProvision(const std::shared_ptr<NativeRdb::ResultSet> & absSharedResultSet,AppProvisionInfo & appProvisionInfo)174 bool AppProvisionInfoManagerRdb::ConvertToAppProvision(
175     const std::shared_ptr<NativeRdb::ResultSet> &absSharedResultSet,
176     AppProvisionInfo &appProvisionInfo)
177 {
178     if (absSharedResultSet == nullptr) {
179         APP_LOGE("absSharedResultSet is nullptr");
180         return false;
181     }
182     auto ret = absSharedResultSet->GoToFirstRow();
183     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GoToFirstRow failed, ret: %{public}d");
184     int64_t versionCode;
185     ret = absSharedResultSet->GetLong(INDEX_VERSION_CODE, versionCode);
186     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString versionCode failed, ret: %{public}d");
187     appProvisionInfo.versionCode = static_cast<uint32_t>(versionCode);
188     ret = absSharedResultSet->GetString(INDEX_VERSION_NAME, appProvisionInfo.versionName);
189     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString versionName failed, ret: %{public}d");
190     ret = absSharedResultSet->GetString(INDEX_UUID, appProvisionInfo.uuid);
191     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString uuid failed, ret: %{public}d");
192     ret = absSharedResultSet->GetString(INDEX_TYPE, appProvisionInfo.type);
193     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString type failed, ret: %{public}d");
194     ret = absSharedResultSet->GetString(INDEX_APP_DISTRIBUTION_TYPE, appProvisionInfo.appDistributionType);
195     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString appDistributionType failed, ret: %{public}d");
196     ret = absSharedResultSet->GetString(INDEX_DEVELOPER_ID, appProvisionInfo.developerId);
197     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString developerId failed, ret: %{public}d");
198     ret = absSharedResultSet->GetString(INDEX_CERTIFICATE, appProvisionInfo.certificate);
199     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString certificate failed, ret: %{public}d");
200     ret = absSharedResultSet->GetString(INDEX_APL, appProvisionInfo.apl);
201     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString apl failed, ret: %{public}d");
202     ret = absSharedResultSet->GetString(INDEX_ISSUER, appProvisionInfo.issuer);
203     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString issuer failed, ret: %{public}d");
204     ret = absSharedResultSet->GetLong(INDEX_VALIDITY_NOT_BEFORE, appProvisionInfo.validity.notBefore);
205     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString notBefore failed, ret: %{public}d");
206     ret = absSharedResultSet->GetLong(INDEX_VALIDITY_NOT_AFTER, appProvisionInfo.validity.notAfter);
207     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString notAfter failed, ret: %{public}d");
208     ret = absSharedResultSet->GetString(INDEX_APP_IDENTIFIER, appProvisionInfo.appIdentifier);
209     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString appIdentifier failed, ret: %{public}d");
210     ret = absSharedResultSet->GetString(INDEX_APP_SERVICE_CAPABILITIES, appProvisionInfo.appServiceCapabilities);
211     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString appServiceCapabilities failed, ret: %{public}d");
212     ret = absSharedResultSet->GetString(INDEX_ORGANIZATION, appProvisionInfo.organization);
213     CHECK_RDB_RESULT_RETURN_IF_FAIL(ret, "GetString organization failed, ret: %{public}d");
214     return true;
215 }
216 
SetSpecifiedDistributionType(const std::string & bundleName,const std::string & specifiedDistributionType)217 bool AppProvisionInfoManagerRdb::SetSpecifiedDistributionType(
218     const std::string &bundleName, const std::string &specifiedDistributionType)
219 {
220     if (bundleName.empty()) {
221         APP_LOGE("SetSpecifiedDistributionType failed, bundleName is empty");
222         return false;
223     }
224     NativeRdb::ValuesBucket valuesBucket;
225     valuesBucket.PutString(SPECIFIED_DISTRIBUTED_TYPE, specifiedDistributionType);
226     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
227     absRdbPredicates.EqualTo(BUNDLE_NAME, bundleName);
228     if (!rdbDataManager_->UpdateData(valuesBucket, absRdbPredicates)) {
229         APP_LOGE("bundleName %{public}s SetSpecifiedDistributionType failed", bundleName.c_str());
230         return false;
231     }
232     return true;
233 }
234 
GetSpecifiedDistributionType(const std::string & bundleName,std::string & specifiedDistributionType)235 bool AppProvisionInfoManagerRdb::GetSpecifiedDistributionType(
236     const std::string &bundleName, std::string &specifiedDistributionType)
237 {
238     if (bundleName.empty()) {
239         APP_LOGE("GetSpecifiedDistributionType failed, bundleName is empty");
240         return false;
241     }
242     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
243     absRdbPredicates.EqualTo(BUNDLE_NAME, bundleName);
244     auto absSharedResultSet = rdbDataManager_->QueryData(absRdbPredicates);
245     if (absSharedResultSet == nullptr) {
246         APP_LOGW("bundleName %{public}s GetSpecifiedDistributionType QueryData failed", bundleName.c_str());
247         return false;
248     }
249     ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
250     auto ret = absSharedResultSet->GoToFirstRow();
251     if (ret != NativeRdb::E_OK) {
252         APP_LOGW("bundleName: %{public}s GetSpecifiedDistributionType failed", bundleName.c_str());
253         return false;
254     }
255     ret = absSharedResultSet->GetString(INDEX_SPECIFIED_DISTRIBUTED_TYPE, specifiedDistributionType);
256     if (ret != NativeRdb::E_OK) {
257         APP_LOGE("bundleName %{public}s GetString failed", bundleName.c_str());
258         return false;
259     }
260     return true;
261 }
262 
SetAdditionalInfo(const std::string & bundleName,const std::string & additionalInfo)263 bool AppProvisionInfoManagerRdb::SetAdditionalInfo(
264     const std::string &bundleName, const std::string &additionalInfo)
265 {
266     if (bundleName.empty()) {
267         APP_LOGE("SetAdditionalInfo failed, bundleName is empty");
268         return false;
269     }
270     NativeRdb::ValuesBucket valuesBucket;
271     valuesBucket.PutString(ADDITIONAL_INFO, additionalInfo);
272     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
273     absRdbPredicates.EqualTo(BUNDLE_NAME, bundleName);
274     if (!rdbDataManager_->UpdateData(valuesBucket, absRdbPredicates)) {
275         APP_LOGE("bundleName %{public}s SetAdditionalInfo failed", bundleName.c_str());
276         return false;
277     }
278     return true;
279 }
280 
GetAdditionalInfo(const std::string & bundleName,std::string & additionalInfo)281 bool AppProvisionInfoManagerRdb::GetAdditionalInfo(
282     const std::string &bundleName, std::string &additionalInfo)
283 {
284     if (bundleName.empty()) {
285         APP_LOGE("GetAdditionalInfo failed, bundleName is empty");
286         return false;
287     }
288     NativeRdb::AbsRdbPredicates absRdbPredicates(APP_PROVISION_INFO_RDB_TABLE_NAME);
289     absRdbPredicates.EqualTo(BUNDLE_NAME, bundleName);
290     auto absSharedResultSet = rdbDataManager_->QueryData(absRdbPredicates);
291     if (absSharedResultSet == nullptr) {
292         APP_LOGW("bundleName %{public}s, GetAdditionalInfo QueryData failed", bundleName.c_str());
293         return false;
294     }
295     ScopeGuard stateGuard([absSharedResultSet] { absSharedResultSet->Close(); });
296     auto ret = absSharedResultSet->GoToFirstRow();
297     if (ret != NativeRdb::E_OK) {
298         APP_LOGW("bundleName %{public}s GetAdditionalInfo failed", bundleName.c_str());
299         return false;
300     }
301     ret = absSharedResultSet->GetString(INDEX_ADDITIONAL_INFO, additionalInfo);
302     if (ret != NativeRdb::E_OK) {
303         APP_LOGE("bundleName %{public}s GetAdditionalInfo failed", bundleName.c_str());
304         return false;
305     }
306     return true;
307 }
308 } // namespace AppExecFwk
309 } // namespace OHOS
310