matter/libmp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 1 Activity

new: better way of handling files db

Browse Source
This commit is contained in:
ngn
2024-07-06 03:48:23 +03:00
parent 98e5c861df
commit 3a6f1c06c0
15 changed files with 396 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/ctx/ctx.c
View File

@ -20,8 +20,8 @@ void lm_ctx_init(lm_ctx_t *ctx) {
}
bool lm_ctx_set_temp(lm_ctx_t *ctx, char *dir){
if(!exists(dir)){
lm_error_set(LM_ERR_CtxTempFail);
if(!mkdir_ifnot(dir)){
lm_error_set(LM_ERR_CtxTempFailMkdir);
return false;
}

6
src/ctx/database.c
View File

@ -24,7 +24,7 @@ bool lm_ctx_database_is_installed(lm_ctx_t *ctx, lm_pkg_t *pkg, bool check_versi
if(NULL == ctx->db)
return false;
if(!lm_database_find(ctx->db, &found, pkg->name))
if(!lm_database_package_find(ctx->db, &found, pkg->name))
return false; // error set by function
if(check_version && !eq(found.version, pkg->version))
@ -43,7 +43,7 @@ bool lm_ctx_database_find(lm_ctx_t *ctx, lm_pkg_t *pkg, char *name){
return false; // error set by function
lm_error_clear();
return lm_database_find(ctx->db, pkg, name);
return lm_database_package_find(ctx->db, pkg, name);
}
bool lm_ctx_database_foreach(lm_ctx_t *ctx, lm_ctx_database_callback_t callback, void *data){
@ -57,7 +57,7 @@ bool lm_ctx_database_foreach(lm_ctx_t *ctx, lm_ctx_database_callback_t callback,
lm_pkg_t pkg;
while(lm_database_next(ctx->db, &pkg)){
while(lm_database_package_next(ctx->db, &pkg)){
if(!callback(ctx, &pkg, data))
break;
}

2
src/ctx/install.c
View File

@ -18,7 +18,7 @@ bool lm_ctx_install(lm_ctx_t *ctx, lm_pkg_t *pkg, lm_ctx_install_callback_t call
return false;
}
if(mkdir_ifnot(ctx->temp)){
if(!mkdir_ifnot(ctx->temp)){
lm_error_set(LM_ERR_CtxTempFailMkdir);
return false;
}

2
src/ctx/update.c
View File

@ -19,7 +19,7 @@ lm_ctx_update_list_t *lm_ctx_update(lm_ctx_t *ctx){
lm_pkg_t *pkg = malloc(sizeof(lm_pkg_t));
while(lm_database_next(ctx->db, pkg)){
while(lm_database_package_next(ctx->db, pkg)){
if(NULL == list->packages)
list->packages = malloc(sizeof(lm_pkg_t*));
else

32
src/database/changes.c
View File

@ -3,6 +3,7 @@
#include "../../include/util.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -13,10 +14,13 @@ bool lm_database_changes_update(lm_database_t *db, lm_pkg_t *pkg, char *file){
return false;
}
char changes_file[strlen(db->dir)+strlen(pkg->name)+20];
join_multiple(changes_file, db->dir, pkg->name, "changes");
char changes_file[strlen(pkg->name)+20];
sprintf(changes_file, "%s_changes", pkg->name);
if(!copy_file(changes_file, file))
char changes_path[strlen(db->dir)+sizeof(changes_file)];
join(changes_path, db->dir, changes_file);
if(!copy_file(changes_path, file))
return false; // error set by function
return true;
@ -28,10 +32,13 @@ bool lm_database_changes_del(lm_database_t *db, lm_pkg_t *pkg){
return false;
}
char changes_file[strlen(db->dir)+strlen(pkg->name)+20];
join_multiple(changes_file, db->dir, pkg->name, "changes");
char changes_file[strlen(pkg->name)+20];
sprintf(changes_file, "%s_changes", pkg->name);
if(unlink(changes_file) < 0 && errno != ENOENT){
char changes_path[strlen(db->dir)+sizeof(changes_file)];
join(changes_path, db->dir, changes_file);
if(unlink(changes_path) < 0 && errno != ENOENT){
lm_error_set(LM_ERR_DbChangesUnlinkFail);
return false;
}
@ -40,13 +47,16 @@ bool lm_database_changes_del(lm_database_t *db, lm_pkg_t *pkg){
}
char *lm_database_changes_get(lm_database_t *db, lm_pkg_t *pkg){
char *changes_file = malloc(strlen(db->dir)+strlen(pkg->name)+20);
join_multiple(changes_file, db->dir, pkg->name, "changes");
char changes_file[strlen(pkg->name)+20];
sprintf(changes_file, "%s_changes", pkg->name);
if(!exists(changes_file)){
free(changes_file);
char *changes_path = malloc(strlen(db->dir)+sizeof(changes_file));
join(changes_path, db->dir, changes_file);
if(!exists(changes_path)){
free(changes_path);
return NULL;
}
return changes_file;
return changes_path;
}

76
src/database/database.c
View File

@ -9,16 +9,50 @@
#include <strings.h>
char *queries[] = {
// QUERY_CREATE_PACKAGE_TABLE
"CREATE TABLE IF NOT EXISTS packages (" \
" name TEXT PRIMARY KEY NOT NULL," \
" desc TEXT NOT NULL," \
" version TEXT NOT NULL," \
" size INT NOT NULL," \
" depends TEXT NOT NULL);",
// QUERY_INSERT_PACKAGE_SINGLE
"INSERT INTO packages VALUES (?, ?, ?, ?, ?)",
// QUERY_SELECT_PACKAGE_SINGLE
"SELECT * FROM packages WHERE name = '?'",
"DELETE from packages WHERE name = '?'",
// QUERY_DELETE_PACKAGE_SINGLE
"DELETE FROM packages WHERE name = '?'",
// QUERY_SELECT_PACKAGE_ALL
"SELECT * FROM packages",
// QUERY_CREATE_FILE_TABLE
"CREATE TABLE IF NOT EXISTS files (" \
" path TEXT PRIMARY KEY NOT NULL," \
" hash TEXT NOT NULL," \
" keep INT NOT NULL," \
" package TEXT NOT NULL);"
// QUERY_INSERT_FILE_SINGLE
"INSERT INTO files VALUES (?, ?, ?, ?)",
// QUERY_DELETE_FILE_ALL
"DELETE FROM files WHERE package = '?'",
// QUERY_SELECT_FILE_SINGLE
"SELECT * FROM files WHERE path = '?'",
// QUERY_SELECT_FILE_ALL
"SELECT * FROM files WHERE package = '?'",
// QUERY_UPDATE_FILE_1
"UPDATE files SET keep = 1 WHERE path = '?'",
// QUERY_UPDATE_FILE_2
"UPDATE files SET keep = 0 WHERE path = '?'",
};
lm_database_t *lm_database_new(char *path){
@ -31,30 +65,54 @@ lm_database_t *lm_database_new(char *path){
return NULL;
}
char dbfile[strlen(path)+20];
join(dbfile, path, "packages.db");
if(!exists(path) && !mkdir_ifnot(path)){
lm_error_set(LM_ERR_DbCantAccess);
return NULL;
}
size_t pathlen = strlen(path);
char packagesdb[pathlen+20], filesdb[pathlen+20];
join(packagesdb, path, "packages.db");
join(filesdb, path, "files.db");
if(sqlite3_open(dbfile, &db->sql)){
pdebug(__func__, "(%s) failed to open databse: %s", path, sqlite3_errmsg(db->sql));
if(sqlite3_open(packagesdb, &db->packages_db)){
pdebug(__func__, "(%s) failed to open databse: %s", path, sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlOpenFail);
return NULL;
}
if(sqlite3_open(filesdb, &db->files_db)){
pdebug(__func__, "(%s) failed to open databse: %s", path, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlOpenFail);
return NULL;
}
if(sqlite3_exec(db->sql, queries[QUERY_CREATE_TABLE], NULL, 0, &err) != SQLITE_OK){
if(sqlite3_exec(db->packages_db, queries[QUERY_CREATE_PACKAGE_TABLE], NULL, 0, &err) != SQLITE_OK){
pdebug(__func__, "(%s) failed to create packages table: %s", path, err);
lm_error_set(LM_ERR_DbSqlCreateFail);
sqlite3_free(err);
}
if(sqlite3_exec(db->files_db, queries[QUERY_CREATE_FILE_TABLE], NULL, 0, &err) != SQLITE_OK){
pdebug(__func__, "(%s) failed to create files table: %s", path, err);
lm_error_set(LM_ERR_DbSqlCreateFail);
sqlite3_free(err);
}
db->dir = strdup(path);
return db;
}
void lm_database_free(lm_database_t *db){
if(NULL != db->st)
sqlite3_finalize(db->st);
if(NULL != db->packages_st)
sqlite3_finalize(db->packages_st);
sqlite3_close(db->sql);
if(NULL != db->files_st)
sqlite3_finalize(db->files_st);
sqlite3_close(db->packages_db);
sqlite3_close(db->files_db);
free(db->dir);
lm_pkg_t *cur = db->pkg, *prev = NULL;

259
src/database/files.c
View File

@ -10,166 +10,171 @@
#include <stdlib.h>
#include <string.h>
bool lm_database_files_foreach(lm_database_t *db, lm_pkg_t *pkg, lm_database_files_eachfunc_t func, void *data){
if(NULL == db || NULL == pkg || NULL == func){
bool lm_database_files_matches(lm_database_t *db, char *path, char *hash){
char *hashdb = NULL;
bool ret = false;
if(NULL == db || NULL == path || NULL == hash){
lm_error_set(LM_ERR_ArgNULL);
goto end;
}
if(sqlite3_prepare(db->files_db, queries[QUERY_SELECT_FILE_SINGLE], strlen(queries[QUERY_SELECT_FILE_SINGLE]), &db->files_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for selecting %s: %s", path, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
sqlite3_bind_text(db->files_st, 1, path, strlen(path), SQLITE_STATIC);
if(sqlite3_step(db->files_st) != SQLITE_DONE){
pdebug(__func__, "failed to execute select statement for selecting %s: %s", path, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlSelectFail);
goto end;
}
hashdb = (char*)sqlite3_column_text(db->files_st, 1);
ret = eq(hashdb, hash);
end:
if(NULL != db->files_st){
sqlite3_finalize(db->files_st);
db->files_st = NULL;
}
return ret;
}
bool lm_database_files_iskeep(lm_database_t *db, char *path){
bool ret = false;
int iskeep = 0;
if(NULL == db || NULL == path){
lm_error_set(LM_ERR_ArgNULL);
goto end;
}
if(sqlite3_prepare(db->files_db, queries[QUERY_SELECT_FILE_SINGLE], strlen(queries[QUERY_SELECT_FILE_SINGLE]), &db->files_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for selecting %s: %s", path, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
sqlite3_bind_text(db->files_st, 1, path, strlen(path), SQLITE_STATIC);
if(sqlite3_step(db->files_st) != SQLITE_DONE){
pdebug(__func__, "failed to execute select statement for selecting %s: %s", path, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlSelectFail);
goto end;
}
iskeep = sqlite3_column_int64(db->files_st, 2);
ret = iskeep == 1;
end:
if(NULL != db->files_st){
sqlite3_finalize(db->files_st);
db->files_st = NULL;
}
return ret;
}
bool lm_database_files_next(lm_database_t *db, lm_pkg_t *pkg, char **path, char **hash, bool *keep){
if(NULL == db || NULL == pkg || NULL == path || NULL == hash || NULL == keep){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char files_list[strlen(db->dir)+strlen(pkg->name)+20];
join_multiple(files_list, db->dir, pkg->name, "files");
if(!exists(files_list)){
lm_error_set(LM_ERR_DbFilesNotFound);
if(NULL == db->files_st &&
sqlite3_prepare(db->files_db, queries[QUERY_SELECT_FILE_ALL], strlen(queries[QUERY_SELECT_FILE_ALL]), &db->files_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for selecting all: %s", sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
return false;
}
FILE *files = fopen(files_list, "r");
char *line = NULL, hash[HASH_LEN+1];
size_t line_len = 0;
bool ret = false;
if(NULL == files){
lm_error_set(LM_ERR_DbFilesOpenFail);
goto end;
else if(NULL != db->files_st){
free(*path);
free(*hash);
*path = NULL;
*hash = NULL;
}
while((line_len = getline(&line, 0, files)) > 0){
if(HASH_LEN >= line_len)
continue;
char path[line_len+1];
memcpy(path, line+HASH_LEN+1, line_len-HASH_LEN);
memcpy(hash, line, HASH_LEN+1);
hash[HASH_LEN] = 0;
if(!func(pkg, path, hash, data))
goto end;
free(line);
line = NULL;
if(sqlite3_step(db->files_st) != SQLITE_ROW){
sqlite3_finalize(db->files_st);
db->files_st = NULL;
return false;
}
ret = true;
end:
free(line);
if(NULL != files)
fclose(files);
return ret;
*path = strdup((char*)sqlite3_column_text(db->files_st, 0));
*hash = strdup((char*)sqlite3_column_text(db->files_st, 1));
*keep = sqlite3_column_int(db->files_st, 2) == 1;
return true;
}
bool lm_database_files_add(lm_database_t *db, lm_pkg_t *pkg, char *path, char *hash){
if(NULL == db || NULL == pkg || NULL == path || NULL == hash){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char pkg_dir[strlen(db->dir)+strlen(pkg->name)+5];
char files_list[sizeof(pkg_dir)+15];
bool ret = false;
join(pkg_dir, db->dir, pkg->name);
join(files_list, pkg_dir, "files");
if(!mkdir_ifnot(pkg_dir)){
lm_error_set(LM_ERR_DbFilesDirFail);
return false;
}
FILE *files = fopen(files_list, "a");
if(NULL == files){
lm_error_set(LM_ERR_DbFilesOpenFail);
if(NULL == db || NULL == pkg || NULL == path || NULL == hash){
lm_error_set(LM_ERR_ArgNULL);
goto end;
}
if(fprintf(files, "%s:%s\n", hash, path) < 0){
pdebug(__func__, "failed to append file to files list: %s", files_list);
lm_error_set(LM_ERR_DbFilesWriteFail);
if(sqlite3_prepare(db->files_db, queries[QUERY_INSERT_FILE_SINGLE], strlen(queries[QUERY_INSERT_FILE_SINGLE]), &db->files_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for inserting %s: %s", path, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
sqlite3_bind_text(db->files_st, 1, path, strlen(path), SQLITE_STATIC);
sqlite3_bind_text(db->files_st, 2, hash, strlen(hash), SQLITE_STATIC);
if(lm_package_keep_contains(pkg, path))
sqlite3_bind_int(db->files_st, 3, 1);
else
sqlite3_bind_int(db->files_st, 3, 0);
sqlite3_bind_text(db->files_st, 4, pkg->name, strlen(pkg->name), SQLITE_STATIC);
if(sqlite3_step(db->files_st) != SQLITE_DONE){
pdebug(__func__, "failed to execute insert statement for inserting %s: %s", pkg->name, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlInsertFail);
goto end;
}
ret = true;
end:
if(NULL != files)
fclose(files);
if(NULL != db->files_st){
sqlite3_finalize(db->files_st);
db->files_st = NULL;
}
return ret;
}
bool lm_database_files_get(lm_database_t *db, lm_pkg_t *pkg, char *path, char *hash){
if(NULL == db || NULL == pkg || NULL == path){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
if(NULL != hash)
bzero(hash, HASH_LEN+1); // zero out the hash
char files_list[strlen(db->dir)+strlen(pkg->name)+10];
join_multiple(files_list, db->dir, pkg->name, "files");
if(!exists(files_list)){
lm_error_set(LM_ERR_DbFilesNotFound);
return false;
}
FILE *files = fopen(files_list, "r");
size_t line_len = 0;
char *line = NULL;
bool ret = false;
if(NULL == files){
lm_error_set(LM_ERR_DbFilesOpenFail);
goto end;
}
while((line_len = getline(&line, 0, files)) > 0){
if(HASH_LEN >= line_len)
continue;
char lpath[line_len+1];
memcpy(lpath, line+HASH_LEN+1, line_len-HASH_LEN);
if(eq(lpath, path)){
if(NULL != hash){
memcpy(hash, line, HASH_LEN+1);
hash[HASH_LEN] = 0;
}
ret = true;
goto end;
}
free(line);
line = NULL;
}
end:
free(line);
if(NULL != files)
fclose(files);
return ret;
}
bool lm_database_files_del(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char files_list[strlen(db->dir)+strlen(pkg->name)+10];
join_multiple(files_list, db->dir, pkg->name, "files");
bool ret = false;
if(unlink(files_list) < 0 && errno != ENOENT){
pdebug(__func__, "failed to delete file list for %s: %s", pkg->name, files_list);
lm_error_set(LM_ERR_DbFilesUnlinkFail);
return false;
if(sqlite3_prepare(db->files_db, queries[QUERY_DELETE_FILE_ALL], strlen(queries[QUERY_DELETE_FILE_ALL]), &db->files_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for deleting %s: %s", pkg->name, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
return true;
sqlite3_bind_text(db->files_st, 1, pkg->name, strlen(pkg->name), SQLITE_STATIC);
if(sqlite3_step(db->files_st) != SQLITE_DONE){
pdebug(__func__, "failed to execute delete statement for deleting %s: %s", pkg->name, sqlite3_errmsg(db->files_db));
lm_error_set(LM_ERR_DbSqlDeleteFail);
goto end;
}
ret = true;
end:
if(NULL != db->files_st){
sqlite3_finalize(db->files_st);
db->files_st = NULL;
}
return ret;
}

153
src/database/keeps.c
View File

@ -1,153 +0,0 @@
#include "../../include/database.h"
#include "../../include/package.h"
#include "../../include/error.h"
#include "../../include/util.h"
#include <stdio.h>
#include <errno.h>
#include <strings.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
bool lm_database_keeps_foreach(lm_database_t *db, lm_pkg_t *pkg, lm_database_keeps_eachfunc_t func, void *data){
if(NULL == db || NULL == pkg || NULL == func){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char keeps_list[strlen(db->dir)+strlen(pkg->name)+20];
join_multiple(keeps_list, db->dir, pkg->name, "keeps");
if(!exists(keeps_list)){
lm_error_set(LM_ERR_DbKeepsNotFound);
return false;
}
FILE *keeps = fopen(keeps_list, "r");
char *line = NULL;
bool ret = false;
if(NULL == keeps){
lm_error_set(LM_ERR_DbKeepsOpenFail);
goto end;
}
while(getline(&line, 0, keeps) > 0){
if(line[0] == 0)
continue;
if(!func(pkg, line, data))
goto end;
free(line);
line = NULL;
}
ret = true;
end:
free(line);
if(NULL != keeps)
fclose(keeps);
return ret;
}
bool lm_database_keeps_load(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char keeps_list[strlen(db->dir)+strlen(pkg->name)+20];
join_multiple(keeps_list, db->dir, pkg->name, "keeps");
if(!exists(keeps_list)){
lm_error_set(LM_ERR_DbKeepsNotFound);
return false;
}
FILE *keeps = fopen(keeps_list, "r");
char *line = NULL;
bool ret = false;
if(NULL == keeps){
lm_error_set(LM_ERR_DbKeepsOpenFail);
goto end;
}
while(getline(&line, 0, keeps) > 0){
if(line[0] == 0)
continue;
if(!lm_package_keep_add(pkg, line))
goto end;
free(line);
line = NULL;
}
ret = true;
end:
free(line);
if(NULL != keeps)
fclose(keeps);
return ret;
}
bool lm_database_keeps_save(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char pkg_dir[strlen(db->dir)+strlen(pkg->name)+5];
char keeps_list[sizeof(pkg_dir)+15];
bool ret = false;
join(pkg_dir, db->dir, pkg->name);
join(keeps_list, pkg_dir, "keeps");
if(!mkdir_ifnot(pkg_dir)){
lm_error_set(LM_ERR_DbKeepsDirFail);
return false;
}
FILE *keeps = fopen(keeps_list, "a");
if(NULL == keeps){
lm_error_set(LM_ERR_DbKeepsOpenFail);
goto end;
}
for(int i = 0; NULL != pkg->keeps[i]; i++)
fprintf(keeps, "%s\n", pkg->keeps[i]);
ret = true;
end:
if(NULL != keeps)
fclose(keeps);
return ret;
}
bool lm_database_keeps_del(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
char keeps_list[strlen(db->dir)+strlen(pkg->name)+20];
join_multiple(keeps_list, db->dir, pkg->name, "keeps");
if(unlink(keeps_list) < 0 && errno != ENOENT){
pdebug(__func__, "failed to delete keep list for %s: %s", pkg->name, keeps_list);
lm_error_set(LM_ERR_DbKeepsUnlinkFail);
return false;
}
return true;
}

105
src/database/package.c
View File

@ -8,7 +8,7 @@
#include <string.h>
#include <strings.h>
bool lm_database_add(lm_database_t *db, lm_pkg_t *pkg){
bool lm_database_packege_add(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
@ -17,39 +17,39 @@ bool lm_database_add(lm_database_t *db, lm_pkg_t *pkg){
char depends[lm_package_depend_strlen(pkg)];
bool ret = false;
if(sqlite3_prepare(db->sql, queries[QUERY_INSERT_PACKAGE], strlen(queries[QUERY_INSERT_PACKAGE]), &db->st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for inserting %s: %s", pkg->name, sqlite3_errmsg(db->sql));
if(sqlite3_prepare(db->packages_db, queries[QUERY_INSERT_PACKAGE_SINGLE], strlen(queries[QUERY_INSERT_PACKAGE_SINGLE]), &db->packages_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for inserting %s: %s", pkg->name, sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
sqlite3_bind_text(db->st, 1, pkg->name, strlen(pkg->name), SQLITE_STATIC);
sqlite3_bind_text(db->st, 2, pkg->desc, strlen(pkg->desc), SQLITE_STATIC);
sqlite3_bind_text(db->st, 3, pkg->version, strlen(pkg->version), SQLITE_STATIC);
sqlite3_bind_int64(db->st, 4, pkg->size);
sqlite3_bind_text(db->packages_st, 1, pkg->name, strlen(pkg->name), SQLITE_STATIC);
sqlite3_bind_text(db->packages_st, 2, pkg->desc, strlen(pkg->desc), SQLITE_STATIC);
sqlite3_bind_text(db->packages_st, 3, pkg->version, strlen(pkg->version), SQLITE_STATIC);
sqlite3_bind_int64(db->packages_st, 4, pkg->size);
if(!lm_package_depend_tostr(pkg, depends)){
pdebug(__func__, "failed to convert depends to string for inserting %s: %s", pkg->name, lm_strerror());
goto end;
}
sqlite3_bind_text(db->st, 5, depends, strlen(depends), SQLITE_STATIC);
sqlite3_bind_text(db->packages_st, 5, depends, strlen(depends), SQLITE_STATIC);
if(sqlite3_step(db->st) != SQLITE_DONE){
pdebug(__func__, "failed to execute insert statement for inserting %s: %s", pkg->name, sqlite3_errmsg(db->sql));
if(sqlite3_step(db->packages_st) != SQLITE_DONE){
pdebug(__func__, "failed to execute insert statement for inserting %s: %s", pkg->name, sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlInsertFail);
goto end;
}
ret = true;
end:
if(NULL != db->st){
sqlite3_finalize(db->st);
db->st = NULL;
if(NULL != db->packages_st){
sqlite3_finalize(db->packages_st);
db->packages_st = NULL;
}
return ret;
}
bool lm_database_find(lm_database_t *db, lm_pkg_t *pkg, char *name){
bool lm_database_package_find(lm_database_t *db, lm_pkg_t *pkg, char *name){
if(NULL == db || NULL == name){
lm_error_set(LM_ERR_ArgNULL);
return false;
@ -57,15 +57,15 @@ bool lm_database_find(lm_database_t *db, lm_pkg_t *pkg, char *name){
bool ret = false;
if(sqlite3_prepare(db->sql, queries[QUERY_SELECT_PACKAGE], strlen(queries[QUERY_SELECT_PACKAGE]), &db->st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for finding %s: %s", name, sqlite3_errmsg(db->sql));
if(sqlite3_prepare(db->packages_db, queries[QUERY_SELECT_PACKAGE_SINGLE], strlen(queries[QUERY_SELECT_PACKAGE_SINGLE]), &db->packages_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for finding %s: %s", name, sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
sqlite3_bind_text(db->st, 1, name, strlen(name), SQLITE_STATIC);
sqlite3_bind_text(db->packages_st, 1, name, strlen(name), SQLITE_STATIC);
if(sqlite3_step(db->st) != SQLITE_ROW){
if(sqlite3_step(db->packages_st) != SQLITE_ROW){
pdebug(__func__, "got no rows for %s", name);
lm_error_set(LM_ERR_DbSqlNotFound);
goto end;
@ -80,12 +80,12 @@ bool lm_database_find(lm_database_t *db, lm_pkg_t *pkg, char *name){
// we are initing it just in case the caller didn't
lm_package_init(pkg);
pkg->name = strdup((char*)sqlite3_column_text(db->st, 0));
pkg->desc = strdup((char*)sqlite3_column_text(db->st, 1));
pkg->version = strdup((char*)sqlite3_column_text(db->st, 2));
pkg->size = sqlite3_column_int64(db->st, 3);
pkg->name = strdup((char*)sqlite3_column_text(db->packages_st, 0));
pkg->desc = strdup((char*)sqlite3_column_text(db->packages_st, 1));
pkg->version = strdup((char*)sqlite3_column_text(db->packages_st, 2));
pkg->size = sqlite3_column_int64(db->packages_st, 3);
char *depends = (char*)sqlite3_column_text(db->st, 3);
char *depends = (char*)sqlite3_column_text(db->packages_st, 3);
if(!lm_package_depend_fromstr(pkg, depends)){
pdebug(__func__, "failed to load depends for finding %s: %s", pkg->name, lm_strerror());
// error is set by the function
@ -94,14 +94,14 @@ bool lm_database_find(lm_database_t *db, lm_pkg_t *pkg, char *name){
ret = true;
end:
if(NULL != db->st){
sqlite3_finalize(db->st);
db->st = NULL;
if(NULL != db->packages_st){
sqlite3_finalize(db->packages_st);
db->packages_st = NULL;
}
return ret;
}
bool lm_database_del(lm_database_t *db, lm_pkg_t *pkg){
bool lm_database_package_del(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
@ -109,63 +109,62 @@ bool lm_database_del(lm_database_t *db, lm_pkg_t *pkg){
bool ret = false;
if(sqlite3_prepare(db->sql, queries[QUERY_DELETE_PACKAGE], strlen(queries[QUERY_DELETE_PACKAGE]), &db->st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for deleting %s: %s", pkg->name, sqlite3_errmsg(db->sql));
if(sqlite3_prepare(db->packages_db, queries[QUERY_DELETE_PACKAGE_SINGLE], strlen(queries[QUERY_DELETE_PACKAGE_SINGLE]), &db->packages_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for deleting %s: %s", pkg->name, sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
goto end;
}
sqlite3_bind_text(db->st, 1, pkg->name, strlen(pkg->name), SQLITE_STATIC);
sqlite3_bind_text(db->packages_st, 1, pkg->name, strlen(pkg->name), SQLITE_STATIC);
if(sqlite3_step(db->st) != SQLITE_DONE){
pdebug(__func__, "failed to execute delete statement for deleting %s: %s", pkg->name, sqlite3_errmsg(db->sql));
lm_error_set(LM_ERR_DbSqlInsertFail);
if(sqlite3_step(db->packages_st) != SQLITE_DONE){
pdebug(__func__, "failed to execute delete statement for deleting %s: %s", pkg->name, sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlDeleteFail);
goto end;
}
ret = true;
end:
if(NULL != db->st){
sqlite3_finalize(db->st);
db->st = NULL;
if(NULL != db->packages_st){
sqlite3_finalize(db->packages_st);
db->packages_st = NULL;
}
return ret;
}
bool lm_database_next(lm_database_t *db, lm_pkg_t *pkg){
bool lm_database_package_next(lm_database_t *db, lm_pkg_t *pkg){
if(NULL == db || NULL == pkg){
lm_error_set(LM_ERR_ArgNULL);
return false;
}
if(NULL == db->st){
if(sqlite3_prepare(db->sql, queries[QUERY_ALL_PACKAGE], strlen(queries[QUERY_ALL_PACKAGE]), &db->st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for selecting all: %s", sqlite3_errmsg(db->sql));
lm_error_set(LM_ERR_DbSqlPrepareFail);
return false;
}
if(NULL == db->packages_st &&
sqlite3_prepare(db->packages_db, queries[QUERY_SELECT_PACKAGE_ALL], strlen(queries[QUERY_SELECT_PACKAGE_ALL]), &db->packages_st, NULL) != SQLITE_OK){
pdebug(__func__, "failed to prepare statement for selecting all: %s", sqlite3_errmsg(db->packages_db));
lm_error_set(LM_ERR_DbSqlPrepareFail);
return false;
}
else
else if(NULL != db->packages_st)
lm_package_free(pkg);
if(sqlite3_step(db->st) != SQLITE_ROW){
sqlite3_finalize(db->st);
db->st = NULL;
if(sqlite3_step(db->packages_st) != SQLITE_ROW){
sqlite3_finalize(db->packages_st);
db->packages_st = NULL;
return false;
}
lm_package_init(pkg);
pkg->name = strdup((char*)sqlite3_column_text(db->st, 0));
pkg->desc = strdup((char*)sqlite3_column_text(db->st, 1));
pkg->version = strdup((char*)sqlite3_column_text(db->st, 2));
pkg->size = sqlite3_column_int64(db->st, 3);
pkg->name = strdup((char*)sqlite3_column_text(db->packages_st, 0));
pkg->desc = strdup((char*)sqlite3_column_text(db->packages_st, 1));
pkg->version = strdup((char*)sqlite3_column_text(db->packages_st, 2));
pkg->size = sqlite3_column_int64(db->packages_st, 3);
char *depends = (char*)sqlite3_column_text(db->st, 3);
char *depends = (char*)sqlite3_column_text(db->packages_st, 3);
if(!lm_package_depend_fromstr(pkg, depends)){
pdebug(__func__, "failed to load depends for finding %s: %s", pkg->name, lm_strerror());
sqlite3_finalize(db->st);
sqlite3_finalize(db->packages_st);
return false;
}

2
src/error.c
View File

@ -89,6 +89,8 @@ void lm_error_set(lm_error_t code, ...) {
{.code = LM_ERR_DbSqlCreateFail, .desc = _("failed to create table in SQLite database") },
{.code = LM_ERR_DbSqlPrepareFail, .desc = _("failed to prepare statement for SQLite database") },
{.code = LM_ERR_DbSqlInsertFail, .desc = _("failed to insert to the table in SQLite database") },
{.code = LM_ERR_DbSqlSelectFail, .desc = _("failed to select from the table in SQLite database") },
{.code = LM_ERR_DbSqlDeleteFail, .desc = _("failed to delete from the table in SQLite database") },
{.code = LM_ERR_DbSqlNotFound, .desc = _("failed to find entry in SQLite database") },
{.code = LM_ERR_PkgGPGFail, .desc = _("failed to init GPG for package verification") },
{.code = LM_ERR_PkgGPGSigFail, .desc = _("failed to import signature to GPG for package verification")},