1 /*#############################################################################
3 # Pakfire - The IPFire package management system #
4 # Copyright (C) 2021 Pakfire development team #
6 # This program is free software: you can redistribute it and/or modify #
7 # it under the terms of the GNU General Public License as published by #
8 # the Free Software Foundation, either version 3 of the License, or #
9 # (at your option) any later version. #
11 # This program is distributed in the hope that it will be useful, #
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of #
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
14 # GNU General Public License for more details. #
16 # You should have received a copy of the GNU General Public License #
17 # along with this program. If not, see <http://www.gnu.org/licenses/>. #
19 #############################################################################*/
22 #include <linux/limits.h>
26 #include <openssl/sha.h>
27 #include <solv/solver.h>
30 #include <pakfire/archive.h>
31 #include <pakfire/db.h>
32 #include <pakfire/dependencies.h>
33 #include <pakfire/digest.h>
34 #include <pakfire/file.h>
35 #include <pakfire/filelist.h>
36 #include <pakfire/logging.h>
37 #include <pakfire/package.h>
38 #include <pakfire/pakfire.h>
39 #include <pakfire/repo.h>
40 #include <pakfire/string.h>
41 #include <pakfire/util.h>
43 #define DATABASE_PATH PAKFIRE_PRIVATE_DIR "/packages.db"
45 #define CURRENT_SCHEMA 8
46 #define SCHEMA_MIN_SUP 7
49 struct pakfire
* pakfire
;
57 time_t last_modified_at
;
60 static void logging_callback(void* data
, int r
, const char* msg
) {
61 struct pakfire
* pakfire
= (struct pakfire
*)data
;
63 ERROR(pakfire
, "Database Error: %s: %s\n",
64 sqlite3_errstr(r
), msg
);
67 static sqlite3_value
* pakfire_db_get(struct pakfire_db
* db
, const char* key
) {
68 sqlite3_stmt
* stmt
= NULL
;
69 sqlite3_value
* val
= NULL
;
72 const char* sql
= "SELECT val FROM settings WHERE key = ?";
74 // Prepare the statement
75 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
77 //ERROR(db->pakfire, "Could not prepare SQL statement: %s: %s\n",
78 // sql, sqlite3_errmsg(db->handle));
83 r
= sqlite3_bind_text(stmt
, 1, key
, strlen(key
), NULL
);
85 ERROR(db
->pakfire
, "Could not bind key: %s\n", sqlite3_errmsg(db
->handle
));
89 // Execute the statement
91 r
= sqlite3_step(stmt
);
92 } while (r
== SQLITE_BUSY
);
94 // We should have read a row
99 val
= sqlite3_column_value(stmt
, 0);
101 ERROR(db
->pakfire
, "Could not read value\n");
105 // Copy value onto the heap
106 val
= sqlite3_value_dup(val
);
110 sqlite3_finalize(stmt
);
115 static char* pakfire_db_get_string(struct pakfire_db
* db
, const char* key
) {
118 // Fetch the value from the database
119 sqlite3_value
* value
= pakfire_db_get(db
, key
);
123 // Extract the value as string
124 const char* p
= (const char*)sqlite3_value_text(value
);
128 // Copy string to heap
133 sqlite3_value_free(value
);
138 static int pakfire_db_set_string(struct pakfire_db
* db
, const char* key
, const char* val
) {
139 sqlite3_stmt
* stmt
= NULL
;
142 DEBUG(db
->pakfire
, "Setting %s to '%s'\n", key
, val
);
144 const char* sql
= "INSERT INTO settings(key, val) VALUES(?, ?) \
145 ON CONFLICT (key) DO UPDATE SET val = excluded.val";
148 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
149 if (r
!= SQLITE_OK
) {
150 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s: %s\n",
151 sql
, sqlite3_errmsg(db
->handle
));
156 r
= sqlite3_bind_text(stmt
, 1, key
, strlen(key
), NULL
);
157 if (r
!= SQLITE_OK
) {
158 ERROR(db
->pakfire
, "Could not bind key: %s\n", sqlite3_errmsg(db
->handle
));
163 r
= sqlite3_bind_text(stmt
, 2, val
, strlen(val
), NULL
);
164 if (r
!= SQLITE_OK
) {
165 ERROR(db
->pakfire
, "Could not bind val: %s\n", sqlite3_errmsg(db
->handle
));
169 // Execute the statement
171 r
= sqlite3_step(stmt
);
172 } while (r
== SQLITE_BUSY
);
175 r
= (r
== SQLITE_OK
);
179 sqlite3_finalize(stmt
);
184 static int pakfire_db_set_int(struct pakfire_db
* db
, const char* key
, int val
) {
185 sqlite3_stmt
* stmt
= NULL
;
188 DEBUG(db
->pakfire
, "Setting %s to '%d'\n", key
, val
);
190 const char* sql
= "INSERT INTO settings(key, val) VALUES(?, ?) \
191 ON CONFLICT (key) DO UPDATE SET val = excluded.val";
194 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
195 if (r
!= SQLITE_OK
) {
196 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s: %s\n",
197 sql
, sqlite3_errmsg(db
->handle
));
202 r
= sqlite3_bind_text(stmt
, 1, key
, strlen(key
), NULL
);
203 if (r
!= SQLITE_OK
) {
204 ERROR(db
->pakfire
, "Could not bind key: %s\n", sqlite3_errmsg(db
->handle
));
209 r
= sqlite3_bind_int64(stmt
, 2, val
);
210 if (r
!= SQLITE_OK
) {
211 ERROR(db
->pakfire
, "Could not bind val: %s\n", sqlite3_errmsg(db
->handle
));
215 // Execute the statement
217 r
= sqlite3_step(stmt
);
218 } while (r
== SQLITE_BUSY
);
221 r
= (r
== SQLITE_OK
);
225 sqlite3_finalize(stmt
);
230 static time_t pakfire_read_modification_time(struct pakfire_db
* db
) {
233 // Fetch the value from the database
234 sqlite3_value
* value
= pakfire_db_get(db
, "last_modified_at");
236 t
= sqlite3_value_int64(value
);
237 sqlite3_value_free(value
);
239 DEBUG(db
->pakfire
, "Could not find last modification timestamp\n");
245 static int pakfire_update_modification_time(struct pakfire_db
* db
) {
246 // Get the current time in UTC
247 time_t t
= time(NULL
);
249 // Store it in the database
250 int r
= pakfire_db_set_int(db
, "last_modified_at", t
);
254 // Update the last modification timestamp
255 db
->last_modified_at
= t
;
260 static int pakfire_db_execute(struct pakfire_db
* db
, const char* stmt
) {
263 DEBUG(db
->pakfire
, "Executing database query: %s\n", stmt
);
266 r
= sqlite3_exec(db
->handle
, stmt
, NULL
, NULL
, NULL
);
267 } while (r
== SQLITE_BUSY
);
271 ERROR(db
->pakfire
, "Database query failed: %s\n", sqlite3_errmsg(db
->handle
));
277 static int pakfire_db_begin_transaction(struct pakfire_db
* db
) {
278 return pakfire_db_execute(db
, "BEGIN TRANSACTION");
281 static int pakfire_db_commit(struct pakfire_db
* db
) {
283 If the database was opened in read-write mode, we will store the
284 timestamp of the latest modification to compare whether the database
285 has been changed mid-transaction.
287 if (db
->mode
== PAKFIRE_DB_READWRITE
) {
288 int r
= pakfire_update_modification_time(db
);
293 return pakfire_db_execute(db
, "COMMIT");
296 static int pakfire_db_rollback(struct pakfire_db
* db
) {
297 return pakfire_db_execute(db
, "ROLLBACK");
301 This function performs any fast optimization and tries to truncate the WAL log file
302 to keep the database as compact as possible on disk.
304 static void pakfire_db_optimize(struct pakfire_db
* db
) {
305 pakfire_db_execute(db
, "PRAGMA optimize");
306 pakfire_db_execute(db
, "PRAGMA wal_checkpoint = TRUNCATE");
309 static void pakfire_db_free(struct pakfire_db
* db
) {
311 // Optimize the database before it is being closed
312 pakfire_db_optimize(db
);
314 // Close database handle
315 int r
= sqlite3_close(db
->handle
);
316 if (r
!= SQLITE_OK
) {
317 ERROR(db
->pakfire
, "Could not close database handle: %s\n",
318 sqlite3_errmsg(db
->handle
));
322 pakfire_unref(db
->pakfire
);
327 static int pakfire_db_get_schema(struct pakfire_db
* db
) {
328 sqlite3_value
* value
= pakfire_db_get(db
, "schema");
332 int schema
= sqlite3_value_int64(value
);
333 sqlite3_value_free(value
);
335 DEBUG(db
->pakfire
, "Database has schema version %d\n", schema
);
340 static int pakfire_db_create_schema(struct pakfire_db
* db
) {
343 // Create settings table
344 r
= pakfire_db_execute(db
, "CREATE TABLE IF NOT EXISTS settings(key TEXT, val TEXT)");
348 // settings: Add a unique index on key
349 r
= pakfire_db_execute(db
, "CREATE UNIQUE INDEX IF NOT EXISTS settings_key ON settings(key)");
353 // Create packages table
354 r
= pakfire_db_execute(db
,
355 "CREATE TABLE IF NOT EXISTS packages("
356 "id INTEGER PRIMARY KEY, "
363 "inst_size INTEGER, "
364 "digest_type INTEGER, "
372 "build_time INTEGER, "
373 "installed INTEGER, "
374 "userinstalled INTEGER, "
384 // packages: Create index to find package by name
385 r
= pakfire_db_execute(db
, "CREATE INDEX IF NOT EXISTS packages_name ON packages(name)");
389 // packages: Create unique index over UUID
390 r
= pakfire_db_execute(db
, "CREATE UNIQUE INDEX IF NOT EXISTS packages_uuid ON packages(uuid)");
394 // Create dependencies table
395 r
= pakfire_db_execute(db
,
396 "CREATE TABLE IF NOT EXISTS dependencies("
400 "FOREIGN KEY (pkg) REFERENCES packages(id) ON DELETE CASCADE"
405 // dependencies: Add index over packages
406 r
= pakfire_db_execute(db
, "CREATE INDEX IF NOT EXISTS dependencies_pkg_index ON dependencies(pkg)");
410 // Create files table
411 r
= pakfire_db_execute(db
,
412 "CREATE TABLE IF NOT EXISTS files("
413 "id INTEGER PRIMARY KEY, "
424 "capabilities TEXT, "
425 "digest_sha2_512 BLOB, "
426 "digest_sha2_256 BLOB, "
427 "digest_blake2b512 BLOB, "
428 "digest_blake2s256 BLOB, "
429 "digest_sha3_512 BLOB, "
430 "digest_sha3_256 BLOB, "
431 "FOREIGN KEY (pkg) REFERENCES packages(id) ON DELETE CASCADE"
436 // files: Add index over packages
437 r
= pakfire_db_execute(db
, "CREATE INDEX IF NOT EXISTS files_pkg_index ON files(pkg)");
441 // files: Add index over path
442 r
= pakfire_db_execute(db
, "CREATE INDEX IF NOT EXISTS files_path_index ON files(path)");
446 // Create scriptlets table
447 r
= pakfire_db_execute(db
,
448 "CREATE TABLE IF NOT EXISTS scriptlets("
449 "id INTEGER PRIMARY KEY, "
453 "FOREIGN KEY (pkg) REFERENCES packages(id) ON DELETE CASCADE"
458 // scriptlets: Add index over packages
459 r
= pakfire_db_execute(db
, "CREATE INDEX IF NOT EXISTS scriptlets_pkg_index ON scriptlets(pkg)");
463 const char* arch
= pakfire_get_arch(db
->pakfire
);
466 r
= pakfire_db_set_string(db
, "arch", arch
);
468 ERROR(db
->pakfire
, "Could not set architecture\n");
475 static int pakfire_db_migrate_to_schema_8(struct pakfire_db
* db
) {
476 // packages: Drop build_id column
479 // TODO sqlite doesn't support adding foreign keys to existing tables and so we would
480 // need to recreate the whole table and rename it afterwards. Annoying.
485 static int pakfire_db_migrate_schema(struct pakfire_db
* db
) {
488 while (db
->schema
< CURRENT_SCHEMA
) {
489 // Begin a new transaction
490 r
= pakfire_db_begin_transaction(db
);
494 switch (db
->schema
) {
497 r
= pakfire_db_create_schema(db
);
501 db
->schema
= CURRENT_SCHEMA
;
505 r
= pakfire_db_migrate_to_schema_8(db
);
513 ERROR(db
->pakfire
, "Cannot migrate database from schema %d\n", db
->schema
);
517 // Update the schema version
518 r
= pakfire_db_set_int(db
, "schema", CURRENT_SCHEMA
);
523 r
= pakfire_db_commit(db
);
531 pakfire_db_rollback(db
);
536 static int pakfire_db_check_arch(struct pakfire_db
* db
) {
539 // Fetch database architecture
540 char* db_arch
= pakfire_db_get_string(db
, "arch");
542 ERROR(db
->pakfire
, "Database is of an unknown architecture\n");
546 // Fetch the running architecture
547 const char* arch
= pakfire_get_arch(db
->pakfire
);
552 if (strcmp(db_arch
, arch
) == 0)
562 static int pakfire_db_setup(struct pakfire_db
* db
) {
566 sqlite3_config(SQLITE_CONFIG_LOG
, logging_callback
, db
->pakfire
);
568 // Enable foreign keys
569 pakfire_db_execute(db
, "PRAGMA foreign_keys = ON");
571 // Make LIKE case-sensitive
572 pakfire_db_execute(db
, "PRAGMA case_sensitive_like = ON");
574 // Fetch the current schema
575 db
->schema
= pakfire_db_get_schema(db
);
577 // Check if the schema is recent enough
578 if (db
->schema
> 0 && db
->schema
< SCHEMA_MIN_SUP
) {
579 ERROR(db
->pakfire
, "Database schema %d is not supported by this version of Pakfire\n",
584 // Read modification timestamp
585 db
->last_modified_at
= pakfire_read_modification_time(db
);
587 DEBUG(db
->pakfire
, "The database was last modified at %ld\n", db
->last_modified_at
);
589 // Done when not in read-write mode
590 if (db
->mode
!= PAKFIRE_DB_READWRITE
)
593 // Disable secure delete
594 pakfire_db_execute(db
, "PRAGMA secure_delete = OFF");
596 // Set database journal to WAL
597 r
= pakfire_db_execute(db
, "PRAGMA journal_mode = WAL");
598 if (r
!= SQLITE_OK
) {
599 ERROR(db
->pakfire
, "Could not set journal mode to WAL: %s\n",
600 sqlite3_errmsg(db
->handle
));
604 // Disable autocheckpoint
605 r
= sqlite3_wal_autocheckpoint(db
->handle
, 0);
606 if (r
!= SQLITE_OK
) {
607 ERROR(db
->pakfire
, "Could not disable autocheckpoint: %s\n",
608 sqlite3_errmsg(db
->handle
));
612 // Create or migrate schema
613 r
= pakfire_db_migrate_schema(db
);
620 int pakfire_db_open(struct pakfire_db
** db
, struct pakfire
* pakfire
, int flags
) {
623 struct pakfire_db
* o
= calloc(1, sizeof(*o
));
627 o
->pakfire
= pakfire_ref(pakfire
);
630 int sqlite3_flags
= 0;
632 // Store mode & forward it to sqlite3
633 if (flags
& PAKFIRE_DB_READWRITE
) {
634 o
->mode
= PAKFIRE_DB_READWRITE
;
635 sqlite3_flags
|= SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
;
637 o
->mode
= PAKFIRE_DB_READONLY
;
638 sqlite3_flags
|= SQLITE_OPEN_READONLY
;
642 r
= pakfire_path(o
->pakfire
, o
->path
, "%s", DATABASE_PATH
);
646 // Try to open the sqlite3 database file
647 r
= sqlite3_open_v2(o
->path
, &o
->handle
, sqlite3_flags
, NULL
);
648 if (r
!= SQLITE_OK
) {
649 ERROR(pakfire
, "Could not open database %s: %s\n",
650 o
->path
, sqlite3_errmsg(o
->handle
));
656 // Setup the database
657 r
= pakfire_db_setup(o
);
661 // Check for compatible architecture
662 r
= pakfire_db_check_arch(o
);
676 struct pakfire_db
* pakfire_db_ref(struct pakfire_db
* db
) {
682 struct pakfire_db
* pakfire_db_unref(struct pakfire_db
* db
) {
691 static unsigned long pakfire_db_integrity_check(struct pakfire_db
* db
) {
692 sqlite3_stmt
* stmt
= NULL
;
695 r
= sqlite3_prepare_v2(db
->handle
, "PRAGMA integrity_check", -1, &stmt
, NULL
);
697 ERROR(db
->pakfire
, "Could not prepare integrity check: %s\n",
698 sqlite3_errmsg(db
->handle
));
703 unsigned long errors
= 0;
707 r
= sqlite3_step(stmt
);
708 } while (r
== SQLITE_BUSY
);
710 if (r
== SQLITE_ROW
) {
711 const char* error
= (const char*)sqlite3_column_text(stmt
, 0);
713 // If the message is "ok", the database has passed the check
714 if (strcmp(error
, "ok") == 0)
717 // Increment error counter
721 ERROR(db
->pakfire
, "%s\n", error
);
723 // Break on anything else
728 sqlite3_finalize(stmt
);
731 ERROR(db
->pakfire
, "Database integrity check failed\n");
733 INFO(db
->pakfire
, "Database integrity check passed\n");
738 static unsigned long pakfire_db_foreign_key_check(struct pakfire_db
* db
) {
739 sqlite3_stmt
* stmt
= NULL
;
742 r
= sqlite3_prepare_v2(db
->handle
, "PRAGMA foreign_key_check", -1, &stmt
, NULL
);
744 ERROR(db
->pakfire
, "Could not prepare foreign key check: %s\n",
745 sqlite3_errmsg(db
->handle
));
750 unsigned long errors
= 0;
754 r
= sqlite3_step(stmt
);
755 } while (r
== SQLITE_BUSY
);
757 if (r
== SQLITE_ROW
) {
758 const unsigned char* table
= sqlite3_column_text(stmt
, 0);
759 unsigned long rowid
= sqlite3_column_int64(stmt
, 1);
760 const unsigned char* foreign_table
= sqlite3_column_text(stmt
, 2);
761 unsigned long foreign_rowid
= sqlite3_column_int64(stmt
, 3);
763 // Increment error counter
767 ERROR(db
->pakfire
, "Foreign key violation found in %s, row %lu: "
768 "%lu does not exist in table %s\n", table
, rowid
, foreign_rowid
, foreign_table
);
770 // Break on anything else
775 sqlite3_finalize(stmt
);
778 ERROR(db
->pakfire
, "Foreign key check failed\n");
780 INFO(db
->pakfire
, "Foreign key check passed\n");
786 This function performs an integrity check of the database
788 int pakfire_db_check(struct pakfire_db
* db
) {
791 // Perform integrity check
792 r
= pakfire_db_integrity_check(db
);
796 // Perform foreign key check
797 r
= pakfire_db_foreign_key_check(db
);
804 // Returns the number of packages installed
805 ssize_t
pakfire_db_packages(struct pakfire_db
* db
) {
806 sqlite3_stmt
* stmt
= NULL
;
807 ssize_t packages
= -1;
809 int r
= sqlite3_prepare_v2(db
->handle
, "SELECT COUNT(*) FROM packages", -1, &stmt
, NULL
);
811 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s\n",
812 sqlite3_errmsg(db
->handle
));
818 r
= sqlite3_step(stmt
);
819 } while (r
== SQLITE_BUSY
);
821 if (r
== SQLITE_ROW
) {
822 packages
= sqlite3_column_int64(stmt
, 0);
825 sqlite3_finalize(stmt
);
830 static void pakfire_db_add_userinstalled(struct pakfire
* pakfire
, const char* name
) {
831 Pool
* pool
= pakfire_get_solv_pool(pakfire
);
833 // Convert name to ID
834 Id id
= pool_str2id(pool
, name
, 1);
836 // Append it to pooljobs
837 queue_push2(&pool
->pooljobs
, SOLVER_USERINSTALLED
|SOLVER_SOLVABLE_NAME
, id
);
840 static int pakfire_db_add_dependencies(struct pakfire_db
* db
, unsigned long id
, struct pakfire_package
* pkg
) {
841 sqlite3_stmt
* stmt
= NULL
;
845 const char* sql
= "INSERT INTO dependencies(pkg, type, dependency) VALUES(?, ?, ?)";
847 // Prepare the statement
848 r
= sqlite3_prepare_v2(db
->handle
, sql
, -1, &stmt
, NULL
);
850 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s: %s\n",
851 sql
, sqlite3_errmsg(db
->handle
));
855 for (const struct pakfire_dep
* dep
= pakfire_deps
; dep
->key
; dep
++) {
856 list
= pakfire_package_get_deps(pkg
, dep
->key
);
862 for (char** d
= list
; *d
; d
++) {
864 r
= sqlite3_bind_int64(stmt
, 1, id
);
866 ERROR(db
->pakfire
, "Could not bind id: %s\n",
867 sqlite3_errmsg(db
->handle
));
872 r
= sqlite3_bind_text(stmt
, 2, dep
->name
, -1, NULL
);
874 ERROR(db
->pakfire
, "Could not bind type: %s\n",
875 sqlite3_errmsg(db
->handle
));
880 r
= sqlite3_bind_text(stmt
, 3, *d
, -1, NULL
);
882 ERROR(db
->pakfire
, "Could not bind dependency: %s\n",
883 sqlite3_errmsg(db
->handle
));
889 r
= sqlite3_step(stmt
);
890 } while (r
== SQLITE_BUSY
);
892 // Reset bound values
902 sqlite3_finalize(stmt
);
904 for (char** dep
= list
; *dep
; dep
++)
912 static int pakfire_db_bind_digest(struct pakfire_db
* db
, sqlite3_stmt
* stmt
, const int field
,
913 struct pakfire_file
* file
, const enum pakfire_digest_types type
) {
914 const unsigned char* digest
= NULL
;
918 digest
= pakfire_file_get_digest(file
, type
, &length
);
920 // If this digest isn't set, just bind NULL
922 return sqlite3_bind_null(stmt
, field
);
924 // Otherwise bind the data blob
925 return sqlite3_bind_blob(stmt
, field
, digest
, length
, NULL
);
928 static int pakfire_db_add_files(struct pakfire_db
* db
, unsigned long id
, struct pakfire_archive
* archive
) {
929 sqlite3_stmt
* stmt
= NULL
;
932 // Get the filelist from the archive
933 struct pakfire_filelist
* filelist
= pakfire_archive_get_filelist(archive
);
935 ERROR(db
->pakfire
, "Could not fetch filelist from archive\n");
939 // Nothing to do if the list is empty
940 if (pakfire_filelist_is_empty(filelist
)) {
961 "digest_blake2b512, "
962 "digest_blake2s256, "
966 "VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
968 // Prepare the statement
969 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
971 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s: %s\n",
972 sql
, sqlite3_errmsg(db
->handle
));
976 for (unsigned int i
= 0; i
< pakfire_filelist_length(filelist
); i
++) {
977 struct pakfire_file
* file
= pakfire_filelist_get(filelist
, i
);
980 r
= sqlite3_bind_int64(stmt
, 1, id
);
982 ERROR(db
->pakfire
, "Could not bind id: %s\n", sqlite3_errmsg(db
->handle
));
983 pakfire_file_unref(file
);
988 const char* path
= pakfire_file_get_path(file
);
990 r
= sqlite3_bind_text(stmt
, 2, path
, -1, NULL
);
992 ERROR(db
->pakfire
, "Could not bind path: %s\n", sqlite3_errmsg(db
->handle
));
993 pakfire_file_unref(file
);
998 size_t size
= pakfire_file_get_size(file
);
1000 r
= sqlite3_bind_int64(stmt
, 3, size
);
1002 ERROR(db
->pakfire
, "Could not bind size: %s\n", sqlite3_errmsg(db
->handle
));
1003 pakfire_file_unref(file
);
1007 // Bind config - XXX TODO
1008 r
= sqlite3_bind_null(stmt
, 4);
1010 ERROR(db
->pakfire
, "Could not bind config: %s\n", sqlite3_errmsg(db
->handle
));
1011 pakfire_file_unref(file
);
1015 // Bind datafile - XXX TODO
1016 r
= sqlite3_bind_null(stmt
, 5);
1018 ERROR(db
->pakfire
, "Could not bind datafile: %s\n", sqlite3_errmsg(db
->handle
));
1019 pakfire_file_unref(file
);
1024 mode_t mode
= pakfire_file_get_mode(file
);
1026 r
= sqlite3_bind_int64(stmt
, 6, mode
);
1028 ERROR(db
->pakfire
, "Could not bind mode: %s\n", sqlite3_errmsg(db
->handle
));
1029 pakfire_file_unref(file
);
1034 const char* uname
= pakfire_file_get_uname(file
);
1036 r
= sqlite3_bind_text(stmt
, 7, uname
, -1, NULL
);
1038 ERROR(db
->pakfire
, "Could not bind uname: %s\n", sqlite3_errmsg(db
->handle
));
1039 pakfire_file_unref(file
);
1044 const char* gname
= pakfire_file_get_gname(file
);
1046 r
= sqlite3_bind_text(stmt
, 8, gname
, -1, NULL
);
1048 ERROR(db
->pakfire
, "Could not bind gname: %s\n", sqlite3_errmsg(db
->handle
));
1049 pakfire_file_unref(file
);
1054 time_t ctime
= pakfire_file_get_ctime(file
);
1056 r
= sqlite3_bind_int64(stmt
, 9, ctime
);
1058 ERROR(db
->pakfire
, "Could not bind ctime: %s\n", sqlite3_errmsg(db
->handle
));
1059 pakfire_file_unref(file
);
1064 time_t mtime
= pakfire_file_get_mtime(file
);
1066 r
= sqlite3_bind_int64(stmt
, 10, mtime
);
1068 ERROR(db
->pakfire
, "Could not bind mtime: %s\n", sqlite3_errmsg(db
->handle
));
1069 pakfire_file_unref(file
);
1073 // Bind capabilities - XXX TODO
1074 r
= sqlite3_bind_null(stmt
, 11);
1076 ERROR(db
->pakfire
, "Could not bind capabilities: %s\n", sqlite3_errmsg(db
->handle
));
1077 pakfire_file_unref(file
);
1082 r
= pakfire_db_bind_digest(db
, stmt
, 12, file
, PAKFIRE_DIGEST_SHA2_512
);
1084 ERROR(db
->pakfire
, "Could not bind SHA2-512 digest: %s\n",
1085 sqlite3_errmsg(db
->handle
));
1086 pakfire_file_unref(file
);
1091 r
= pakfire_db_bind_digest(db
, stmt
, 13, file
, PAKFIRE_DIGEST_SHA2_256
);
1093 ERROR(db
->pakfire
, "Could not bind SHA2-256 digest: %s\n",
1094 sqlite3_errmsg(db
->handle
));
1095 pakfire_file_unref(file
);
1099 // BLAKE2b512 Digest
1100 r
= pakfire_db_bind_digest(db
, stmt
, 14, file
, PAKFIRE_DIGEST_BLAKE2B512
);
1102 ERROR(db
->pakfire
, "Could not bind BLAKE2b512 digest: %s\n",
1103 sqlite3_errmsg(db
->handle
));
1104 pakfire_file_unref(file
);
1108 // BLAKE2s256 Digest
1109 r
= pakfire_db_bind_digest(db
, stmt
, 15, file
, PAKFIRE_DIGEST_BLAKE2S256
);
1111 ERROR(db
->pakfire
, "Could not bind BLAKE2s256 digest: %s\n",
1112 sqlite3_errmsg(db
->handle
));
1113 pakfire_file_unref(file
);
1118 r
= pakfire_db_bind_digest(db
, stmt
, 16, file
, PAKFIRE_DIGEST_SHA3_512
);
1120 ERROR(db
->pakfire
, "Could not bind SHA3-512 digest: %s\n",
1121 sqlite3_errmsg(db
->handle
));
1122 pakfire_file_unref(file
);
1127 r
= pakfire_db_bind_digest(db
, stmt
, 17, file
, PAKFIRE_DIGEST_SHA3_256
);
1129 ERROR(db
->pakfire
, "Could not bind SHA3-256 digest: %s\n",
1130 sqlite3_errmsg(db
->handle
));
1131 pakfire_file_unref(file
);
1137 r
= sqlite3_step(stmt
);
1138 } while (r
== SQLITE_BUSY
);
1141 if (r
!= SQLITE_DONE
) {
1142 ERROR(db
->pakfire
, "Could not add file to database: %s\n",
1143 sqlite3_errmsg(db
->handle
));
1144 pakfire_file_unref(file
);
1148 // Move on to next file
1149 pakfire_file_unref(file
);
1151 // Reset bound values
1152 sqlite3_reset(stmt
);
1160 sqlite3_finalize(stmt
);
1161 pakfire_filelist_unref(filelist
);
1166 static int pakfire_db_add_scriptlets(struct pakfire_db
* db
, unsigned long id
, struct pakfire_archive
* archive
) {
1167 sqlite3_stmt
* stmt
= NULL
;
1171 const char* sql
= "INSERT INTO scriptlets(pkg, type, scriptlet) VALUES(?, ?, ?)";
1173 // Prepare the statement
1174 r
= sqlite3_prepare_v2(db
->handle
, sql
, -1, &stmt
, NULL
);
1176 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s: %s\n",
1177 sql
, sqlite3_errmsg(db
->handle
));
1181 for (const char** type
= pakfire_scriptlet_types
; *type
; type
++) {
1182 // Fetch the scriptlet
1183 struct pakfire_scriptlet
* scriptlet
= pakfire_archive_get_scriptlet(archive
, *type
);
1188 r
= sqlite3_bind_int64(stmt
, 1, id
);
1190 ERROR(db
->pakfire
, "Could not bind id: %s\n", sqlite3_errmsg(db
->handle
));
1191 pakfire_scriptlet_unref(scriptlet
);
1196 r
= sqlite3_bind_text(stmt
, 2, *type
, -1, NULL
);
1198 ERROR(db
->pakfire
, "Could not bind type: %s\n", sqlite3_errmsg(db
->handle
));
1199 pakfire_scriptlet_unref(scriptlet
);
1203 const char* data
= pakfire_scriptlet_get_data(scriptlet
, &size
);
1206 r
= sqlite3_bind_text(stmt
, 3, data
, size
, NULL
);
1208 ERROR(db
->pakfire
, "Could not bind scriptlet: %s\n", sqlite3_errmsg(db
->handle
));
1209 pakfire_scriptlet_unref(scriptlet
);
1215 r
= sqlite3_step(stmt
);
1216 } while (r
== SQLITE_BUSY
);
1219 if (r
!= SQLITE_DONE
) {
1220 ERROR(db
->pakfire
, "Could not add scriptlet to database: %s\n",
1221 sqlite3_errmsg(db
->handle
));
1222 pakfire_scriptlet_unref(scriptlet
);
1226 pakfire_scriptlet_unref(scriptlet
);
1228 // Reset bound values
1229 sqlite3_reset(stmt
);
1237 sqlite3_finalize(stmt
);
1242 int pakfire_db_add_package(struct pakfire_db
* db
,
1243 struct pakfire_package
* pkg
, struct pakfire_archive
* archive
, int userinstalled
) {
1244 sqlite3_stmt
* stmt
= NULL
;
1247 // Begin a new transaction
1248 r
= pakfire_db_begin_transaction(db
);
1252 const char* sql
= "INSERT INTO "
1294 "CURRENT_TIMESTAMP, "
1303 // Prepare the statement
1304 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
1305 if (r
!= SQLITE_OK
) {
1306 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s: %s\n",
1307 sql
, sqlite3_errmsg(db
->handle
));
1312 const char* name
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_NAME
);
1314 r
= sqlite3_bind_text(stmt
, 1, name
, -1, NULL
);
1316 ERROR(db
->pakfire
, "Could not bind name: %s\n", sqlite3_errmsg(db
->handle
));
1321 const char* evr
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_EVR
);
1323 r
= sqlite3_bind_text(stmt
, 2, evr
, -1, NULL
);
1325 ERROR(db
->pakfire
, "Could not bind evr: %s\n", sqlite3_errmsg(db
->handle
));
1330 const char* arch
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_ARCH
);
1332 r
= sqlite3_bind_text(stmt
, 3, arch
, -1, NULL
);
1334 ERROR(db
->pakfire
, "Could not bind arch: %s\n", sqlite3_errmsg(db
->handle
));
1339 const char* groups
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_GROUPS
);
1342 r
= sqlite3_bind_text(stmt
, 4, groups
, -1, NULL
);
1344 ERROR(db
->pakfire
, "Could not bind groups: %s\n", sqlite3_errmsg(db
->handle
));
1350 r
= sqlite3_bind_null(stmt
, 4);
1356 const char* filename
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_FILENAME
);
1358 r
= sqlite3_bind_text(stmt
, 5, filename
, -1, NULL
);
1360 ERROR(db
->pakfire
, "Could not bind filename: %s\n", sqlite3_errmsg(db
->handle
));
1365 unsigned long long size
= pakfire_package_get_num(pkg
, PAKFIRE_PKG_DOWNLOADSIZE
, 0);
1367 r
= sqlite3_bind_int64(stmt
, 6, size
);
1369 ERROR(db
->pakfire
, "Could not bind size: %s\n", sqlite3_errmsg(db
->handle
));
1373 // Bind installed size
1374 unsigned long long inst_size
= pakfire_package_get_num(pkg
, PAKFIRE_PKG_INSTALLSIZE
, 0);
1376 r
= sqlite3_bind_int64(stmt
, 7, inst_size
);
1378 ERROR(db
->pakfire
, "Could not bind inst_size: %s\n", sqlite3_errmsg(db
->handle
));
1382 const unsigned char* digest
= NULL
;
1383 enum pakfire_digest_types digest_type
= 0;
1384 size_t digest_length
= 0;
1387 digest
= pakfire_package_get_digest(pkg
, &digest_type
, &digest_length
);
1389 ERROR(db
->pakfire
, "Could not fetch the package's digest: %m\n");
1394 // Set the digest type
1395 r
= sqlite3_bind_int64(stmt
, 8, digest_type
);
1397 ERROR(db
->pakfire
, "Could not bind digest type: %s\n", sqlite3_errmsg(db
->handle
));
1402 r
= sqlite3_bind_blob(stmt
, 9, digest
, digest_length
, NULL
);
1404 ERROR(db
->pakfire
, "Could not bind digest: %s\n", sqlite3_errmsg(db
->handle
));
1409 const char* license
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_LICENSE
);
1411 r
= sqlite3_bind_text(stmt
, 10, license
, -1, NULL
);
1413 ERROR(db
->pakfire
, "Could not bind license: %s\n", sqlite3_errmsg(db
->handle
));
1418 const char* summary
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_SUMMARY
);
1420 r
= sqlite3_bind_text(stmt
, 11, summary
, -1, NULL
);
1422 ERROR(db
->pakfire
, "Could not bind summary: %s\n", sqlite3_errmsg(db
->handle
));
1427 const char* description
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_DESCRIPTION
);
1429 r
= sqlite3_bind_text(stmt
, 12, description
, -1, NULL
);
1431 ERROR(db
->pakfire
, "Could not bind description: %s\n", sqlite3_errmsg(db
->handle
));
1436 const char* uuid
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_UUID
);
1438 r
= sqlite3_bind_text(stmt
, 13, uuid
, -1, NULL
);
1440 ERROR(db
->pakfire
, "Could not bind uuid: %s\n", sqlite3_errmsg(db
->handle
));
1445 const char* vendor
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_VENDOR
);
1447 r
= sqlite3_bind_text(stmt
, 14, vendor
, -1, NULL
);
1449 ERROR(db
->pakfire
, "Could not bind vendor: %s\n", sqlite3_errmsg(db
->handle
));
1454 const char* build_host
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_BUILD_HOST
);
1456 r
= sqlite3_bind_text(stmt
, 15, build_host
, -1, NULL
);
1458 ERROR(db
->pakfire
, "Could not bind build_host: %s\n", sqlite3_errmsg(db
->handle
));
1463 time_t build_time
= pakfire_package_get_num(pkg
, PAKFIRE_PKG_BUILD_TIME
, 0);
1465 r
= sqlite3_bind_int64(stmt
, 16, build_time
);
1467 ERROR(db
->pakfire
, "Could not bind build_time: %s\n", sqlite3_errmsg(db
->handle
));
1471 // Bind repository name
1472 struct pakfire_repo
* repo
= pakfire_package_get_repo(pkg
);
1474 const char* repo_name
= pakfire_repo_get_name(repo
);
1475 pakfire_repo_unref(repo
);
1477 r
= sqlite3_bind_text(stmt
, 17, repo_name
, -1, NULL
);
1483 r
= sqlite3_bind_null(stmt
, 17);
1488 // installed by the user?
1489 r
= sqlite3_bind_int(stmt
, 18, userinstalled
);
1491 ERROR(db
->pakfire
, "Could not bind userinstalled: %s\n", sqlite3_errmsg(db
->handle
));
1495 // Source package name
1496 const char* source_name
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_SOURCE_NAME
);
1498 r
= sqlite3_bind_text(stmt
, 19, source_name
, -1, NULL
);
1502 r
= sqlite3_bind_null(stmt
, 19);
1508 const char* source_evr
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_SOURCE_EVR
);
1510 r
= sqlite3_bind_text(stmt
, 20, source_evr
, -1, NULL
);
1514 r
= sqlite3_bind_null(stmt
, 20);
1520 const char* source_arch
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_SOURCE_ARCH
);
1522 r
= sqlite3_bind_text(stmt
, 21, source_arch
, -1, NULL
);
1526 r
= sqlite3_bind_null(stmt
, 21);
1532 const char* distribution
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_DISTRO
);
1534 r
= sqlite3_bind_text(stmt
, 22, distribution
, -1, NULL
);
1538 r
= sqlite3_bind_null(stmt
, 22);
1545 r
= sqlite3_step(stmt
);
1546 } while (r
== SQLITE_BUSY
);
1548 if (r
!= SQLITE_DONE
) {
1549 ERROR(db
->pakfire
, "Could not add package to database: %s\n",
1550 sqlite3_errmsg(db
->handle
));
1556 unsigned long packages_id
= sqlite3_last_insert_rowid(db
->handle
);
1559 r
= pakfire_db_add_dependencies(db
, packages_id
, pkg
);
1564 r
= pakfire_db_add_files(db
, packages_id
, archive
);
1569 r
= pakfire_db_add_scriptlets(db
, packages_id
, archive
);
1575 sqlite3_finalize(stmt
);
1577 // Commit or rollback
1579 pakfire_db_rollback(db
);
1581 r
= pakfire_db_commit(db
);
1586 int pakfire_db_remove_package(struct pakfire_db
* db
, struct pakfire_package
* pkg
) {
1587 sqlite3_stmt
* stmt
= NULL
;
1590 // Begin a new transaction
1591 r
= pakfire_db_begin_transaction(db
);
1595 // Fetch the package's UUID
1596 const char* uuid
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_UUID
);
1598 ERROR(db
->pakfire
, "Package has no UUID\n");
1603 r
= sqlite3_prepare_v2(db
->handle
,
1604 "DELETE FROM packages WHERE uuid = ?", -1, &stmt
, NULL
);
1606 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s\n",
1607 sqlite3_errmsg(db
->handle
));
1612 r
= sqlite3_bind_text(stmt
, 1, uuid
, -1, NULL
);
1614 ERROR(db
->pakfire
, "Could not bind uuid: %s\n", sqlite3_errmsg(db
->handle
));
1620 r
= sqlite3_step(stmt
);
1621 } while (r
== SQLITE_BUSY
);
1623 // Check if we have been successful
1624 if (r
!= SQLITE_DONE
) {
1625 ERROR(db
->pakfire
, "Could not delete package %s\n", uuid
);
1635 sqlite3_finalize(stmt
);
1637 // Commit or rollback
1639 pakfire_db_rollback(db
);
1641 r
= pakfire_db_commit(db
);
1646 struct pakfire_scriptlet
* pakfire_db_get_scriptlet(struct pakfire_db
* db
,
1647 struct pakfire_package
* pkg
, const char* type
) {
1648 struct pakfire_scriptlet
* scriptlet
= NULL
;
1649 sqlite3_stmt
* stmt
= NULL
;
1652 // Fetch the package's UUID
1653 const char* uuid
= pakfire_package_get_string(pkg
, PAKFIRE_PKG_UUID
);
1655 ERROR(db
->pakfire
, "Package has no UUID\n");
1659 const char* sql
= "SELECT scriptlets.scriptlet FROM packages \
1660 JOIN scriptlets ON packages.id = scriptlets.pkg \
1661 WHERE packages.uuid = ? AND scriptlets.type = ?";
1663 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
1665 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s %s\n",
1666 sql
, sqlite3_errmsg(db
->handle
));
1671 r
= sqlite3_bind_text(stmt
, 1, uuid
, -1, NULL
);
1673 ERROR(db
->pakfire
, "Could not bind uuid: %s\n", sqlite3_errmsg(db
->handle
));
1677 r
= sqlite3_bind_text(stmt
, 2, type
, -1, NULL
);
1679 ERROR(db
->pakfire
, "Could not bind type: %s\n", sqlite3_errmsg(db
->handle
));
1683 DEBUG(db
->pakfire
, "Searching for scriptlet for package %s of type %s\n", uuid
, type
);
1687 r
= sqlite3_step(stmt
);
1688 } while (r
== SQLITE_BUSY
);
1690 // We have some payload
1691 if (r
== SQLITE_ROW
) {
1692 const void* data
= sqlite3_column_blob(stmt
, 1);
1693 ssize_t size
= sqlite3_column_bytes(stmt
, 1);
1695 // Create a scriptlet object
1696 r
= pakfire_scriptlet_create(&scriptlet
, db
->pakfire
, type
, data
, size
);
1703 sqlite3_finalize(stmt
);
1708 static int pakfire_db_load_package(struct pakfire_db
* db
, struct pakfire_repo
* repo
, sqlite3_stmt
* stmt
) {
1709 struct pakfire_package
* pkg
= NULL
;
1713 const char* name
= (const char*)sqlite3_column_text(stmt
, 0);
1715 ERROR(db
->pakfire
, "Could not read name: %s\n", sqlite3_errmsg(db
->handle
));
1720 const char* evr
= (const char*)sqlite3_column_text(stmt
, 1);
1722 ERROR(db
->pakfire
, "Could not read evr: %s\n", sqlite3_errmsg(db
->handle
));
1727 const char* arch
= (const char*)sqlite3_column_text(stmt
, 2);
1729 ERROR(db
->pakfire
, "Could not read arch: %s\n", sqlite3_errmsg(db
->handle
));
1734 r
= pakfire_package_create(&pkg
, db
->pakfire
, repo
, name
, evr
, arch
);
1736 ERROR(db
->pakfire
, "Could not create package '%s-%s.%s': %m\n", name
, evr
, arch
);
1741 uint64_t id
= sqlite3_column_int64(stmt
, 3);
1743 r
= pakfire_package_set_num(pkg
, PAKFIRE_PKG_DBID
, id
);
1749 const char* groups
= (const char*)sqlite3_column_text(stmt
, 4);
1751 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_GROUPS
, groups
);
1757 const char* filename
= (const char*)sqlite3_column_text(stmt
, 5);
1759 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_FILENAME
, filename
);
1765 size_t size
= sqlite3_column_int64(stmt
, 6);
1767 r
= pakfire_package_set_num(pkg
, PAKFIRE_PKG_DOWNLOADSIZE
, size
);
1773 size
= sqlite3_column_int64(stmt
, 7);
1775 r
= pakfire_package_set_num(pkg
, PAKFIRE_PKG_INSTALLSIZE
, size
);
1781 enum pakfire_digest_types digest_type
= sqlite3_column_int64(stmt
, 8);
1782 size_t digest_length
= 0;
1787 const unsigned char* digest
= sqlite3_column_blob(stmt
, 9);
1788 if (digest_type
&& digest
) {
1789 pakfire_package_set_digest(pkg
, digest_type
, digest
, digest_length
);
1793 const char* license
= (const char*)sqlite3_column_text(stmt
, 10);
1795 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_LICENSE
, license
);
1801 const char* summary
= (const char*)sqlite3_column_text(stmt
, 11);
1803 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_SUMMARY
, summary
);
1809 const char* description
= (const char*)sqlite3_column_text(stmt
, 12);
1811 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_DESCRIPTION
, description
);
1817 const char* uuid
= (const char*)sqlite3_column_text(stmt
, 13);
1819 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_UUID
, uuid
);
1825 const char* vendor
= (const char*)sqlite3_column_text(stmt
, 14);
1827 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_VENDOR
, vendor
);
1833 const char* build_host
= (const char*)sqlite3_column_text(stmt
, 15);
1835 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_BUILD_HOST
, build_host
);
1841 time_t build_time
= sqlite3_column_int64(stmt
, 16);
1843 r
= pakfire_package_set_num(pkg
, PAKFIRE_PKG_BUILD_TIME
, build_time
);
1849 time_t install_time
= sqlite3_column_int64(stmt
, 17);
1851 r
= pakfire_package_set_num(pkg
, PAKFIRE_PKG_INSTALLTIME
, install_time
);
1856 // installed by user?
1857 int userinstalled
= sqlite3_column_int(stmt
, 18);
1859 pakfire_db_add_userinstalled(db
->pakfire
, name
);
1862 const char* files
= (const char*)sqlite3_column_text(stmt
, 19);
1864 r
= pakfire_package_set_filelist_from_string(pkg
, files
);
1871 const struct dependency
{
1873 const enum pakfire_package_key key
;
1874 } dependencies
[] = {
1875 { 20, PAKFIRE_PKG_PROVIDES
},
1876 { 21, PAKFIRE_PKG_PREREQUIRES
},
1877 { 22, PAKFIRE_PKG_REQUIRES
},
1878 { 23, PAKFIRE_PKG_CONFLICTS
},
1879 { 24, PAKFIRE_PKG_OBSOLETES
},
1880 { 25, PAKFIRE_PKG_RECOMMENDS
},
1881 { 26, PAKFIRE_PKG_SUGGESTS
},
1882 { 27, PAKFIRE_PKG_SUPPLEMENTS
},
1883 { 28, PAKFIRE_PKG_ENHANCES
},
1887 for (const struct dependency
* deps
= dependencies
; deps
->field
; deps
++) {
1888 const char* relations
= (const char*)sqlite3_column_text(stmt
, deps
->field
);
1890 r
= pakfire_str2deps(db
->pakfire
, pkg
, deps
->key
, relations
);
1897 const char* source_name
= (const char*)sqlite3_column_text(stmt
, 29);
1899 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_SOURCE_NAME
, source_name
);
1905 const char* source_evr
= (const char*)sqlite3_column_text(stmt
, 30);
1907 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_SOURCE_EVR
, source_evr
);
1913 const char* source_arch
= (const char*)sqlite3_column_text(stmt
, 31);
1915 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_SOURCE_ARCH
, source_arch
);
1921 const char* distribution
= (const char*)sqlite3_column_text(stmt
, 32);
1923 r
= pakfire_package_set_string(pkg
, PAKFIRE_PKG_DESCRIPTION
, description
);
1933 pakfire_package_unref(pkg
);
1938 int pakfire_db_load(struct pakfire_db
* db
, struct pakfire_repo
* repo
) {
1939 sqlite3_stmt
* stmt
= NULL
;
1942 DEBUG(db
->pakfire
, "Loading package database...\n");
1944 // Drop contents of the repository
1945 pakfire_repo_clear(repo
);
1947 // Save starting time
1948 clock_t t_start
= clock();
1970 "strftime('%s', installed) AS installed, "
1973 "SELECT group_concat(path, '\n') FROM files WHERE files.pkg = packages.id"
1976 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1977 "WHERE d.pkg = packages.id AND d.type = 'provides'"
1980 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1981 "WHERE d.pkg = packages.id AND d.type = 'prerequires'"
1982 ") AS prerequires, "
1984 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1985 "WHERE d.pkg = packages.id AND d.type = 'requires'"
1988 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1989 "WHERE d.pkg = packages.id AND d.type = 'conflicts'"
1992 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1993 "WHERE d.pkg = packages.id AND d.type = 'obsoletes'"
1996 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1997 "WHERE d.pkg = packages.id AND d.type = 'recommends'"
2000 "SELECT group_concat(dependency, '\n') FROM dependencies d "
2001 "WHERE d.pkg = packages.id AND d.type = 'suggests'"
2004 "SELECT group_concat(dependency, '\n') FROM dependencies d "
2005 "WHERE d.pkg = packages.id AND d.type = 'supplements'"
2006 ") AS supplements, "
2008 "SELECT group_concat(dependency, '\n') FROM dependencies d "
2009 "WHERE d.pkg = packages.id AND d.type = 'enhances'"
2019 // Prepare the statement
2020 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
2022 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s %s\n",
2023 sql
, sqlite3_errmsg(db
->handle
));
2029 r
= sqlite3_step(stmt
);
2032 // Retry if the database was busy
2038 r
= pakfire_db_load_package(db
, repo
, stmt
);
2043 // All rows have been processed
2047 // Go to error in any other cases
2054 // Save time when we finished
2057 DEBUG(db
->pakfire
, "Loading package database completed in %.4fms\n",
2058 (double)(t_end
- t_start
) * 1000 / CLOCKS_PER_SEC
);
2060 // Mark repository as changed
2061 pakfire_repo_has_changed(repo
);
2068 ERROR(db
->pakfire
, "Failed reading package database: %m\n");
2069 pakfire_repo_clear(repo
);
2073 sqlite3_finalize(stmt
);
2078 static int pakfire_db_load_file_digest(struct pakfire_db
* db
, struct pakfire_file
* file
,
2079 sqlite3_stmt
* stmt
, const enum pakfire_digest_types type
, const int field
) {
2081 const unsigned char* digest
= sqlite3_column_blob(stmt
, field
);
2083 // Nothing further to do if field is NULL
2087 // Length of the stored value
2088 const size_t length
= sqlite3_column_bytes(stmt
, field
);
2091 return pakfire_file_set_digest(file
, type
, digest
, length
);
2094 static int pakfire_db_load_file(struct pakfire_db
* db
, struct pakfire_filelist
* filelist
,
2095 sqlite3_stmt
* stmt
) {
2096 struct pakfire_file
* file
= NULL
;
2097 char abspath
[PATH_MAX
];
2100 // Create a new file object
2101 r
= pakfire_file_create(&file
, db
->pakfire
);
2106 const char* path
= (const char*)sqlite3_column_text(stmt
, 0);
2108 // Abort if no path is set
2110 ERROR(db
->pakfire
, "File has no path\n");
2116 r
= pakfire_file_set_path(file
, path
);
2118 ERROR(db
->pakfire
, "%s: Could not set path '%s': %m\n", path
, path
);
2122 // Make the absolute path
2123 r
= pakfire_path(db
->pakfire
, abspath
, "%s", path
);
2125 ERROR(db
->pakfire
, "%s: Could not make absolute path: %m\n", path
);
2129 // Set the absolute path
2130 r
= pakfire_file_set_abspath(file
, abspath
);
2132 ERROR(db
->pakfire
, "%s: Could not set absolute path %s: %m\n", path
, abspath
);
2137 size_t size
= sqlite3_column_int64(stmt
, 1);
2139 pakfire_file_set_size(file
, size
);
2142 mode_t mode
= sqlite3_column_int(stmt
, 2);
2144 pakfire_file_set_mode(file
, mode
);
2147 const char* uname
= (const char*)sqlite3_column_text(stmt
, 3);
2149 // Abort if no user is set
2151 ERROR(db
->pakfire
, "%s: No user\n", path
);
2157 r
= pakfire_file_set_uname(file
, uname
);
2159 ERROR(db
->pakfire
, "%s: Could not set user '%s': %m\n", path
, uname
);
2164 const char* gname
= (const char*)sqlite3_column_text(stmt
, 4);
2166 // Abort if no group is set
2168 ERROR(db
->pakfire
, "%s: No group\n", path
);
2174 r
= pakfire_file_set_gname(file
, gname
);
2176 ERROR(db
->pakfire
, "%s: Could not set group '%s': %m\n", path
, gname
);
2181 time_t ctime
= sqlite3_column_int64(stmt
, 5);
2183 pakfire_file_set_ctime(file
, ctime
);
2186 time_t mtime
= sqlite3_column_int64(stmt
, 6);
2188 pakfire_file_set_mtime(file
, mtime
);
2191 r
= pakfire_db_load_file_digest(db
, file
, stmt
, PAKFIRE_DIGEST_SHA2_512
, 7);
2196 r
= pakfire_db_load_file_digest(db
, file
, stmt
, PAKFIRE_DIGEST_SHA2_256
, 8);
2200 // BLAKE2b512 Digest
2201 r
= pakfire_db_load_file_digest(db
, file
, stmt
, PAKFIRE_DIGEST_BLAKE2B512
, 9);
2205 // BLAKE2s256 Digest
2206 r
= pakfire_db_load_file_digest(db
, file
, stmt
, PAKFIRE_DIGEST_BLAKE2S256
, 10);
2211 r
= pakfire_db_load_file_digest(db
, file
, stmt
, PAKFIRE_DIGEST_SHA3_512
, 11);
2216 r
= pakfire_db_load_file_digest(db
, file
, stmt
, PAKFIRE_DIGEST_SHA3_256
, 12);
2220 // Append the file to the filelist
2221 r
= pakfire_filelist_add(filelist
, file
);
2227 pakfire_file_unref(file
);
2232 int pakfire_db_filelist(struct pakfire_db
* db
, struct pakfire_filelist
** filelist
) {
2233 struct pakfire_filelist
* list
= NULL
;
2234 sqlite3_stmt
* stmt
= NULL
;
2248 "digest_blake2b512, "
2249 "digest_blake2s256, "
2256 // Prepare the statement
2257 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
2259 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s %s\n",
2260 sql
, sqlite3_errmsg(db
->handle
));
2264 // Create a new filelist
2265 r
= pakfire_filelist_create(&list
, db
->pakfire
);
2269 // Iterate over all rows
2272 r
= sqlite3_step(stmt
);
2275 // Retry if the database was busy
2281 r
= pakfire_db_load_file(db
, list
, stmt
);
2286 // All rows have been processed
2291 // Go to error in any other cases
2298 // Return the filelist
2299 *filelist
= pakfire_filelist_ref(list
);
2303 ERROR(db
->pakfire
, "Could not fetch filelist: %m\n");
2306 sqlite3_finalize(stmt
);
2308 pakfire_filelist_unref(list
);
2313 int pakfire_db_package_filelist(struct pakfire_db
* db
, struct pakfire_filelist
** filelist
,
2314 struct pakfire_package
* pkg
) {
2315 struct pakfire_filelist
* fl
= NULL
;
2316 sqlite3_stmt
* stmt
= NULL
;
2319 // Fetch the package ID
2320 uint64_t id
= pakfire_package_get_num(pkg
, PAKFIRE_PKG_DBID
, 0);
2322 ERROR(db
->pakfire
, "Package did not have an ID\n");
2326 // Create a new filelist
2327 r
= pakfire_filelist_create(&fl
, db
->pakfire
);
2329 ERROR(db
->pakfire
, "Could not create filelist: %m\n");
2344 "digest_blake2b512, "
2345 "digest_blake2s256, "
2350 // Select all files that belong to this package
2354 // Filter out any files that are also in a different package (i.e. an update
2355 // that has already been installed and this is the cleanup of the obsolete pkg)
2360 "FROM files AS duplicates "
2362 "files.path = duplicates.path "
2364 "files.pkg != duplicates.pkg"
2367 // Return ordered by path
2371 // Prepare the statement
2372 r
= sqlite3_prepare_v2(db
->handle
, sql
, strlen(sql
), &stmt
, NULL
);
2374 ERROR(db
->pakfire
, "Could not prepare SQL statement: %s %s\n",
2375 sql
, sqlite3_errmsg(db
->handle
));
2380 r
= sqlite3_bind_int64(stmt
, 1, id
);
2382 ERROR(db
->pakfire
, "Could not bind package ID: %s\n", sqlite3_errmsg(db
->handle
));
2388 r
= sqlite3_step(stmt
);
2391 // Retry if the database was busy
2397 r
= pakfire_db_load_file(db
, fl
, stmt
);
2402 // All rows have been processed
2406 // Go to error in any other cases
2413 *filelist
= pakfire_filelist_ref(fl
);
2418 sqlite3_finalize(stmt
);
2420 pakfire_filelist_unref(fl
);