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