1 /*
2 * Copyright (c) 2022 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 "sqlite3_utils.h"
17
18 #include <securec.h>
19 #include <stdlib.h>
20 #include <string.h>
21
22 #include "softbus_adapter_mem.h"
23 #include "softbus_def.h"
24 #include "softbus_errcode.h"
25 #include "softbus_log.h"
26
27 #define SQL_DEFAULT_LEN 256
28
29 /* The index of database context state */
30 #define DB_STATE_QUERYING (0x1)
31 #define DB_STATE_TRANSACTION (0x1 << 1)
32
33 typedef int32_t (*BindParaCb)(DbContext *ctx, int32_t paraNum, uint8_t *data);
34 typedef int32_t (*QueryDataCb)(DbContext *ctx, uint8_t *data, int32_t idx);
35
36 typedef struct {
37 const char *tableName;
38 const char *sqlForCreate;
39 const char *sqlForInsert;
40 const char *sqlForSearchByKey;
41 const char *sqlForRemoveByKey;
42 BindParaCb insertCb;
43 BindParaCb searchCb;
44 BindParaCb removeCb;
45 QueryDataCb queryDataCb;
46 } SqliteManager;
47
48 /* The default SQL statement */
49 #define SQL_DROP_TABLE "DROP TABLE "
50 #define SQL_REMOVE_ALL_RECORD "DELETE FROM "
51 #define SQL_BEGIN_TRANSACTION "BEGIN TRANSACTION"
52 #define SQL_COMMIT_TRANSACTION "COMMIT TRANSACTION"
53 #define SQL_ROLLBACK_TRANSACTION "ROLLBACK TRANSACTION"
54 #define SQL_SEARCH_IF_TABLE_EXIST "SELECT * FROM sqlite_master WHERE type ='table' AND name = '%s'"
55
56 /**
57 * @brief The SQL statement of TrustedDeviceInfo table.
58 *
59 * This table is used to store the trusted relationship, and its name is TrustedDeviceInfo in {@link DATABASE_NAME}.
60 * After each networking, record the udid value according to the device account.
61 */
62 #define TABLE_NAME_OF_TRUSTED_DEV_INFO "TrustedDeviceInfo"
63 #define SQL_CREATE_TRUSTED_DEV_INFO_TABLE "CREATE TABLE IF NOT EXISTS "TABLE_NAME_OF_TRUSTED_DEV_INFO" \
64 (accountHash TEXT NOT NULL, \
65 udid TEXT NOT NULL, \
66 primary key(accountHash, udid));"
67 #define SQL_INSERT_TRUSTED_DEV_INFO "INSERT INTO "TABLE_NAME_OF_TRUSTED_DEV_INFO" \
68 (accountHash, udid) VALUES (?, ?)"
69 #define SQL_SEARCH_TRUSTED_DEV_INFO_BY_ID "SELECT udid FROM "TABLE_NAME_OF_TRUSTED_DEV_INFO" \
70 WHERE accountHash = ?"
71 #define SQL_REMOVE_TRUSTED_DEV_INFO_BY_ID "DELETE FROM "TABLE_NAME_OF_TRUSTED_DEV_INFO" \
72 WHERE accountHash = ? AND udid = ?"
73
74 static int32_t BindInsertTrustedDevInfoCb(DbContext *ctx, int32_t paraNum, uint8_t *data);
75 static int32_t BindSelectTrustedDevInfoCb(DbContext *ctx, int32_t paraNum, uint8_t *data);
76 static int32_t GetTrustedDevInfoByIdCb(DbContext *ctx, uint8_t *data, int32_t idx);
77
78 static SqliteManager g_sqliteMgr[TABLE_NAME_ID_MAX] = {
79 [TABLE_TRUSTED_DEV_INFO] = {
80 .tableName = TABLE_NAME_OF_TRUSTED_DEV_INFO,
81 .sqlForCreate = SQL_CREATE_TRUSTED_DEV_INFO_TABLE,
82 .sqlForInsert = SQL_INSERT_TRUSTED_DEV_INFO,
83 .sqlForSearchByKey = SQL_SEARCH_TRUSTED_DEV_INFO_BY_ID,
84 .sqlForRemoveByKey = SQL_REMOVE_TRUSTED_DEV_INFO_BY_ID,
85 .insertCb = BindInsertTrustedDevInfoCb,
86 .searchCb = BindSelectTrustedDevInfoCb,
87 .removeCb = BindInsertTrustedDevInfoCb,
88 .queryDataCb = GetTrustedDevInfoByIdCb,
89 },
90 };
91
GetTrustedDevInfoByIdCb(DbContext * ctx,uint8_t * data,int32_t idx)92 NO_SANITIZE("cfi") static int32_t GetTrustedDevInfoByIdCb(DbContext *ctx, uint8_t *data, int32_t idx)
93 {
94 int32_t i = 0;
95 char *info = (char *)data + idx * UDID_BUF_LEN;
96
97 if (GetQueryResultColText(ctx, i, info, UDID_BUF_LEN) != SOFTBUS_OK) {
98 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "get query result failed");
99 return SOFTBUS_ERR;
100 }
101 return SOFTBUS_OK;
102 }
103
BindInsertTrustedDevInfoCb(DbContext * ctx,int32_t paraNum,uint8_t * data)104 static int32_t BindInsertTrustedDevInfoCb(DbContext *ctx, int32_t paraNum, uint8_t *data)
105 {
106 int32_t rc;
107 int32_t idx = 1;
108
109 if (data == NULL) {
110 return SQLITE_ERROR;
111 }
112 const TrustedDevInfoRecord *record = (TrustedDevInfoRecord *)data;
113 rc = BindParaText(ctx, idx, record->accountHexHash, strlen(record->accountHexHash));
114 if (rc != SQLITE_OK) {
115 return rc;
116 }
117 return BindParaText(ctx, ++idx, record->udid, strlen(record->udid));
118 }
119
BindSelectTrustedDevInfoCb(DbContext * ctx,int32_t paraNum,uint8_t * data)120 static int32_t BindSelectTrustedDevInfoCb(DbContext *ctx, int32_t paraNum, uint8_t *data)
121 {
122 int32_t idx = 1;
123
124 if (data == NULL) {
125 return SQLITE_ERROR;
126 }
127 return BindParaText(ctx, idx, (char *)data, strlen((char *)data));
128 }
129
ExecuteSql(DbContext * ctx,const char * sql,uint32_t len,BindParaCb cb,uint8_t * data)130 NO_SANITIZE("cfi") static int32_t ExecuteSql(DbContext *ctx, const char *sql, uint32_t len, BindParaCb cb,
131 uint8_t *data)
132 {
133 int32_t paraNum;
134 int32_t rc;
135
136 if (sql == NULL || sql[0] == '\0') {
137 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "execute sql get invalid param");
138 return SQLITE_ERROR;
139 }
140 rc = sqlite3_prepare_v2(ctx->db, sql, len, &ctx->stmt, NULL);
141 if (rc != SQLITE_OK || ctx->stmt == NULL) {
142 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_prepare_v2 failed, %s", sqlite3_errmsg(ctx->db));
143 return sqlite3_errcode(ctx->db);
144 }
145 paraNum = sqlite3_bind_parameter_count(ctx->stmt);
146 if (paraNum <= 0) {
147 rc = sqlite3_step(ctx->stmt);
148 if (rc != SQLITE_ROW && rc != SQLITE_DONE) {
149 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_step <= 0 failed, %s", sqlite3_errmsg(ctx->db));
150 }
151 return rc;
152 }
153 if (paraNum > 0 && cb == NULL) {
154 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "need cd for binding parameter");
155 (void)sqlite3_finalize(ctx->stmt);
156 ctx->stmt = NULL;
157 return SQLITE_ERROR;
158 }
159 rc = cb(ctx, paraNum, data);
160 if (rc != SQLITE_OK) {
161 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "binding parameter cd fail");
162 (void)sqlite3_finalize(ctx->stmt);
163 ctx->stmt = NULL;
164 return sqlite3_errcode(ctx->db);
165 }
166 rc = sqlite3_step(ctx->stmt);
167 if (rc != SQLITE_ROW && rc != SQLITE_DONE) {
168 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_step > 0 failed, %s", sqlite3_errmsg(ctx->db));
169 }
170 return rc;
171 }
172
QueryData(DbContext * ctx,const char * sql,uint32_t len,BindParaCb cb,uint8_t * data)173 NO_SANITIZE("cfi") static int32_t QueryData(DbContext *ctx, const char *sql, uint32_t len, BindParaCb cb, uint8_t *data)
174 {
175 int32_t rc;
176
177 rc = ExecuteSql(ctx, sql, len, cb, data);
178 if (rc != SQLITE_ROW) {
179 (void)sqlite3_finalize(ctx->stmt);
180 ctx->stmt = NULL;
181 } else {
182 ctx->state |= DB_STATE_QUERYING;
183 }
184 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_DBG, "QueryData done, state: %d", ctx->state);
185 return rc;
186 }
187
QueryDataNext(DbContext * ctx)188 NO_SANITIZE("cfi") static int32_t QueryDataNext(DbContext *ctx)
189 {
190 int32_t rc;
191
192 rc = sqlite3_step(ctx->stmt);
193 if (rc != SQLITE_ROW) {
194 ctx->state &= ~DB_STATE_QUERYING;
195 (void)sqlite3_finalize(ctx->stmt);
196 ctx->stmt = NULL;
197 }
198 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_DBG, "QueryDataNext done, state: %d", ctx->state);
199 return rc;
200 }
201
CheckDbContextParam(const DbContext * ctx)202 static bool CheckDbContextParam(const DbContext *ctx)
203 {
204 if (ctx == NULL) {
205 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
206 return false;
207 }
208 if (ctx->db == NULL || ctx->stmt != NULL) {
209 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid db context state");
210 return false;
211 }
212 return true;
213 }
214
CheckBindOrQueryParam(const DbContext * ctx)215 static bool CheckBindOrQueryParam(const DbContext *ctx)
216 {
217 if (ctx == NULL) {
218 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid db context parameters");
219 return false;
220 }
221 if (ctx->db == NULL || ctx->stmt == NULL) {
222 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid db context state");
223 return false;
224 }
225 return true;
226 }
227
OpenDatabase(DbContext ** ctx)228 NO_SANITIZE("cfi") int32_t OpenDatabase(DbContext **ctx)
229 {
230 int32_t rc;
231 sqlite3 *sqlite = NULL;
232
233 if (ctx == NULL) {
234 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
235 return SOFTBUS_INVALID_PARAM;
236 }
237 rc = sqlite3_open_v2(DATABASE_NAME, &sqlite, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
238 SQLITE_OPEN_NOMUTEX, NULL);
239 if (rc != SQLITE_OK || sqlite == NULL) {
240 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_open_v2 fail: %s", sqlite3_errmsg(sqlite));
241 (void)sqlite3_close_v2(sqlite);
242 return SOFTBUS_ERR;
243 }
244 *ctx = (DbContext *)SoftBusCalloc(sizeof(DbContext));
245 if (*ctx == NULL) {
246 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "malloc DbContext fail");
247 (void)sqlite3_close_v2(sqlite);
248 return SOFTBUS_MALLOC_ERR;
249 } else {
250 (*ctx)->db = sqlite;
251 }
252 return SOFTBUS_OK;
253 }
254
CloseDatabase(DbContext * ctx)255 NO_SANITIZE("cfi") int32_t CloseDatabase(DbContext *ctx)
256 {
257 if (!CheckDbContextParam(ctx)) {
258 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
259 return SOFTBUS_INVALID_PARAM;
260 }
261 (void)sqlite3_close_v2(ctx->db);
262 SoftBusFree(ctx);
263 return SOFTBUS_OK;
264 }
265
CreateTable(DbContext * ctx,TableNameID id)266 NO_SANITIZE("cfi") int32_t CreateTable(DbContext *ctx, TableNameID id)
267 {
268 int32_t rc;
269 char *errMsg = NULL;
270
271 if (!CheckDbContextParam(ctx)) {
272 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
273 return SOFTBUS_INVALID_PARAM;
274 }
275 const char *sql = g_sqliteMgr[id].sqlForCreate;
276 if (sql == NULL || sql[0] == '\0') {
277 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "createsql is not impl");
278 return SOFTBUS_ERR;
279 }
280 rc = sqlite3_exec(ctx->db, sql, NULL, NULL, &errMsg);
281 if (rc != SQLITE_OK && errMsg != NULL) {
282 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite_exec fail: %s", errMsg);
283 sqlite3_free(errMsg);
284 }
285 return rc == SQLITE_OK ? SOFTBUS_OK : SOFTBUS_ERR;
286 }
287
DeleteTable(DbContext * ctx,TableNameID id)288 NO_SANITIZE("cfi") int32_t DeleteTable(DbContext *ctx, TableNameID id)
289 {
290 int32_t rc;
291 char sql[SQL_DEFAULT_LEN] = {0};
292
293 if (!CheckDbContextParam(ctx)) {
294 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
295 return SOFTBUS_INVALID_PARAM;
296 }
297 rc = sprintf_s(sql, SQL_DEFAULT_LEN, "%s%s", SQL_DROP_TABLE, g_sqliteMgr[id].tableName);
298 if (rc < 0) {
299 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sprintf_s sql fail");
300 return SOFTBUS_ERR;
301 }
302 rc = ExecuteSql(ctx, sql, strlen(sql), NULL, NULL);
303 if (rc != SQLITE_DONE) {
304 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "delete table fail");
305 rc = SOFTBUS_ERR;
306 } else {
307 rc = SOFTBUS_OK;
308 }
309 (void)sqlite3_finalize(ctx->stmt);
310 ctx->stmt = NULL;
311 return rc;
312 }
313
CheckTableExist(DbContext * ctx,TableNameID id,bool * isExist)314 NO_SANITIZE("cfi") int32_t CheckTableExist(DbContext *ctx, TableNameID id, bool *isExist)
315 {
316 int32_t rc;
317 char sql[SQL_DEFAULT_LEN] = {0};
318
319 if (!CheckDbContextParam(ctx) || isExist == NULL) {
320 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
321 return SOFTBUS_INVALID_PARAM;
322 }
323 rc = sprintf_s(sql, SQL_DEFAULT_LEN, SQL_SEARCH_IF_TABLE_EXIST, g_sqliteMgr[id].tableName);
324 if (rc < 0) {
325 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sprintf_s sql fail");
326 return SOFTBUS_ERR;
327 }
328 *isExist = false;
329 rc = ExecuteSql(ctx, sql, strlen(sql), NULL, NULL);
330 if (rc == SQLITE_ROW && sqlite3_column_count(ctx->stmt) != 0) {
331 *isExist = true;
332 }
333 (void)sqlite3_finalize(ctx->stmt);
334 ctx->stmt = NULL;
335 return SOFTBUS_OK;
336 }
337
InsertRecord(DbContext * ctx,TableNameID id,uint8_t * data)338 NO_SANITIZE("cfi") int32_t InsertRecord(DbContext *ctx, TableNameID id, uint8_t *data)
339 {
340 int32_t rc;
341
342 if (!CheckDbContextParam(ctx) || data == NULL) {
343 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
344 return SOFTBUS_INVALID_PARAM;
345 }
346 rc = ExecuteSql(ctx, g_sqliteMgr[id].sqlForInsert, strlen(g_sqliteMgr[id].sqlForInsert),
347 g_sqliteMgr[id].insertCb, data);
348 if (rc != SQLITE_DONE) {
349 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "insert data failed");
350 rc = SOFTBUS_ERR;
351 } else {
352 rc = SOFTBUS_OK;
353 }
354 (void)sqlite3_finalize(ctx->stmt);
355 ctx->stmt = NULL;
356 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_DBG, "insert data done");
357 return rc;
358 }
359
RemoveRecordByKey(DbContext * ctx,TableNameID id,uint8_t * data)360 NO_SANITIZE("cfi") int32_t RemoveRecordByKey(DbContext *ctx, TableNameID id, uint8_t *data)
361 {
362 int32_t rc;
363
364 if (!CheckDbContextParam(ctx) || data == NULL) {
365 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
366 return SOFTBUS_INVALID_PARAM;
367 }
368 rc = ExecuteSql(ctx, g_sqliteMgr[id].sqlForRemoveByKey, strlen(g_sqliteMgr[id].sqlForRemoveByKey),
369 g_sqliteMgr[id].removeCb, data);
370 if (rc != SQLITE_DONE) {
371 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "remove data failed");
372 rc = SOFTBUS_ERR;
373 } else {
374 rc = SOFTBUS_OK;
375 }
376 (void)sqlite3_finalize(ctx->stmt);
377 ctx->stmt = NULL;
378 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_DBG, "remove data done");
379 return rc;
380 }
381
RemoveAllRecord(DbContext * ctx,TableNameID id)382 NO_SANITIZE("cfi") int32_t RemoveAllRecord(DbContext *ctx, TableNameID id)
383 {
384 int32_t rc;
385 char sql[SQL_DEFAULT_LEN] = {0};
386
387 if (!CheckDbContextParam(ctx)) {
388 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
389 return SOFTBUS_INVALID_PARAM;
390 }
391 rc = sprintf_s(sql, SQL_DEFAULT_LEN, "%s%s", SQL_REMOVE_ALL_RECORD, g_sqliteMgr[id].tableName);
392 if (rc < 0) {
393 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sprintf_s sql fail");
394 return SOFTBUS_ERR;
395 }
396 rc = ExecuteSql(ctx, sql, strlen(sql), NULL, NULL);
397 if (rc != SQLITE_DONE) {
398 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "remove data failed");
399 rc = SOFTBUS_ERR;
400 } else {
401 rc = SOFTBUS_OK;
402 }
403 (void)sqlite3_finalize(ctx->stmt);
404 ctx->stmt = NULL;
405 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_DBG, "remove data done");
406 return rc;
407 }
408
GetRecordNumByKey(DbContext * ctx,TableNameID id,uint8_t * data)409 NO_SANITIZE("cfi") int32_t GetRecordNumByKey(DbContext *ctx, TableNameID id, uint8_t *data)
410 {
411 int32_t rc;
412 int32_t num = 0;
413
414 if (!CheckDbContextParam(ctx)) {
415 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
416 return 0;
417 }
418 rc = QueryData(ctx, g_sqliteMgr[id].sqlForSearchByKey, strlen(g_sqliteMgr[id].sqlForSearchByKey),
419 g_sqliteMgr[id].searchCb, data);
420 if (rc != SQLITE_ROW) {
421 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "find no match data");
422 return 0;
423 }
424 do {
425 num++;
426 rc = QueryDataNext(ctx);
427 } while (rc == SQLITE_ROW);
428 if (rc != SQLITE_DONE) {
429 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "GetQueryDataNum failed");
430 return 0;
431 }
432 return num;
433 }
434
QueryRecordByKey(DbContext * ctx,TableNameID id,uint8_t * data,uint8_t ** replyInfo,int infoNum)435 NO_SANITIZE("cfi") int32_t QueryRecordByKey(DbContext *ctx, TableNameID id, uint8_t *data,
436 uint8_t **replyInfo, int infoNum)
437 {
438 int32_t rc;
439 int32_t num = 0;
440
441 if (!CheckDbContextParam(ctx) || replyInfo == NULL) {
442 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
443 return SOFTBUS_INVALID_PARAM;
444 }
445 rc = QueryData(ctx, g_sqliteMgr[id].sqlForSearchByKey, strlen(g_sqliteMgr[id].sqlForSearchByKey),
446 g_sqliteMgr[id].searchCb, data);
447 if (rc != SQLITE_ROW) {
448 return SOFTBUS_ERR;
449 }
450 do {
451 if (g_sqliteMgr[id].queryDataCb != NULL) {
452 g_sqliteMgr[id].queryDataCb(ctx, *replyInfo, num);
453 }
454 rc = QueryDataNext(ctx);
455 num++;
456 } while (rc == SQLITE_ROW && num < infoNum);
457 if (rc != SQLITE_DONE) {
458 if (rc == SQLITE_ROW) {
459 ctx->state &= ~DB_STATE_QUERYING;
460 (void)sqlite3_finalize(ctx->stmt);
461 ctx->stmt = NULL;
462 }
463 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "QueryData failed");
464 return SOFTBUS_ERR;
465 }
466 return SOFTBUS_OK;
467 }
468
OpenTransaction(DbContext * ctx)469 NO_SANITIZE("cfi") int32_t OpenTransaction(DbContext *ctx)
470 {
471 int32_t rc;
472
473 if (!CheckDbContextParam(ctx)) {
474 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
475 return SOFTBUS_INVALID_PARAM;
476 }
477 if ((ctx->state & DB_STATE_TRANSACTION) != 0) {
478 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "already open the transaction: %d", ctx->state);
479 return SOFTBUS_OK;
480 }
481 rc = ExecuteSql(ctx, SQL_BEGIN_TRANSACTION, strlen(SQL_BEGIN_TRANSACTION), NULL, NULL);
482 if (rc != SQLITE_DONE) {
483 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "open transaction failed");
484 rc = SOFTBUS_ERR;
485 } else {
486 ctx->state |= DB_STATE_TRANSACTION;
487 rc = SOFTBUS_OK;
488 }
489 (void)sqlite3_finalize(ctx->stmt);
490 ctx->stmt = NULL;
491 return rc;
492 }
493
CloseTransaction(DbContext * ctx,CloseTransactionType type)494 NO_SANITIZE("cfi") int32_t CloseTransaction(DbContext *ctx, CloseTransactionType type)
495 {
496 int32_t rc;
497 const char *sql = SQL_COMMIT_TRANSACTION;
498
499 if (!CheckDbContextParam(ctx)) {
500 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
501 return SOFTBUS_INVALID_PARAM;
502 }
503 if ((ctx->state & DB_STATE_TRANSACTION) == 0) {
504 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "the transaction already closed: %d", ctx->state);
505 return SOFTBUS_OK;
506 }
507 if (type == CLOSE_TRANS_ROLLBACK) {
508 sql = SQL_ROLLBACK_TRANSACTION;
509 }
510 rc = ExecuteSql(ctx, sql, strlen(sql), NULL, NULL);
511 if (rc != SQLITE_DONE) {
512 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "close transaction failed");
513 rc = SOFTBUS_ERR;
514 } else {
515 rc = SOFTBUS_OK;
516 }
517 ctx->state &= ~DB_STATE_TRANSACTION;
518 (void)sqlite3_finalize(ctx->stmt);
519 ctx->stmt = NULL;
520 return rc;
521 }
522
EncryptedDb(DbContext * ctx,const uint8_t * password,uint32_t len)523 NO_SANITIZE("cfi") int32_t EncryptedDb(DbContext *ctx, const uint8_t *password, uint32_t len)
524 {
525 int32_t rc;
526
527 if (!CheckDbContextParam(ctx) || password == NULL) {
528 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
529 return SOFTBUS_INVALID_PARAM;
530 }
531 rc = sqlite3_key(ctx->db, password, len);
532 if (rc != SQLITE_OK) {
533 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "config key failed: %s", sqlite3_errmsg(ctx->db));
534 return SOFTBUS_ERR;
535 }
536 return SOFTBUS_OK;
537 }
538
UpdateDbPassword(DbContext * ctx,const uint8_t * password,uint32_t len)539 NO_SANITIZE("cfi") int32_t UpdateDbPassword(DbContext *ctx, const uint8_t *password, uint32_t len)
540 {
541 int32_t rc;
542
543 if (!CheckDbContextParam(ctx) || password == NULL) {
544 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
545 return SOFTBUS_INVALID_PARAM;
546 }
547 rc = sqlite3_rekey(ctx->db, password, len);
548 if (rc != SQLITE_OK) {
549 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "update key failed: %s", sqlite3_errmsg(ctx->db));
550 return SOFTBUS_ERR;
551 }
552 return SOFTBUS_OK;
553 }
554
BindParaInt(DbContext * ctx,int32_t idx,int32_t value)555 NO_SANITIZE("cfi") int32_t BindParaInt(DbContext *ctx, int32_t idx, int32_t value)
556 {
557 int32_t rc;
558
559 if (!CheckBindOrQueryParam(ctx) || idx <= 0) {
560 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
561 return SQLITE_ERROR;
562 }
563 rc = sqlite3_bind_int(ctx->stmt, idx, value);
564 if (rc != SQLITE_OK) {
565 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_bind_int failed: %s", sqlite3_errmsg(ctx->db));
566 }
567 return rc;
568 }
569
BindParaInt64(DbContext * ctx,int32_t idx,int64_t value)570 NO_SANITIZE("cfi") int32_t BindParaInt64(DbContext *ctx, int32_t idx, int64_t value)
571 {
572 int32_t rc;
573
574 if (!CheckBindOrQueryParam(ctx) || idx <= 0) {
575 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
576 return SQLITE_ERROR;
577 }
578 rc = sqlite3_bind_int64(ctx->stmt, idx, value);
579 if (rc != SQLITE_OK) {
580 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_bind_int64 failed: %s", sqlite3_errmsg(ctx->db));
581 }
582 return rc;
583 }
584
BindParaText(DbContext * ctx,int32_t idx,const char * value,uint32_t valueLen)585 NO_SANITIZE("cfi") int32_t BindParaText(DbContext *ctx, int32_t idx, const char *value, uint32_t valueLen)
586 {
587 int32_t rc;
588
589 if (!CheckBindOrQueryParam(ctx) || idx <= 0 || value == NULL || value[0] == '\0' || strlen(value) != valueLen) {
590 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
591 return SQLITE_ERROR;
592 }
593 rc = sqlite3_bind_text(ctx->stmt, idx, value, valueLen, SQLITE_STATIC);
594 if (rc != SQLITE_OK) {
595 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_bind_text failed: %s", sqlite3_errmsg(ctx->db));
596 }
597 return rc;
598 }
599
BindParaDouble(DbContext * ctx,int32_t idx,double value)600 NO_SANITIZE("cfi") int32_t BindParaDouble(DbContext *ctx, int32_t idx, double value)
601 {
602 int32_t rc;
603
604 if (!CheckBindOrQueryParam(ctx) || idx <= 0) {
605 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
606 return SQLITE_ERROR;
607 }
608 rc = sqlite3_bind_double(ctx->stmt, idx, value);
609 if (rc != SQLITE_OK) {
610 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "sqlite3_bind_double failed: %s", sqlite3_errmsg(ctx->db));
611 }
612 return rc;
613 }
614
GetQueryResultColCount(DbContext * ctx,int32_t * count)615 NO_SANITIZE("cfi") int32_t GetQueryResultColCount(DbContext *ctx, int32_t *count)
616 {
617 if (!CheckBindOrQueryParam(ctx)) {
618 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
619 return SOFTBUS_INVALID_PARAM;
620 }
621 if ((ctx->state & DB_STATE_QUERYING) == 0) {
622 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "the query already closed: %d", ctx->state);
623 return SOFTBUS_ERR;
624 }
625 *count = sqlite3_column_count(ctx->stmt);
626 return SOFTBUS_OK;
627 }
628
GetQueryResultColText(DbContext * ctx,int32_t iCol,char * text,uint32_t len)629 NO_SANITIZE("cfi") int32_t GetQueryResultColText(DbContext *ctx, int32_t iCol, char *text, uint32_t len)
630 {
631 const unsigned char *result;
632
633 if (!CheckBindOrQueryParam(ctx) || iCol < 0 || text == NULL) {
634 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
635 return SOFTBUS_INVALID_PARAM;
636 }
637 if ((ctx->state & DB_STATE_QUERYING) == 0) {
638 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "the query already closed: %d", ctx->state);
639 return SOFTBUS_ERR;
640 }
641 if (sqlite3_column_type(ctx->stmt, iCol) != SQLITE_TEXT) {
642 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "column type not match");
643 return SOFTBUS_ERR;
644 }
645 result = sqlite3_column_text(ctx->stmt, iCol);
646 if (strcpy_s(text, len, (const char *)result) != EOK) {
647 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "strcpy_s fail");
648 return SOFTBUS_ERR;
649 }
650 return SOFTBUS_OK;
651 }
652
GetQueryResultColInt(DbContext * ctx,int32_t iCol,int32_t * value)653 NO_SANITIZE("cfi") int32_t GetQueryResultColInt(DbContext *ctx, int32_t iCol, int32_t *value)
654 {
655 if (!CheckBindOrQueryParam(ctx) || iCol < 0) {
656 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
657 return SOFTBUS_INVALID_PARAM;
658 }
659 if ((ctx->state & DB_STATE_QUERYING) == 0) {
660 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "the query already closed: %d", ctx->state);
661 return SOFTBUS_ERR;
662 }
663 if (sqlite3_column_type(ctx->stmt, iCol) != SQLITE_INTEGER) {
664 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "column type not match");
665 return SOFTBUS_ERR;
666 }
667 *value = sqlite3_column_int(ctx->stmt, iCol);
668 return SOFTBUS_OK;
669 }
670
GetQueryResultColInt64(DbContext * ctx,int32_t iCol,int64_t * value)671 NO_SANITIZE("cfi") int32_t GetQueryResultColInt64(DbContext *ctx, int32_t iCol, int64_t *value)
672 {
673 if (!CheckBindOrQueryParam(ctx) || iCol < 0) {
674 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
675 return SOFTBUS_INVALID_PARAM;
676 }
677 if ((ctx->state & DB_STATE_QUERYING) == 0) {
678 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "the query already closed: %d", ctx->state);
679 return SOFTBUS_ERR;
680 }
681 if (sqlite3_column_type(ctx->stmt, iCol) != SQLITE_INTEGER) {
682 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "column type not match");
683 return SOFTBUS_ERR;
684 }
685 *value = sqlite3_column_int64(ctx->stmt, iCol);
686 return SOFTBUS_OK;
687 }
688
GetQueryResultColDouble(DbContext * ctx,int32_t iCol,double * value)689 NO_SANITIZE("cfi") int32_t GetQueryResultColDouble(DbContext *ctx, int32_t iCol, double *value)
690 {
691 if (!CheckBindOrQueryParam(ctx) || iCol < 0) {
692 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "invalid parameters");
693 return SOFTBUS_INVALID_PARAM;
694 }
695 if ((ctx->state & DB_STATE_QUERYING) == 0) {
696 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "the query already closed: %d", ctx->state);
697 return SOFTBUS_ERR;
698 }
699 if (sqlite3_column_type(ctx->stmt, iCol) != SQLITE_FLOAT) {
700 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "column type not match");
701 return SOFTBUS_ERR;
702 }
703 *value = sqlite3_column_double(ctx->stmt, iCol);
704 return SOFTBUS_OK;
705 }
706