1 /*
2 * Copyright (c) 2021-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 "access_token_open_callback.h"
17
18 #include "access_token_error.h"
19 #include "access_token.h"
20 #include "accesstoken_common_log.h"
21 #include "token_field_const.h"
22
23 namespace OHOS {
24 namespace Security {
25 namespace AccessToken {
26 namespace {
27 constexpr const char* INTEGER_STR = " integer not null,";
28 constexpr const char* TEXT_STR = " text not null,";
29 // back up name is xxx_slave fixed, can not be changed
30 constexpr const char* DATABASE_NAME_BACK = "access_token_slave.db";
31 }
32
CreateHapTokenInfoTable(NativeRdb::RdbStore & rdbStore)33 int32_t AccessTokenOpenCallback::CreateHapTokenInfoTable(NativeRdb::RdbStore& rdbStore)
34 {
35 std::string tableName;
36 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_HAP_INFO, tableName);
37
38 std::string sql = "create table if not exists " + tableName;
39 sql.append(" (")
40 .append(TokenFiledConst::FIELD_TOKEN_ID)
41 .append(INTEGER_STR)
42 .append(TokenFiledConst::FIELD_USER_ID)
43 .append(INTEGER_STR)
44 .append(TokenFiledConst::FIELD_BUNDLE_NAME)
45 .append(TEXT_STR)
46 .append(TokenFiledConst::FIELD_INST_INDEX)
47 .append(INTEGER_STR)
48 .append(TokenFiledConst::FIELD_DLP_TYPE)
49 .append(INTEGER_STR)
50 .append(TokenFiledConst::FIELD_APP_ID)
51 .append(TEXT_STR)
52 .append(TokenFiledConst::FIELD_DEVICE_ID)
53 .append(TEXT_STR)
54 .append(TokenFiledConst::FIELD_APL)
55 .append(INTEGER_STR)
56 .append(TokenFiledConst::FIELD_TOKEN_VERSION)
57 .append(INTEGER_STR)
58 .append(TokenFiledConst::FIELD_TOKEN_ATTR)
59 .append(INTEGER_STR)
60 .append(TokenFiledConst::FIELD_API_VERSION)
61 .append(INTEGER_STR)
62 .append(TokenFiledConst::FIELD_FORBID_PERM_DIALOG)
63 .append(INTEGER_STR)
64 .append("primary key(")
65 .append(TokenFiledConst::FIELD_TOKEN_ID)
66 .append("))");
67
68 return rdbStore.ExecuteSql(sql);
69 }
70
CreateNativeTokenInfoTable(NativeRdb::RdbStore & rdbStore)71 int32_t AccessTokenOpenCallback::CreateNativeTokenInfoTable(NativeRdb::RdbStore& rdbStore)
72 {
73 std::string tableName;
74 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_NATIVE_INFO, tableName);
75
76 std::string sql = "create table if not exists " + tableName;
77 sql.append(" (")
78 .append(TokenFiledConst::FIELD_TOKEN_ID)
79 .append(INTEGER_STR)
80 .append(TokenFiledConst::FIELD_PROCESS_NAME)
81 .append(TEXT_STR)
82 .append(TokenFiledConst::FIELD_TOKEN_VERSION)
83 .append(INTEGER_STR)
84 .append(TokenFiledConst::FIELD_TOKEN_ATTR)
85 .append(INTEGER_STR)
86 .append(TokenFiledConst::FIELD_DCAP)
87 .append(TEXT_STR)
88 .append(TokenFiledConst::FIELD_NATIVE_ACLS)
89 .append(TEXT_STR)
90 .append(TokenFiledConst::FIELD_APL)
91 .append(INTEGER_STR)
92 .append("primary key(")
93 .append(TokenFiledConst::FIELD_TOKEN_ID)
94 .append("))");
95
96 return rdbStore.ExecuteSql(sql);
97 }
98
CreatePermissionDefinitionTable(NativeRdb::RdbStore & rdbStore)99 int32_t AccessTokenOpenCallback::CreatePermissionDefinitionTable(NativeRdb::RdbStore& rdbStore)
100 {
101 std::string tableName;
102 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_DEF, tableName);
103
104 std::string sql = "create table if not exists " + tableName;
105 sql.append(" (")
106 .append(TokenFiledConst::FIELD_TOKEN_ID)
107 .append(INTEGER_STR)
108 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
109 .append(TEXT_STR)
110 .append(TokenFiledConst::FIELD_BUNDLE_NAME)
111 .append(TEXT_STR)
112 .append(TokenFiledConst::FIELD_GRANT_MODE)
113 .append(INTEGER_STR)
114 .append(TokenFiledConst::FIELD_AVAILABLE_LEVEL)
115 .append(INTEGER_STR)
116 .append(TokenFiledConst::FIELD_PROVISION_ENABLE)
117 .append(INTEGER_STR)
118 .append(TokenFiledConst::FIELD_DISTRIBUTED_SCENE_ENABLE)
119 .append(INTEGER_STR)
120 .append(TokenFiledConst::FIELD_LABEL)
121 .append(TEXT_STR)
122 .append(TokenFiledConst::FIELD_LABEL_ID)
123 .append(INTEGER_STR)
124 .append(TokenFiledConst::FIELD_DESCRIPTION)
125 .append(TEXT_STR)
126 .append(TokenFiledConst::FIELD_DESCRIPTION_ID)
127 .append(INTEGER_STR)
128 .append(TokenFiledConst::FIELD_AVAILABLE_TYPE)
129 .append(INTEGER_STR)
130 .append(TokenFiledConst::FIELD_KERNEL_EFFECT)
131 .append(" integer, ")
132 .append(TokenFiledConst::FIELD_HAS_VALUE)
133 .append(" integer, ")
134 .append("primary key(")
135 .append(TokenFiledConst::FIELD_TOKEN_ID)
136 .append(",")
137 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
138 .append("))");
139
140 return rdbStore.ExecuteSql(sql);
141 }
142
CreatePermissionStateTable(NativeRdb::RdbStore & rdbStore)143 int32_t AccessTokenOpenCallback::CreatePermissionStateTable(NativeRdb::RdbStore& rdbStore)
144 {
145 std::string tableName;
146 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, tableName);
147
148 std::string sql = "create table if not exists " + tableName;
149 sql.append(" (")
150 .append(TokenFiledConst::FIELD_TOKEN_ID)
151 .append(INTEGER_STR)
152 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
153 .append(TEXT_STR)
154 .append(TokenFiledConst::FIELD_DEVICE_ID)
155 .append(TEXT_STR)
156 .append(TokenFiledConst::FIELD_GRANT_IS_GENERAL + " integer,")
157 .append(TokenFiledConst::FIELD_GRANT_STATE)
158 .append(INTEGER_STR)
159 .append(TokenFiledConst::FIELD_GRANT_FLAG)
160 .append(INTEGER_STR)
161 .append("primary key(")
162 .append(TokenFiledConst::FIELD_TOKEN_ID)
163 .append(",")
164 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
165 .append(",")
166 .append(TokenFiledConst::FIELD_DEVICE_ID)
167 .append("))");
168
169 return rdbStore.ExecuteSql(sql);
170 }
171
CreateVersionOneTable(NativeRdb::RdbStore & rdbStore)172 int32_t AccessTokenOpenCallback::CreateVersionOneTable(NativeRdb::RdbStore& rdbStore)
173 {
174 int32_t res = CreateHapTokenInfoTable(rdbStore);
175 if (res != NativeRdb::E_OK) {
176 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table hap_token_info_table.");
177 return res;
178 }
179
180 res = CreateNativeTokenInfoTable(rdbStore);
181 if (res != NativeRdb::E_OK) {
182 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table native_token_info_table.");
183 return res;
184 }
185
186 res = CreatePermissionDefinitionTable(rdbStore);
187 if (res != NativeRdb::E_OK) {
188 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table permission_definition_table.");
189 return res;
190 }
191
192 res = CreatePermissionStateTable(rdbStore);
193 if (res != NativeRdb::E_OK) {
194 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table permission_state_table.");
195 return res;
196 }
197
198 return 0;
199 }
200
CreatePermissionRequestToggleStatusTable(NativeRdb::RdbStore & rdbStore)201 int32_t AccessTokenOpenCallback::CreatePermissionRequestToggleStatusTable(NativeRdb::RdbStore& rdbStore)
202 {
203 std::string tableName;
204 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_REQUEST_TOGGLE_STATUS, tableName);
205
206 std::string sql = "create table if not exists " + tableName;
207 sql.append(" (")
208 .append(TokenFiledConst::FIELD_USER_ID)
209 .append(INTEGER_STR)
210 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
211 .append(TEXT_STR)
212 .append(TokenFiledConst::FIELD_REQUEST_TOGGLE_STATUS)
213 .append(INTEGER_STR)
214 .append("primary key(")
215 .append(TokenFiledConst::FIELD_USER_ID)
216 .append(",")
217 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
218 .append("))");
219
220 return rdbStore.ExecuteSql(sql);
221 }
222
CreateVersionThreeTable(NativeRdb::RdbStore & rdbStore)223 int32_t AccessTokenOpenCallback::CreateVersionThreeTable(NativeRdb::RdbStore& rdbStore)
224 {
225 int32_t res = CreatePermissionRequestToggleStatusTable(rdbStore);
226 if (res != NativeRdb::E_OK) {
227 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table permission_request_toggle_status_table.");
228 return res;
229 }
230
231 return 0;
232 }
233
CreatePermissionExtendValueTable(NativeRdb::RdbStore & rdbStore)234 int32_t AccessTokenOpenCallback::CreatePermissionExtendValueTable(NativeRdb::RdbStore& rdbStore)
235 {
236 std::string tableName;
237 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, tableName);
238
239 std::string sql = "create table if not exists " + tableName;
240 sql.append(" (")
241 .append(TokenFiledConst::FIELD_TOKEN_ID)
242 .append(INTEGER_STR)
243 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
244 .append(TEXT_STR)
245 .append(TokenFiledConst::FIELD_VALUE)
246 .append(TEXT_STR)
247 .append("primary key(")
248 .append(TokenFiledConst::FIELD_TOKEN_ID)
249 .append(",")
250 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
251 .append(",")
252 .append(TokenFiledConst::FIELD_VALUE)
253 .append("))");
254
255 return rdbStore.ExecuteSql(sql);
256 }
257
CreateVersionFiveTable(NativeRdb::RdbStore & rdbStore)258 int32_t AccessTokenOpenCallback::CreateVersionFiveTable(NativeRdb::RdbStore& rdbStore)
259 {
260 int32_t res = CreatePermissionExtendValueTable(rdbStore);
261 if (res != NativeRdb::E_OK) {
262 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table permission_extend_value_table.");
263 return res;
264 }
265
266 return 0;
267 }
268
CreateHapUndefineInfoTable(NativeRdb::RdbStore & rdbStore)269 int32_t AccessTokenOpenCallback::CreateHapUndefineInfoTable(NativeRdb::RdbStore& rdbStore)
270 {
271 std::string tableName;
272 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, tableName);
273
274 std::string sql = "create table if not exists " + tableName;
275 sql.append(" (")
276 .append(TokenFiledConst::FIELD_TOKEN_ID)
277 .append(INTEGER_STR)
278 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
279 .append(TEXT_STR)
280 .append(TokenFiledConst::FIELD_ACL)
281 .append(INTEGER_STR)
282 .append(TokenFiledConst::FIELD_APP_DISTRIBUTION_TYPE)
283 .append(" text, ")
284 .append(TokenFiledConst::FIELD_VALUE)
285 .append(" text, ")
286 .append("primary key(")
287 .append(TokenFiledConst::FIELD_TOKEN_ID)
288 .append(",")
289 .append(TokenFiledConst::FIELD_PERMISSION_NAME)
290 .append("))");
291
292 return rdbStore.ExecuteSql(sql);
293 }
294
CreateSystemConfigTable(NativeRdb::RdbStore & rdbStore)295 int32_t AccessTokenOpenCallback::CreateSystemConfigTable(NativeRdb::RdbStore& rdbStore)
296 {
297 std::string tableName;
298 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG, tableName);
299
300 std::string sql = "create table if not exists " + tableName;
301 sql.append(" (")
302 .append(TokenFiledConst::FIELD_NAME)
303 .append(TEXT_STR)
304 .append(TokenFiledConst::FIELD_VALUE)
305 .append(TEXT_STR)
306 .append("primary key(")
307 .append(TokenFiledConst::FIELD_NAME)
308 .append("))");
309
310 return rdbStore.ExecuteSql(sql);
311 }
312
CreateVersionSixTable(NativeRdb::RdbStore & rdbStore)313 int32_t AccessTokenOpenCallback::CreateVersionSixTable(NativeRdb::RdbStore& rdbStore)
314 {
315 int32_t res = CreateHapUndefineInfoTable(rdbStore);
316 if (res != NativeRdb::E_OK) {
317 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table hap_undefine_info_table.");
318 return res;
319 }
320
321 res = CreateSystemConfigTable(rdbStore);
322 if (res != NativeRdb::E_OK) {
323 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create table system_config_table.");
324 return res;
325 }
326
327 return 0;
328 }
329
OnCreate(NativeRdb::RdbStore & rdbStore)330 int32_t AccessTokenOpenCallback::OnCreate(NativeRdb::RdbStore& rdbStore)
331 {
332 LOGI(ATM_DOMAIN, ATM_TAG, "DB OnCreate.");
333
334 int32_t res = CreateVersionOneTable(rdbStore);
335 if (res != NativeRdb::E_OK) {
336 return res;
337 }
338
339 res = CreateVersionThreeTable(rdbStore);
340 if (res != NativeRdb::E_OK) {
341 return res;
342 }
343
344 res = CreateVersionFiveTable(rdbStore);
345 if (res != NativeRdb::E_OK) {
346 return res;
347 }
348
349 res = CreateVersionSixTable(rdbStore);
350 if (res != NativeRdb::E_OK) {
351 return res;
352 }
353
354 std::string dbBackPath = std::string(DATABASE_PATH) + std::string(DATABASE_NAME_BACK);
355 if (access(dbBackPath.c_str(), NativeRdb::E_OK) != 0) {
356 return 0;
357 }
358
359 // if OnCreate solution found back up db, restore from backup, may be origin db has lost
360 LOGW(ATM_DOMAIN, ATM_TAG, "Detech origin database disappear, restore from backup!");
361
362 res = rdbStore.Restore("");
363 if (res != NativeRdb::E_OK) {
364 LOGE(ATM_DOMAIN, ATM_TAG, "Db restore failed, res is %{public}d.", res);
365 }
366
367 LOGW(ATM_DOMAIN, ATM_TAG, "Database restore from backup success!");
368
369 return 0;
370 }
371
AddAvailableTypeColumn(NativeRdb::RdbStore & rdbStore)372 int32_t AccessTokenOpenCallback::AddAvailableTypeColumn(NativeRdb::RdbStore& rdbStore)
373 {
374 std::string tableName;
375 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_DEF, tableName);
376
377 // check if column available_type exsit
378 std::string checkSql = "SELECT 1 FROM " + tableName + " WHERE " +
379 TokenFiledConst::FIELD_AVAILABLE_TYPE + "=" + std::to_string(ATokenAvailableTypeEnum::NORMAL);
380
381 int32_t checkRes = rdbStore.ExecuteSql(checkSql);
382 LOGI(ATM_DOMAIN, ATM_TAG, "Check result is %{public}d.", checkRes);
383 if (checkRes == NativeRdb::E_OK) {
384 // success means there exsit column available_type in table
385 return NativeRdb::E_OK;
386 }
387
388 // alter table add column
389 std::string sql = "alter table " + tableName + " add column " +
390 TokenFiledConst::FIELD_AVAILABLE_TYPE + " integer default " + std::to_string(ATokenAvailableTypeEnum::NORMAL);
391
392 int32_t res = rdbStore.ExecuteSql(sql);
393 LOGI(ATM_DOMAIN, ATM_TAG, "Insert column result is %{public}d.", res);
394
395 return res;
396 }
397
AddRequestToggleStatusColumn(NativeRdb::RdbStore & rdbStore)398 int32_t AccessTokenOpenCallback::AddRequestToggleStatusColumn(NativeRdb::RdbStore& rdbStore)
399 {
400 std::string tableName;
401 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_REQUEST_TOGGLE_STATUS, tableName);
402
403 // check if column status exsit
404 std::string checkSql = "SELECT 1 FROM " + tableName + " WHERE " +
405 TokenFiledConst::FIELD_REQUEST_TOGGLE_STATUS + "=" + std::to_string(0);
406
407 int32_t checkRes = rdbStore.ExecuteSql(checkSql);
408 LOGI(ATM_DOMAIN, ATM_TAG, "Check result is %{public}d.", checkRes);
409 if (checkRes == NativeRdb::E_OK) {
410 // success means there exsit column status in table
411 return NativeRdb::E_OK;
412 }
413
414 // alter table add column
415 std::string sql = "alter table " + tableName + " add column " +
416 TokenFiledConst::FIELD_REQUEST_TOGGLE_STATUS + " integer default " + std::to_string(0); // 0: close
417
418 int32_t res = rdbStore.ExecuteSql(sql);
419 LOGI(ATM_DOMAIN, ATM_TAG, "Insert column result is %{public}d.", res);
420
421 return res;
422 }
423
AddPermDialogCapColumn(NativeRdb::RdbStore & rdbStore)424 int32_t AccessTokenOpenCallback::AddPermDialogCapColumn(NativeRdb::RdbStore& rdbStore)
425 {
426 std::string tableName;
427 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_HAP_INFO, tableName);
428
429 // check if column perm_dialog_cap_state exsit
430 std::string checkSql = "SELECT 1 FROM " + tableName + " WHERE " +
431 TokenFiledConst::FIELD_FORBID_PERM_DIALOG + "=" + std::to_string(0);
432
433 int32_t checkRes = rdbStore.ExecuteSql(checkSql);
434 LOGI(ATM_DOMAIN, ATM_TAG, "Check result is %{public}d.", checkRes);
435 if (checkRes == NativeRdb::E_OK) {
436 // success means there exsit column perm_dialog_cap_state in table
437 return NativeRdb::E_OK;
438 }
439
440 // alter table add column
441 std::string sql = "alter table " + tableName + " add column " +
442 TokenFiledConst::FIELD_FORBID_PERM_DIALOG + " integer default " + std::to_string(false);
443
444 int32_t res = rdbStore.ExecuteSql(sql);
445 LOGI(ATM_DOMAIN, ATM_TAG, "Insert column result is %{public}d.", res);
446
447 return res;
448 }
449
AddKernelEffectAndHasValueColumn(NativeRdb::RdbStore & rdbStore)450 int32_t AccessTokenOpenCallback::AddKernelEffectAndHasValueColumn(NativeRdb::RdbStore& rdbStore)
451 {
452 std::string tableName;
453 AccessTokenDbUtil::GetTableNameByType(AtmDataType::ACCESSTOKEN_PERMISSION_DEF, tableName);
454
455 // check if column kernel_effect exsit
456 std::string checkSql = "SELECT 1 FROM " + tableName + " WHERE " + TokenFiledConst::FIELD_KERNEL_EFFECT + "=" +
457 std::to_string(0);
458
459 int32_t checkRes = rdbStore.ExecuteSql(checkSql);
460 if (checkRes == NativeRdb::E_OK) {
461 return NativeRdb::E_OK; // success means there exsit column kernel_effect in table
462 }
463
464 // alter table add column kernel_effect
465 std::string executeSql = "alter table " + tableName + " add column " + TokenFiledConst::FIELD_KERNEL_EFFECT +
466 " integer default " + std::to_string(false);
467
468 int32_t executeRes = rdbStore.ExecuteSql(executeSql);
469 if (executeRes != NativeRdb::E_OK) {
470 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to add column kernel_effect to table %{public}s, errCode is %{public}d.",
471 tableName.c_str(), executeRes);
472 return executeRes;
473 }
474
475 LOGI(ATM_DOMAIN, ATM_TAG, "Success to add column kernel_effect to permission_definition_table.");
476
477 // check if column has_value exsit
478 checkSql = "SELECT 1 FROM " + tableName + " WHERE " + TokenFiledConst::FIELD_HAS_VALUE + "=" + std::to_string(0);
479
480 checkRes = rdbStore.ExecuteSql(checkSql);
481 if (checkRes == NativeRdb::E_OK) {
482 return NativeRdb::E_OK; // success means there exsit column has_value in table
483 }
484
485 // alter table add column has_value
486 executeSql = "alter table " + tableName + " add column " + TokenFiledConst::FIELD_HAS_VALUE +
487 " integer default " + std::to_string(0);
488
489 executeRes = rdbStore.ExecuteSql(executeSql);
490 if (executeRes != NativeRdb::E_OK) {
491 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to add column has_value to table %{public}s, errCode is %{public}d.",
492 tableName.c_str(), executeRes);
493 return executeRes;
494 }
495
496 LOGI(ATM_DOMAIN, ATM_TAG, "Success to add column has_value to permission_definition_table.");
497
498 return NativeRdb::E_OK;
499 }
500
OnUpgrade(NativeRdb::RdbStore & rdbStore,int32_t currentVersion,int32_t targetVersion)501 int32_t AccessTokenOpenCallback::OnUpgrade(NativeRdb::RdbStore& rdbStore, int32_t currentVersion, int32_t targetVersion)
502 {
503 LOGI(ATM_DOMAIN, ATM_TAG, "DB OnUpgrade from currentVersion %{public}d to targetVersion %{public}d.",
504 currentVersion, targetVersion);
505
506 int32_t res = 0;
507 switch (currentVersion) { // upgrade to the latest db version in rom, no mather how much the version is
508 case DATABASE_VERSION_1: // 1->2
509 res = AddAvailableTypeColumn(rdbStore);
510 if (res != NativeRdb::E_OK) {
511 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to add column available_type, res is %{public}d.", res);
512 return res;
513 }
514 res = AddPermDialogCapColumn(rdbStore);
515 if (res != NativeRdb::E_OK) {
516 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to add column perm_dialog_cap_state, res is %{public}d.", res);
517 return res;
518 }
519
520 case DATABASE_VERSION_2: // 2->3
521 res = CreateVersionThreeTable(rdbStore);
522 if (res != NativeRdb::E_OK) {
523 return res;
524 }
525
526 case DATABASE_VERSION_3: // 3->4
527 res = AddRequestToggleStatusColumn(rdbStore);
528 if (res != NativeRdb::E_OK) {
529 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to add column status.");
530 return res;
531 }
532
533 case DATABASE_VERSION_4: // 4->5
534 res = CreateVersionFiveTable(rdbStore);
535 if (res != NativeRdb::E_OK) {
536 return res;
537 }
538 res = AddKernelEffectAndHasValueColumn(rdbStore);
539 if (res != NativeRdb::E_OK) {
540 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to add column kernel_effect or has_value.");
541 return res;
542 }
543
544 case DATABASE_VERSION_5: // 5->6
545 res = CreateVersionSixTable(rdbStore);
546 if (res != NativeRdb::E_OK) {
547 return res;
548 }
549
550 default:
551 return NativeRdb::E_OK;
552 }
553
554 return NativeRdb::E_OK;
555 }
556 } // namespace AccessToken
557 } // namespace Security
558 } // namespace OHOS
559