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