src/libpakfire/db.c

   1 /*#############################################################################
   2 #                                                                             #
   3 # Pakfire - The IPFire package management system                              #
   4 # Copyright (C) 2021 Pakfire development team                                 #
   5 #                                                                             #
   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.                                         #
  10 #                                                                             #
  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.                                #
  15 #                                                                             #
  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/>.       #
  18 #                                                                             #
  19 #############################################################################*/
  20
  21 #include <errno.h>
  22 #include <linux/limits.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25
  26 #include <openssl/sha.h>
  27 #include <solv/solver.h>
  28 #include <sqlite3.h>
  29
  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>
  42
  43 #define DATABASE_PATH PAKFIRE_PRIVATE_DIR "/packages.db"
  44
  45 #define CURRENT_SCHEMA 8
  46 #define SCHEMA_MIN_SUP 7
  47
  48 struct pakfire_db {
  49         struct pakfire* pakfire;
  50         int nrefs;
  51
  52         char path[PATH_MAX];
  53         int mode;
  54
  55         sqlite3* handle;
  56         int schema;
  57         time_t last_modified_at;
  58 };
  59
  60 static void logging_callback(void* data, int r, const char* msg) {
  61         struct pakfire* pakfire = (struct pakfire*)data;
  62
  63         ERROR(pakfire, "Database Error: %s: %s\n",
  64                 sqlite3_errstr(r), msg);
  65 }
  66
  67 static sqlite3_value* pakfire_db_get(struct pakfire_db* db, const char* key) {
  68         sqlite3_stmt* stmt = NULL;
  69         sqlite3_value* val = NULL;
  70         int r;
  71
  72         const char* sql = "SELECT val FROM settings WHERE key = ?";
  73
  74         // Prepare the statement
  75         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
  76         if (r != SQLITE_OK) {
  77                 //ERROR(db->pakfire, "Could not prepare SQL statement: %s: %s\n",
  78                 //      sql, sqlite3_errmsg(db->handle));
  79                 return NULL;
  80         }
  81
  82         // Bind key
  83         r = sqlite3_bind_text(stmt, 1, key, strlen(key), NULL);
  84         if (r != SQLITE_OK) {
  85                 ERROR(db->pakfire, "Could not bind key: %s\n", sqlite3_errmsg(db->handle));
  86                 goto ERROR;
  87         }
  88
  89         // Execute the statement
  90         do {
  91                 r = sqlite3_step(stmt);
  92         } while (r == SQLITE_BUSY);
  93
  94         // We should have read a row
  95         if (r != SQLITE_ROW)
  96                 goto ERROR;
  97
  98         // Read value
  99         val = sqlite3_column_value(stmt, 0);
 100         if (!val) {
 101                 ERROR(db->pakfire, "Could not read value\n");
 102                 goto ERROR;
 103         }
 104
 105         // Copy value onto the heap
 106         val = sqlite3_value_dup(val);
 107
 108 ERROR:
 109         if (stmt)
 110                 sqlite3_finalize(stmt);
 111
 112         return val;
 113 }
 114
 115 static char* pakfire_db_get_string(struct pakfire_db* db, const char* key) {
 116         char* s = NULL;
 117
 118         // Fetch the value from the database
 119         sqlite3_value* value = pakfire_db_get(db, key);
 120         if (!value)
 121                 return NULL;
 122
 123         // Extract the value as string
 124         const char* p = (const char*)sqlite3_value_text(value);
 125         if (!p)
 126                 goto ERROR;
 127
 128         // Copy string to heap
 129         s = strdup(p);
 130
 131 ERROR:
 132         if (value)
 133                 sqlite3_value_free(value);
 134
 135         return s;
 136 }
 137
 138 static int pakfire_db_set_string(struct pakfire_db* db, const char* key, const char* val) {
 139         sqlite3_stmt* stmt = NULL;
 140         int r;
 141
 142         DEBUG(db->pakfire, "Setting %s to '%s'\n", key, val);
 143
 144         const char* sql = "INSERT INTO settings(key, val) VALUES(?, ?) \
 145                 ON CONFLICT (key) DO UPDATE SET val = excluded.val";
 146
 147         // Prepare statement
 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));
 152                 return 1;
 153         }
 154
 155         // Bind key
 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));
 159                 goto ERROR;
 160         }
 161
 162         // Bind val
 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));
 166                 goto ERROR;
 167         }
 168
 169         // Execute the statement
 170         do {
 171                 r = sqlite3_step(stmt);
 172         } while (r == SQLITE_BUSY);
 173
 174         // Set return code
 175         r = (r == SQLITE_OK);
 176
 177 ERROR:
 178         if (stmt)
 179                 sqlite3_finalize(stmt);
 180
 181         return r;
 182 }
 183
 184 static int pakfire_db_set_int(struct pakfire_db* db, const char* key, int val) {
 185         sqlite3_stmt* stmt = NULL;
 186         int r;
 187
 188         DEBUG(db->pakfire, "Setting %s to '%d'\n", key, val);
 189
 190         const char* sql = "INSERT INTO settings(key, val) VALUES(?, ?) \
 191                 ON CONFLICT (key) DO UPDATE SET val = excluded.val";
 192
 193         // Prepare statement
 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));
 198                 return 1;
 199         }
 200
 201         // Bind key
 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));
 205                 goto ERROR;
 206         }
 207
 208         // Bind val
 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));
 212                 goto ERROR;
 213         }
 214
 215         // Execute the statement
 216         do {
 217                 r = sqlite3_step(stmt);
 218         } while (r == SQLITE_BUSY);
 219
 220         // Set return code
 221         r = (r == SQLITE_OK);
 222
 223 ERROR:
 224         if (stmt)
 225                 sqlite3_finalize(stmt);
 226
 227         return r;
 228 }
 229
 230 static time_t pakfire_read_modification_time(struct pakfire_db* db) {
 231         time_t t = 0;
 232
 233         // Fetch the value from the database
 234         sqlite3_value* value = pakfire_db_get(db, "last_modified_at");
 235         if (value) {
 236                 t = sqlite3_value_int64(value);
 237                 sqlite3_value_free(value);
 238         } else {
 239                 DEBUG(db->pakfire, "Could not find last modification timestamp\n");
 240         }
 241
 242         return t;
 243 }
 244
 245 static int pakfire_update_modification_time(struct pakfire_db* db) {
 246         // Get the current time in UTC
 247         time_t t = time(NULL);
 248
 249         // Store it in the database
 250         int r = pakfire_db_set_int(db, "last_modified_at", t);
 251         if (r)
 252                 return r;
 253
 254         // Update the last modification timestamp
 255         db->last_modified_at = t;
 256
 257         return r;
 258 }
 259
 260 static int pakfire_db_execute(struct pakfire_db* db, const char* stmt) {
 261         int r;
 262
 263         DEBUG(db->pakfire, "Executing database query: %s\n", stmt);
 264
 265         do {
 266                 r = sqlite3_exec(db->handle, stmt, NULL, NULL, NULL);
 267         } while (r == SQLITE_BUSY);
 268
 269         // Log any errors
 270         if (r) {
 271                 ERROR(db->pakfire, "Database query failed: %s\n", sqlite3_errmsg(db->handle));
 272         }
 273
 274         return r;
 275 }
 276
 277 static int pakfire_db_begin_transaction(struct pakfire_db* db) {
 278         return pakfire_db_execute(db, "BEGIN TRANSACTION");
 279 }
 280
 281 static int pakfire_db_commit(struct pakfire_db* db) {
 282         /*
 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.
 286         */
 287         if (db->mode == PAKFIRE_DB_READWRITE) {
 288                 int r = pakfire_update_modification_time(db);
 289                 if (r)
 290                         return r;
 291         }
 292
 293         return pakfire_db_execute(db, "COMMIT");
 294 }
 295
 296 static int pakfire_db_rollback(struct pakfire_db* db) {
 297         return pakfire_db_execute(db, "ROLLBACK");
 298 }
 299
 300 /*
 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.
 303 */
 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");
 307 }
 308
 309 static void pakfire_db_free(struct pakfire_db* db) {
 310         if (db->handle) {
 311                 // Optimize the database before it is being closed
 312                 pakfire_db_optimize(db);
 313
 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));
 319                 }
 320         }
 321
 322         pakfire_unref(db->pakfire);
 323
 324         free(db);
 325 }
 326
 327 static int pakfire_db_get_schema(struct pakfire_db* db) {
 328         sqlite3_value* value = pakfire_db_get(db, "schema");
 329         if (!value)
 330                 return -1;
 331
 332         int schema = sqlite3_value_int64(value);
 333         sqlite3_value_free(value);
 334
 335         DEBUG(db->pakfire, "Database has schema version %d\n", schema);
 336
 337         return schema;
 338 }
 339
 340 static int pakfire_db_create_schema(struct pakfire_db* db) {
 341         int r;
 342
 343         // Create settings table
 344         r = pakfire_db_execute(db, "CREATE TABLE IF NOT EXISTS settings(key TEXT, val TEXT)");
 345         if (r)
 346                 return 1;
 347
 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)");
 350         if (r)
 351                 return 1;
 352
 353         // Create packages table
 354         r = pakfire_db_execute(db,
 355                 "CREATE TABLE IF NOT EXISTS packages("
 356                         "id              INTEGER PRIMARY KEY, "
 357                         "name            TEXT, "
 358                         "evr             TEXT, "
 359                         "arch            TEXT, "
 360                         "groups          TEXT, "
 361                         "filename        TEXT, "
 362                         "size            INTEGER, "
 363                         "inst_size       INTEGER, "
 364                         "digest_type     INTEGER, "
 365                         "digest          BLOB, "
 366                         "license         TEXT, "
 367                         "summary         TEXT, "
 368                         "description     TEXT, "
 369                         "uuid            TEXT, "
 370                         "vendor          TEXT, "
 371                         "build_host      TEXT, "
 372                         "build_time      INTEGER, "
 373                         "installed       INTEGER, "
 374                         "userinstalled   INTEGER, "
 375                         "repository      TEXT, "
 376                         "source_name     TEXT, "
 377                         "source_evr      TEXT, "
 378                         "source_arch     TEXT, "
 379                         "distribution    TEXT"
 380                 ")");
 381         if (r)
 382                 return 1;
 383
 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)");
 386         if (r)
 387                 return 1;
 388
 389         // packages: Create unique index over UUID
 390         r = pakfire_db_execute(db, "CREATE UNIQUE INDEX IF NOT EXISTS packages_uuid ON packages(uuid)");
 391         if (r)
 392                 return 1;
 393
 394         // Create dependencies table
 395         r = pakfire_db_execute(db,
 396                 "CREATE TABLE IF NOT EXISTS dependencies("
 397                         "pkg            INTEGER, "
 398                         "type           TEXT, "
 399                         "dependency     TEXT, "
 400                         "FOREIGN KEY (pkg) REFERENCES packages(id) ON DELETE CASCADE"
 401                 ")");
 402         if (r)
 403                 return r;
 404
 405         // dependencies: Add index over packages
 406         r = pakfire_db_execute(db, "CREATE INDEX IF NOT EXISTS dependencies_pkg_index ON dependencies(pkg)");
 407         if (r)
 408                 return r;
 409
 410         // Create files table
 411         r = pakfire_db_execute(db,
 412                 "CREATE TABLE IF NOT EXISTS files("
 413                         "id                INTEGER PRIMARY KEY, "
 414                         "path              TEXT, "
 415                         "pkg               INTEGER, "
 416                         "size              INTEGER, "
 417                         "config            INTEGER, "
 418                         "datafile          INTEGER, "
 419                         "mode              INTEGER, "
 420                         "uname             TEXT, "
 421                         "gname             TEXT, "
 422                         "ctime             INTEGER, "
 423                         "mtime             INTEGER, "
 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"
 432                 ")");
 433         if (r)
 434                 return 1;
 435
 436         // files: Add index over packages
 437         r = pakfire_db_execute(db, "CREATE INDEX IF NOT EXISTS files_pkg_index ON files(pkg)");
 438         if (r)
 439                 return 1;
 440
 441         // files: Add index over path
 442         r = pakfire_db_execute(db, "CREATE INDEX IF NOT EXISTS files_path_index ON files(path)");
 443         if (r)
 444                 return 1;
 445
 446         // Create scriptlets table
 447         r = pakfire_db_execute(db,
 448                 "CREATE TABLE IF NOT EXISTS scriptlets("
 449                         "id             INTEGER PRIMARY KEY, "
 450                         "pkg            INTEGER, "
 451                         "type           TEXT, "
 452                         "scriptlet      TEXT, "
 453                         "FOREIGN KEY (pkg) REFERENCES packages(id) ON DELETE CASCADE"
 454                 ")");
 455         if (r)
 456                 return 1;
 457
 458         // scriptlets: Add index over packages
 459         r = pakfire_db_execute(db, "CREATE INDEX IF NOT EXISTS scriptlets_pkg_index ON scriptlets(pkg)");
 460         if (r)
 461                 return 1;
 462
 463         const char* arch = pakfire_get_arch(db->pakfire);
 464
 465         // Set architecture
 466         r = pakfire_db_set_string(db, "arch", arch);
 467         if (r) {
 468                 ERROR(db->pakfire, "Could not set architecture\n");
 469                 return r;
 470         }
 471
 472         return 0;
 473 }
 474
 475 static int pakfire_db_migrate_to_schema_8(struct pakfire_db* db) {
 476         // packages: Drop build_id column
 477
 478         // Add foreign keys
 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.
 481
 482         return 0;
 483 }
 484
 485 static int pakfire_db_migrate_schema(struct pakfire_db* db) {
 486         int r;
 487
 488         while (db->schema < CURRENT_SCHEMA) {
 489                 // Begin a new transaction
 490                 r = pakfire_db_begin_transaction(db);
 491                 if (r)
 492                         goto ROLLBACK;
 493
 494                 switch (db->schema) {
 495                         // No schema exists
 496                         case -1:
 497                                 r = pakfire_db_create_schema(db);
 498                                 if (r)
 499                                         goto ROLLBACK;
 500
 501                                 db->schema = CURRENT_SCHEMA;
 502                                 break;
 503
 504                         case 7:
 505                                 r = pakfire_db_migrate_to_schema_8(db);
 506                                 if (r)
 507                                         goto ROLLBACK;
 508
 509                                 db->schema++;
 510                                 break;
 511
 512                         default:
 513                                 ERROR(db->pakfire, "Cannot migrate database from schema %d\n", db->schema);
 514                                 goto ROLLBACK;
 515                 }
 516
 517                 // Update the schema version
 518                 r = pakfire_db_set_int(db, "schema", CURRENT_SCHEMA);
 519                 if (r)
 520                         goto ROLLBACK;
 521
 522                 // All done, commit!
 523                 r = pakfire_db_commit(db);
 524                 if (r)
 525                         goto ROLLBACK;
 526         }
 527
 528         return 0;
 529
 530 ROLLBACK:
 531         pakfire_db_rollback(db);
 532
 533         return 1;
 534 }
 535
 536 static int pakfire_db_check_arch(struct pakfire_db* db) {
 537         int r = 1;
 538
 539         // Fetch database architecture
 540         char* db_arch = pakfire_db_get_string(db, "arch");
 541         if (!db_arch) {
 542                 ERROR(db->pakfire, "Database is of an unknown architecture\n");
 543                 goto ERROR;
 544         }
 545
 546         // Fetch the running architecture
 547         const char* arch = pakfire_get_arch(db->pakfire);
 548         if (!arch)
 549                 goto ERROR;
 550
 551         // They should match
 552         if (strcmp(db_arch, arch) == 0)
 553                 r = 0;
 554
 555 ERROR:
 556         if (db_arch)
 557                 free(db_arch);
 558
 559         return r;
 560 }
 561
 562 static int pakfire_db_setup(struct pakfire_db* db) {
 563         int r;
 564
 565         // Setup logging
 566         sqlite3_config(SQLITE_CONFIG_LOG, logging_callback, db->pakfire);
 567
 568         // Enable foreign keys
 569         pakfire_db_execute(db, "PRAGMA foreign_keys = ON");
 570
 571         // Make LIKE case-sensitive
 572         pakfire_db_execute(db, "PRAGMA case_sensitive_like = ON");
 573
 574         // Fetch the current schema
 575         db->schema = pakfire_db_get_schema(db);
 576
 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",
 580                         db->schema);
 581                 return 1;
 582         }
 583
 584         // Read modification timestamp
 585         db->last_modified_at = pakfire_read_modification_time(db);
 586
 587         DEBUG(db->pakfire, "The database was last modified at %ld\n", db->last_modified_at);
 588
 589         // Done when not in read-write mode
 590         if (db->mode != PAKFIRE_DB_READWRITE)
 591                 return 0;
 592
 593         // Disable secure delete
 594         pakfire_db_execute(db, "PRAGMA secure_delete = OFF");
 595
 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));
 601                 return 1;
 602         }
 603
 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));
 609                 return 1;
 610         }
 611
 612         // Create or migrate schema
 613         r = pakfire_db_migrate_schema(db);
 614         if (r)
 615                 return r;
 616
 617         return 0;
 618 }
 619
 620 int pakfire_db_open(struct pakfire_db** db, struct pakfire* pakfire, int flags) {
 621         int r = 1;
 622
 623         struct pakfire_db* o = calloc(1, sizeof(*o));
 624         if (!o)
 625                 return -ENOMEM;
 626
 627         o->pakfire = pakfire_ref(pakfire);
 628         o->nrefs = 1;
 629
 630         int sqlite3_flags = 0;
 631
 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;
 636         } else {
 637                 o->mode = PAKFIRE_DB_READONLY;
 638                 sqlite3_flags |= SQLITE_OPEN_READONLY;
 639         }
 640
 641         // Make the filename
 642         r = pakfire_path(o->pakfire, o->path, "%s", DATABASE_PATH);
 643         if (r)
 644                 goto END;
 645
 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));
 651
 652                 r = 1;
 653                 goto END;
 654         }
 655
 656         // Setup the database
 657         r = pakfire_db_setup(o);
 658         if (r)
 659                 goto END;
 660
 661         // Check for compatible architecture
 662         r = pakfire_db_check_arch(o);
 663         if (r)
 664                 goto END;
 665
 666         *db = o;
 667         r = 0;
 668
 669 END:
 670         if (r)
 671                 pakfire_db_free(o);
 672
 673         return r;
 674 }
 675
 676 struct pakfire_db* pakfire_db_ref(struct pakfire_db* db) {
 677         db->nrefs++;
 678
 679         return db;
 680 }
 681
 682 struct pakfire_db* pakfire_db_unref(struct pakfire_db* db) {
 683         if (--db->nrefs > 0)
 684                 return db;
 685
 686         pakfire_db_free(db);
 687
 688         return NULL;
 689 }
 690
 691 static unsigned long pakfire_db_integrity_check(struct pakfire_db* db) {
 692         sqlite3_stmt* stmt = NULL;
 693         int r;
 694
 695         r = sqlite3_prepare_v2(db->handle, "PRAGMA integrity_check", -1, &stmt, NULL);
 696         if (r) {
 697                 ERROR(db->pakfire, "Could not prepare integrity check: %s\n",
 698                         sqlite3_errmsg(db->handle));
 699                 return 1;
 700         }
 701
 702         // Count any errors
 703         unsigned long errors = 0;
 704
 705         while (1) {
 706                 do {
 707                         r = sqlite3_step(stmt);
 708                 } while (r == SQLITE_BUSY);
 709
 710                 if (r == SQLITE_ROW) {
 711                         const char* error = (const char*)sqlite3_column_text(stmt, 0);
 712
 713                         // If the message is "ok", the database has passed the check
 714                         if (strcmp(error, "ok") == 0)
 715                                 continue;
 716
 717                         // Increment error counter
 718                         errors++;
 719
 720                         // Log the message
 721                         ERROR(db->pakfire, "%s\n", error);
 722
 723                 // Break on anything else
 724                 } else
 725                         break;
 726         }
 727
 728         sqlite3_finalize(stmt);
 729
 730         if (errors)
 731                 ERROR(db->pakfire, "Database integrity check failed\n");
 732         else
 733                 INFO(db->pakfire, "Database integrity check passed\n");
 734
 735         return errors;
 736 }
 737
 738 static unsigned long pakfire_db_foreign_key_check(struct pakfire_db* db) {
 739         sqlite3_stmt* stmt = NULL;
 740         int r;
 741
 742         r = sqlite3_prepare_v2(db->handle, "PRAGMA foreign_key_check", -1, &stmt, NULL);
 743         if (r) {
 744                 ERROR(db->pakfire, "Could not prepare foreign key check: %s\n",
 745                         sqlite3_errmsg(db->handle));
 746                 return 1;
 747         }
 748
 749         // Count any errors
 750         unsigned long errors = 0;
 751
 752         while (1) {
 753                 do {
 754                         r = sqlite3_step(stmt);
 755                 } while (r == SQLITE_BUSY);
 756
 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);
 762
 763                         // Increment error counter
 764                         errors++;
 765
 766                         // Log the message
 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);
 769
 770                 // Break on anything else
 771                 } else
 772                         break;
 773         }
 774
 775         sqlite3_finalize(stmt);
 776
 777         if (errors)
 778                 ERROR(db->pakfire, "Foreign key check failed\n");
 779         else
 780                 INFO(db->pakfire, "Foreign key check passed\n");
 781
 782         return errors;
 783 }
 784
 785 /*
 786         This function performs an integrity check of the database
 787 */
 788 int pakfire_db_check(struct pakfire_db* db) {
 789         int r;
 790
 791         // Perform integrity check
 792         r = pakfire_db_integrity_check(db);
 793         if (r)
 794                 return 1;
 795
 796         // Perform foreign key check
 797         r = pakfire_db_foreign_key_check(db);
 798         if (r)
 799                 return 1;
 800
 801         return 0;
 802 }
 803
 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;
 808
 809         int r = sqlite3_prepare_v2(db->handle, "SELECT COUNT(*) FROM packages", -1, &stmt, NULL);
 810         if (r) {
 811                 ERROR(db->pakfire, "Could not prepare SQL statement: %s\n",
 812                         sqlite3_errmsg(db->handle));
 813                 return -1;
 814         }
 815
 816         // Execute query
 817         do {
 818                 r = sqlite3_step(stmt);
 819         } while (r == SQLITE_BUSY);
 820
 821         if (r == SQLITE_ROW) {
 822                 packages = sqlite3_column_int64(stmt, 0);
 823         }
 824
 825         sqlite3_finalize(stmt);
 826
 827         return packages;
 828 }
 829
 830 static void pakfire_db_add_userinstalled(struct pakfire* pakfire, const char* name) {
 831         Pool* pool = pakfire_get_solv_pool(pakfire);
 832
 833         // Convert name to ID
 834         Id id = pool_str2id(pool, name, 1);
 835
 836         // Append it to pooljobs
 837         queue_push2(&pool->pooljobs, SOLVER_USERINSTALLED|SOLVER_SOLVABLE_NAME, id);
 838 }
 839
 840 static int pakfire_db_add_dependencies(struct pakfire_db* db, unsigned long id, struct pakfire_package* pkg) {
 841         sqlite3_stmt* stmt = NULL;
 842         int r = 1;
 843
 844         const char* sql = "INSERT INTO dependencies(pkg, type, dependency) VALUES(?, ?, ?)";
 845
 846         // Prepare the statement
 847         r = sqlite3_prepare_v2(db->handle, sql, -1, &stmt, NULL);
 848         if (r) {
 849                 ERROR(db->pakfire, "Could not prepare SQL statement: %s: %s\n",
 850                         sql, sqlite3_errmsg(db->handle));
 851                 goto END;
 852         }
 853
 854         const struct __relation {
 855                 const char* type;
 856                 char** (*func)(struct pakfire_package*);
 857         } relations[] = {
 858                 { "provides", pakfire_package_get_provides },
 859                 { "prerequires", pakfire_package_get_prerequires },
 860                 { "requires", pakfire_package_get_requires },
 861                 { "conflicts", pakfire_package_get_conflicts },
 862                 { "obsoletes", pakfire_package_get_obsoletes },
 863                 { "recommends", pakfire_package_get_recommends },
 864                 { "suggests", pakfire_package_get_suggests },
 865                 { "supplements", pakfire_package_get_supplements },
 866                 { "enhances", pakfire_package_get_enhances },
 867                 { NULL, NULL },
 868         };
 869
 870         for (const struct __relation* relation = relations; relation->type; relation++) {
 871                 char** list = relation->func(pkg);
 872                 if (!list)
 873                         continue;
 874
 875                 for (char** dep = list; *dep; dep++) {
 876                         // Bind package ID
 877                         r = sqlite3_bind_int64(stmt, 1, id);
 878                         if (r) {
 879                                 ERROR(db->pakfire, "Could not bind id: %s\n",
 880                                         sqlite3_errmsg(db->handle));
 881                                 goto END;
 882                         }
 883
 884                         // Bind type
 885                         r = sqlite3_bind_text(stmt, 2, relation->type, -1, NULL);
 886                         if (r) {
 887                                 ERROR(db->pakfire, "Could not bind type: %s\n",
 888                                         sqlite3_errmsg(db->handle));
 889                                 goto END;
 890                         }
 891
 892                         // Bind dependency
 893                         r = sqlite3_bind_text(stmt, 3, *dep, -1, NULL);
 894                         if (r) {
 895                                 ERROR(db->pakfire, "Could not bind dependency: %s\n",
 896                                         sqlite3_errmsg(db->handle));
 897                                 goto END;
 898                         }
 899
 900                         // Execute query
 901                         do {
 902                                 r = sqlite3_step(stmt);
 903                         } while (r == SQLITE_BUSY);
 904
 905                         free(*dep);
 906
 907                         // Reset bound values
 908                         sqlite3_reset(stmt);
 909                 }
 910
 911                 free(list);
 912         }
 913
 914         // All okay
 915         r = 0;
 916
 917 END:
 918         if (stmt)
 919                 sqlite3_finalize(stmt);
 920
 921         return r;
 922 }
 923
 924 static int pakfire_db_bind_digest(struct pakfire_db* db, sqlite3_stmt* stmt, const int field,
 925                 struct pakfire_file* file, const enum pakfire_digest_types type) {
 926         const unsigned char* digest = NULL;
 927         size_t length = 0;
 928
 929         // Fetch the digest
 930         digest = pakfire_file_get_digest(file, type, &length);
 931
 932         // If this digest isn't set, just bind NULL
 933         if (!digest)
 934                 return sqlite3_bind_null(stmt, field);
 935
 936         // Otherwise bind the data blob
 937         return sqlite3_bind_blob(stmt, field, digest, length, NULL);
 938 }
 939
 940 static int pakfire_db_add_files(struct pakfire_db* db, unsigned long id, struct pakfire_archive* archive) {
 941         sqlite3_stmt* stmt = NULL;
 942         int r = 1;
 943
 944         // Get the filelist from the archive
 945         struct pakfire_filelist* filelist = pakfire_archive_get_filelist(archive);
 946         if (!filelist) {
 947                 ERROR(db->pakfire, "Could not fetch filelist from archive\n");
 948                 return 1;
 949         }
 950
 951         // Nothing to do if the list is empty
 952         if (pakfire_filelist_is_empty(filelist)) {
 953                 r = 0;
 954                 goto END;
 955         }
 956
 957         const char* sql =
 958                 "INSERT INTO "
 959                 "       files("
 960                                 "pkg, "
 961                                 "path, "
 962                                 "size, "
 963                                 "config, "
 964                                 "datafile, "
 965                                 "mode, "
 966                                 "uname, "
 967                                 "gname, "
 968                                 "ctime, "
 969                                 "mtime, "
 970                                 "capabilities, "
 971                                 "digest_sha2_512, "
 972                                 "digest_sha2_256, "
 973                                 "digest_blake2b512, "
 974                                 "digest_blake2s256, "
 975                                 "digest_sha3_512, "
 976                                 "digest_sha3_256"
 977                         ") "
 978                         "VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 979
 980         // Prepare the statement
 981         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
 982         if (r) {
 983                 ERROR(db->pakfire, "Could not prepare SQL statement: %s: %s\n",
 984                         sql, sqlite3_errmsg(db->handle));
 985                 goto END;
 986         }
 987
 988         for (unsigned int i = 0; i < pakfire_filelist_size(filelist); i++) {
 989                 struct pakfire_file* file = pakfire_filelist_get(filelist, i);
 990
 991                 // Bind package ID
 992                 r = sqlite3_bind_int64(stmt, 1, id);
 993                 if (r) {
 994                         ERROR(db->pakfire, "Could not bind id: %s\n", sqlite3_errmsg(db->handle));
 995                         pakfire_file_unref(file);
 996                         goto END;
 997                 }
 998
 999                 // Bind name
1000                 const char* path = pakfire_file_get_path(file);
1001
1002                 r = sqlite3_bind_text(stmt, 2, path, -1, NULL);
1003                 if (r) {
1004                         ERROR(db->pakfire, "Could not bind path: %s\n", sqlite3_errmsg(db->handle));
1005                         pakfire_file_unref(file);
1006                         goto END;
1007                 }
1008
1009                 // Bind size
1010                 size_t size = pakfire_file_get_size(file);
1011
1012                 r = sqlite3_bind_int64(stmt, 3, size);
1013                 if (r) {
1014                         ERROR(db->pakfire, "Could not bind size: %s\n", sqlite3_errmsg(db->handle));
1015                         pakfire_file_unref(file);
1016                         goto END;
1017                 }
1018
1019                 // Bind config - XXX TODO
1020                 r = sqlite3_bind_null(stmt, 4);
1021                 if (r) {
1022                         ERROR(db->pakfire, "Could not bind config: %s\n", sqlite3_errmsg(db->handle));
1023                         pakfire_file_unref(file);
1024                         goto END;
1025                 }
1026
1027                 // Bind datafile - XXX TODO
1028                 r = sqlite3_bind_null(stmt, 5);
1029                 if (r) {
1030                         ERROR(db->pakfire, "Could not bind datafile: %s\n", sqlite3_errmsg(db->handle));
1031                         pakfire_file_unref(file);
1032                         goto END;
1033                 }
1034
1035                 // Bind mode
1036                 mode_t mode = pakfire_file_get_mode(file);
1037
1038                 r = sqlite3_bind_int64(stmt, 6, mode);
1039                 if (r) {
1040                         ERROR(db->pakfire, "Could not bind mode: %s\n", sqlite3_errmsg(db->handle));
1041                         pakfire_file_unref(file);
1042                         goto END;
1043                 }
1044
1045                 // Bind uname
1046                 const char* uname = pakfire_file_get_uname(file);
1047
1048                 r = sqlite3_bind_text(stmt, 7, uname, -1, NULL);
1049                 if (r) {
1050                         ERROR(db->pakfire, "Could not bind uname: %s\n", sqlite3_errmsg(db->handle));
1051                         pakfire_file_unref(file);
1052                         goto END;
1053                 }
1054
1055                 // Bind gname
1056                 const char* gname = pakfire_file_get_gname(file);
1057
1058                 r = sqlite3_bind_text(stmt, 8, gname, -1, NULL);
1059                 if (r) {
1060                         ERROR(db->pakfire, "Could not bind gname: %s\n", sqlite3_errmsg(db->handle));
1061                         pakfire_file_unref(file);
1062                         goto END;
1063                 }
1064
1065                 // Bind ctime
1066                 time_t ctime = pakfire_file_get_ctime(file);
1067
1068                 r = sqlite3_bind_int64(stmt, 9, ctime);
1069                 if (r) {
1070                         ERROR(db->pakfire, "Could not bind ctime: %s\n", sqlite3_errmsg(db->handle));
1071                         pakfire_file_unref(file);
1072                         goto END;
1073                 }
1074
1075                 // Bind mtime
1076                 time_t mtime = pakfire_file_get_mtime(file);
1077
1078                 r = sqlite3_bind_int64(stmt, 10, mtime);
1079                 if (r) {
1080                         ERROR(db->pakfire, "Could not bind mtime: %s\n", sqlite3_errmsg(db->handle));
1081                         pakfire_file_unref(file);
1082                         goto END;
1083                 }
1084
1085                 // Bind capabilities - XXX TODO
1086                 r = sqlite3_bind_null(stmt, 11);
1087                 if (r) {
1088                         ERROR(db->pakfire, "Could not bind capabilities: %s\n", sqlite3_errmsg(db->handle));
1089                         pakfire_file_unref(file);
1090                         goto END;
1091                 }
1092
1093                 // SHA2-512 Digest
1094                 r = pakfire_db_bind_digest(db, stmt, 12, file, PAKFIRE_DIGEST_SHA2_512);
1095                 if (r) {
1096                         ERROR(db->pakfire, "Could not bind SHA2-512 digest: %s\n",
1097                                 sqlite3_errmsg(db->handle));
1098                         pakfire_file_unref(file);
1099                         goto END;
1100                 }
1101
1102                 // SHA2-256 Digest
1103                 r = pakfire_db_bind_digest(db, stmt, 13, file, PAKFIRE_DIGEST_SHA2_256);
1104                 if (r) {
1105                         ERROR(db->pakfire, "Could not bind SHA2-256 digest: %s\n",
1106                                 sqlite3_errmsg(db->handle));
1107                         pakfire_file_unref(file);
1108                         goto END;
1109                 }
1110
1111                 // BLAKE2b512 Digest
1112                 r = pakfire_db_bind_digest(db, stmt, 14, file, PAKFIRE_DIGEST_BLAKE2B512);
1113                 if (r) {
1114                         ERROR(db->pakfire, "Could not bind BLAKE2b512 digest: %s\n",
1115                                 sqlite3_errmsg(db->handle));
1116                         pakfire_file_unref(file);
1117                         goto END;
1118                 }
1119
1120                 // BLAKE2s256 Digest
1121                 r = pakfire_db_bind_digest(db, stmt, 15, file, PAKFIRE_DIGEST_BLAKE2S256);
1122                 if (r) {
1123                         ERROR(db->pakfire, "Could not bind BLAKE2s256 digest: %s\n",
1124                                 sqlite3_errmsg(db->handle));
1125                         pakfire_file_unref(file);
1126                         goto END;
1127                 }
1128
1129                 // SHA3-512 Digest
1130                 r = pakfire_db_bind_digest(db, stmt, 16, file, PAKFIRE_DIGEST_SHA3_512);
1131                 if (r) {
1132                         ERROR(db->pakfire, "Could not bind SHA3-512 digest: %s\n",
1133                                 sqlite3_errmsg(db->handle));
1134                         pakfire_file_unref(file);
1135                         goto END;
1136                 }
1137
1138                 // SHA3-256 Digest
1139                 r = pakfire_db_bind_digest(db, stmt, 17, file, PAKFIRE_DIGEST_SHA3_256);
1140                 if (r) {
1141                         ERROR(db->pakfire, "Could not bind SHA3-256 digest: %s\n",
1142                                 sqlite3_errmsg(db->handle));
1143                         pakfire_file_unref(file);
1144                         goto END;
1145                 }
1146
1147                 // Execute query
1148                 do {
1149                         r = sqlite3_step(stmt);
1150                 } while (r == SQLITE_BUSY);
1151
1152                 // Check for errors
1153                 if (r != SQLITE_DONE) {
1154                         ERROR(db->pakfire, "Could not add file to database: %s\n",
1155                                 sqlite3_errmsg(db->handle));
1156                         pakfire_file_unref(file);
1157                         goto END;
1158                 }
1159
1160                 // Move on to next file
1161                 pakfire_file_unref(file);
1162
1163                 // Reset bound values
1164                 sqlite3_reset(stmt);
1165         }
1166
1167         // All okay
1168         r = 0;
1169
1170 END:
1171         if (stmt)
1172                 sqlite3_finalize(stmt);
1173         pakfire_filelist_unref(filelist);
1174
1175         return r;
1176 }
1177
1178 static int pakfire_db_add_scriptlets(struct pakfire_db* db, unsigned long id, struct pakfire_archive* archive) {
1179         sqlite3_stmt* stmt = NULL;
1180         size_t size;
1181         int r = 1;
1182
1183         const char* sql = "INSERT INTO scriptlets(pkg, type, scriptlet) VALUES(?, ?, ?)";
1184
1185         // Prepare the statement
1186         r = sqlite3_prepare_v2(db->handle, sql, -1, &stmt, NULL);
1187         if (r) {
1188                 ERROR(db->pakfire, "Could not prepare SQL statement: %s: %s\n",
1189                         sql, sqlite3_errmsg(db->handle));
1190                 goto END;
1191         }
1192
1193         for (const char** type = pakfire_scriptlet_types; *type; type++) {
1194                 // Fetch the scriptlet
1195                 struct pakfire_scriptlet* scriptlet = pakfire_archive_get_scriptlet(archive, *type);
1196                 if (!scriptlet)
1197                         continue;
1198
1199                 // Bind package ID
1200                 r = sqlite3_bind_int64(stmt, 1, id);
1201                 if (r) {
1202                         ERROR(db->pakfire, "Could not bind id: %s\n", sqlite3_errmsg(db->handle));
1203                         pakfire_scriptlet_unref(scriptlet);
1204                         goto END;
1205                 }
1206
1207                 // Bind handle
1208                 r = sqlite3_bind_text(stmt, 2, *type, -1, NULL);
1209                 if (r) {
1210                         ERROR(db->pakfire, "Could not bind type: %s\n", sqlite3_errmsg(db->handle));
1211                         pakfire_scriptlet_unref(scriptlet);
1212                         goto END;
1213                 }
1214
1215                 const char* data = pakfire_scriptlet_get_data(scriptlet, &size);
1216
1217                 // Bind scriptlet
1218                 r = sqlite3_bind_text(stmt, 3, data, size, NULL);
1219                 if (r) {
1220                         ERROR(db->pakfire, "Could not bind scriptlet: %s\n", sqlite3_errmsg(db->handle));
1221                         pakfire_scriptlet_unref(scriptlet);
1222                         goto END;
1223                 }
1224
1225                 // Execute query
1226                 do {
1227                         r = sqlite3_step(stmt);
1228                 } while (r == SQLITE_BUSY);
1229
1230                 // Check for errors
1231                 if (r != SQLITE_DONE) {
1232                         ERROR(db->pakfire, "Could not add scriptlet to database: %s\n",
1233                                 sqlite3_errmsg(db->handle));
1234                         pakfire_scriptlet_unref(scriptlet);
1235                         goto END;
1236                 }
1237
1238                 pakfire_scriptlet_unref(scriptlet);
1239
1240                 // Reset bound values
1241                 sqlite3_reset(stmt);
1242         }
1243
1244         // All okay
1245         r = 0;
1246
1247 END:
1248         if (stmt)
1249                 sqlite3_finalize(stmt);
1250
1251         return r;
1252 }
1253
1254 int pakfire_db_add_package(struct pakfire_db* db,
1255                 struct pakfire_package* pkg, struct pakfire_archive* archive, int userinstalled) {
1256         sqlite3_stmt* stmt = NULL;
1257         int r;
1258
1259         // Begin a new transaction
1260         r = pakfire_db_begin_transaction(db);
1261         if (r)
1262                 goto ERROR;
1263
1264         const char* sql = "INSERT INTO "
1265                 "packages("
1266                         "name, "
1267                         "evr, "
1268                         "arch, "
1269                         "groups, "
1270                         "filename, "
1271                         "size, "
1272                         "inst_size, "
1273                         "digest_type, "
1274                         "digest, "
1275                         "license, "
1276                         "summary, "
1277                         "description, "
1278                         "uuid, "
1279                         "vendor, "
1280                         "build_host, "
1281                         "build_time, "
1282                         "installed, "
1283                         "repository, "
1284                         "userinstalled, "
1285                         "source_name, "
1286                         "source_evr, "
1287                         "source_arch, "
1288                         "distribution"
1289                 ") VALUES("
1290                         "?, "
1291                         "?, "
1292                         "?, "
1293                         "?, "
1294                         "?, "
1295                         "?, "
1296                         "?, "
1297                         "?, "
1298                         "?, "
1299                         "?, "
1300                         "?, "
1301                         "?, "
1302                         "?, "
1303                         "?, "
1304                         "?, "
1305                         "?, "
1306                         "CURRENT_TIMESTAMP, "
1307                         "?, "
1308                         "?, "
1309                         "?, "
1310                         "?, "
1311                         "?, "
1312                         "?"
1313                 ")";
1314
1315         // Prepare the statement
1316         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
1317         if (r != SQLITE_OK) {
1318                 ERROR(db->pakfire, "Could not prepare SQL statement: %s: %s\n",
1319                         sql, sqlite3_errmsg(db->handle));
1320                 goto ERROR;
1321         }
1322
1323         // Bind name
1324         const char* name = pakfire_package_get_string(pkg, PAKFIRE_PKG_NAME);
1325
1326         r = sqlite3_bind_text(stmt, 1, name, -1, NULL);
1327         if (r) {
1328                 ERROR(db->pakfire, "Could not bind name: %s\n", sqlite3_errmsg(db->handle));
1329                 goto ERROR;
1330         }
1331
1332         // Bind evr
1333         const char* evr = pakfire_package_get_string(pkg, PAKFIRE_PKG_EVR);
1334
1335         r = sqlite3_bind_text(stmt, 2, evr, -1, NULL);
1336         if (r) {
1337                 ERROR(db->pakfire, "Could not bind evr: %s\n", sqlite3_errmsg(db->handle));
1338                 goto ERROR;
1339         }
1340
1341         // Bind arch
1342         const char* arch = pakfire_package_get_string(pkg, PAKFIRE_PKG_ARCH);
1343
1344         r = sqlite3_bind_text(stmt, 3, arch, -1, NULL);
1345         if (r) {
1346                 ERROR(db->pakfire, "Could not bind arch: %s\n", sqlite3_errmsg(db->handle));
1347                 goto ERROR;
1348         }
1349
1350         // Bind groups
1351         const char* groups = pakfire_package_get_string(pkg, PAKFIRE_PKG_GROUPS);
1352
1353         if (groups) {
1354                 r = sqlite3_bind_text(stmt, 4, groups, -1, NULL);
1355                 if (r) {
1356                         ERROR(db->pakfire, "Could not bind groups: %s\n", sqlite3_errmsg(db->handle));
1357                         goto ERROR;
1358                 }
1359
1360         // No groups
1361         } else {
1362                 r = sqlite3_bind_null(stmt, 4);
1363                 if (r)
1364                         goto ERROR;
1365         }
1366
1367         // Bind filename
1368         const char* filename = pakfire_package_get_string(pkg, PAKFIRE_PKG_FILENAME);
1369
1370         r = sqlite3_bind_text(stmt, 5, filename, -1, NULL);
1371         if (r) {
1372                 ERROR(db->pakfire, "Could not bind filename: %s\n", sqlite3_errmsg(db->handle));
1373                 goto ERROR;
1374         }
1375
1376         // Bind size
1377         unsigned long long size = pakfire_package_get_downloadsize(pkg);
1378
1379         r = sqlite3_bind_int64(stmt, 6, size);
1380         if (r) {
1381                 ERROR(db->pakfire, "Could not bind size: %s\n", sqlite3_errmsg(db->handle));
1382                 goto ERROR;
1383         }
1384
1385         // Bind installed size
1386         unsigned long long inst_size = pakfire_package_get_installsize(pkg);
1387
1388         r = sqlite3_bind_int64(stmt, 7, inst_size);
1389         if (r) {
1390                 ERROR(db->pakfire, "Could not bind inst_size: %s\n", sqlite3_errmsg(db->handle));
1391                 goto ERROR;
1392         }
1393
1394         const unsigned char* digest = NULL;
1395         enum pakfire_digest_types digest_type = 0;
1396         size_t digest_length = 0;
1397
1398         // Fetch the digest
1399         digest = pakfire_package_get_digest(pkg, &digest_type, &digest_length);
1400         if (!digest) {
1401                 ERROR(db->pakfire, "Could not fetch the package's digest: %m\n");
1402                 r = 1;
1403                 goto ERROR;
1404         }
1405
1406         // Set the digest type
1407         r = sqlite3_bind_int64(stmt, 8, digest_type);
1408         if (r) {
1409                 ERROR(db->pakfire, "Could not bind digest type: %s\n", sqlite3_errmsg(db->handle));
1410                 goto ERROR;
1411         }
1412
1413         // Set the digest
1414         r = sqlite3_bind_blob(stmt, 9, digest, digest_length, NULL);
1415         if (r) {
1416                 ERROR(db->pakfire, "Could not bind digest: %s\n", sqlite3_errmsg(db->handle));
1417                 goto ERROR;
1418         }
1419
1420         // Bind license
1421         const char* license = pakfire_package_get_string(pkg, PAKFIRE_PKG_LICENSE);
1422
1423         r = sqlite3_bind_text(stmt, 10, license, -1, NULL);
1424         if (r) {
1425                 ERROR(db->pakfire, "Could not bind license: %s\n", sqlite3_errmsg(db->handle));
1426                 goto ERROR;
1427         }
1428
1429         // Bind summary
1430         const char* summary = pakfire_package_get_string(pkg, PAKFIRE_PKG_SUMMARY);
1431
1432         r = sqlite3_bind_text(stmt, 11, summary, -1, NULL);
1433         if (r) {
1434                 ERROR(db->pakfire, "Could not bind summary: %s\n", sqlite3_errmsg(db->handle));
1435                 goto ERROR;
1436         }
1437
1438         // Bind description
1439         const char* description = pakfire_package_get_string(pkg, PAKFIRE_PKG_DESCRIPTION);
1440
1441         r = sqlite3_bind_text(stmt, 12, description, -1, NULL);
1442         if (r) {
1443                 ERROR(db->pakfire, "Could not bind description: %s\n", sqlite3_errmsg(db->handle));
1444                 goto ERROR;
1445         }
1446
1447         // Bind uuid
1448         const char* uuid = pakfire_package_get_string(pkg, PAKFIRE_PKG_UUID);
1449
1450         r = sqlite3_bind_text(stmt, 13, uuid, -1, NULL);
1451         if (r) {
1452                 ERROR(db->pakfire, "Could not bind uuid: %s\n", sqlite3_errmsg(db->handle));
1453                 goto ERROR;
1454         }
1455
1456         // Bind vendor
1457         const char* vendor = pakfire_package_get_string(pkg, PAKFIRE_PKG_VENDOR);
1458
1459         r = sqlite3_bind_text(stmt, 14, vendor, -1, NULL);
1460         if (r) {
1461                 ERROR(db->pakfire, "Could not bind vendor: %s\n", sqlite3_errmsg(db->handle));
1462                 goto ERROR;
1463         }
1464
1465         // Bind build_host
1466         const char* build_host = pakfire_package_get_string(pkg, PAKFIRE_PKG_BUILD_HOST);
1467
1468         r = sqlite3_bind_text(stmt, 15, build_host, -1, NULL);
1469         if (r) {
1470                 ERROR(db->pakfire, "Could not bind build_host: %s\n", sqlite3_errmsg(db->handle));
1471                 goto ERROR;
1472         }
1473
1474         // Bind build_time
1475         time_t build_time = pakfire_package_get_build_time(pkg);
1476
1477         r = sqlite3_bind_int64(stmt, 16, build_time);
1478         if (r) {
1479                 ERROR(db->pakfire, "Could not bind build_time: %s\n", sqlite3_errmsg(db->handle));
1480                 goto ERROR;
1481         }
1482
1483         // Bind repository name
1484         struct pakfire_repo* repo = pakfire_package_get_repo(pkg);
1485         if (repo) {
1486                 const char* repo_name = pakfire_repo_get_name(repo);
1487                 pakfire_repo_unref(repo);
1488
1489                 r = sqlite3_bind_text(stmt, 17, repo_name, -1, NULL);
1490                 if (r)
1491                         goto ERROR;
1492
1493         // No repository?
1494         } else {
1495                 r = sqlite3_bind_null(stmt, 17);
1496                 if (r)
1497                         goto ERROR;
1498         }
1499
1500         // installed by the user?
1501         r = sqlite3_bind_int(stmt, 18, userinstalled);
1502         if (r) {
1503                 ERROR(db->pakfire, "Could not bind userinstalled: %s\n", sqlite3_errmsg(db->handle));
1504                 goto ERROR;
1505         }
1506
1507         // Source package name
1508         const char* source_name = pakfire_package_get_source_name(pkg);
1509         if (source_name) {
1510                 r = sqlite3_bind_text(stmt, 19, source_name, -1, NULL);
1511                 if (r)
1512                         goto ERROR;
1513         } else {
1514                 r = sqlite3_bind_null(stmt, 19);
1515                 if (r)
1516                         goto ERROR;
1517         }
1518
1519         // Source EVR
1520         const char* source_evr = pakfire_package_get_source_evr(pkg);
1521         if (source_evr) {
1522                 r = sqlite3_bind_text(stmt, 20, source_evr, -1, NULL);
1523                 if (r)
1524                         goto ERROR;
1525         } else {
1526                 r = sqlite3_bind_null(stmt, 20);
1527                 if (r)
1528                         goto ERROR;
1529         }
1530
1531         // Source arch
1532         const char* source_arch = pakfire_package_get_source_arch(pkg);
1533         if (source_arch) {
1534                 r = sqlite3_bind_text(stmt, 21, source_arch, -1, NULL);
1535                 if (r)
1536                         goto ERROR;
1537         } else {
1538                 r = sqlite3_bind_null(stmt, 21);
1539                 if (r)
1540                         goto ERROR;
1541         }
1542
1543         // Distribution
1544         const char* distribution = pakfire_package_get_string(pkg, PAKFIRE_PKG_DISTRO);
1545         if (distribution) {
1546                 r = sqlite3_bind_text(stmt, 22, distribution, -1, NULL);
1547                 if (r)
1548                         goto ERROR;
1549         } else {
1550                 r = sqlite3_bind_null(stmt, 22);
1551                 if (r)
1552                         goto ERROR;
1553         }
1554
1555         // Run query
1556         do {
1557                 r = sqlite3_step(stmt);
1558         } while (r == SQLITE_BUSY);
1559
1560         if (r != SQLITE_DONE) {
1561                 ERROR(db->pakfire, "Could not add package to database: %s\n",
1562                         sqlite3_errmsg(db->handle));
1563                 r = 1;
1564                 goto ERROR;
1565         }
1566
1567         // Save package ID
1568         unsigned long packages_id = sqlite3_last_insert_rowid(db->handle);
1569
1570         // Add dependencies
1571         r = pakfire_db_add_dependencies(db, packages_id, pkg);
1572         if (r)
1573                 goto ERROR;
1574
1575         // Add files
1576         r = pakfire_db_add_files(db, packages_id, archive);
1577         if (r)
1578                 goto ERROR;
1579
1580         // Add scriptlets
1581         r = pakfire_db_add_scriptlets(db, packages_id, archive);
1582         if (r)
1583                 goto ERROR;
1584
1585 ERROR:
1586         if (stmt)
1587                 sqlite3_finalize(stmt);
1588
1589         // Commit or rollback
1590         if (r)
1591                 pakfire_db_rollback(db);
1592         else
1593                 r = pakfire_db_commit(db);
1594
1595         return r;
1596 }
1597
1598 int pakfire_db_remove_package(struct pakfire_db* db, struct pakfire_package* pkg) {
1599         sqlite3_stmt* stmt = NULL;
1600         int r = 1;
1601
1602         // Begin a new transaction
1603         r = pakfire_db_begin_transaction(db);
1604         if (r)
1605                 goto ERROR;
1606
1607         // Fetch the package's UUID
1608         const char* uuid = pakfire_package_get_string(pkg, PAKFIRE_PKG_UUID);
1609         if (!uuid) {
1610                 ERROR(db->pakfire, "Package has no UUID\n");
1611                 r = 1;
1612                 goto ERROR;
1613         }
1614
1615         r = sqlite3_prepare_v2(db->handle,
1616                 "DELETE FROM packages WHERE uuid = ?", -1, &stmt, NULL);
1617         if (r) {
1618                 ERROR(db->pakfire, "Could not prepare SQL statement: %s\n",
1619                         sqlite3_errmsg(db->handle));
1620                 goto ERROR;
1621         }
1622
1623         // Bind UUID
1624         r = sqlite3_bind_text(stmt, 1, uuid, -1, NULL);
1625         if (r) {
1626                 ERROR(db->pakfire, "Could not bind uuid: %s\n", sqlite3_errmsg(db->handle));
1627                 goto ERROR;
1628         }
1629
1630         // Execute query
1631         do {
1632                 r = sqlite3_step(stmt);
1633         } while (r == SQLITE_BUSY);
1634
1635         // Check if we have been successful
1636         if (r != SQLITE_DONE) {
1637                 ERROR(db->pakfire, "Could not delete package %s\n", uuid);
1638                 r = 1;
1639                 goto ERROR;
1640         }
1641
1642         // All done
1643         r = 0;
1644
1645 ERROR:
1646         if (stmt)
1647                 sqlite3_finalize(stmt);
1648
1649         // Commit or rollback
1650         if (r)
1651                 pakfire_db_rollback(db);
1652         else
1653                 r = pakfire_db_commit(db);
1654
1655         return r;
1656 }
1657
1658 struct pakfire_scriptlet* pakfire_db_get_scriptlet(struct pakfire_db* db,
1659                 struct pakfire_package* pkg, const char* type) {
1660         struct pakfire_scriptlet* scriptlet = NULL;
1661         sqlite3_stmt* stmt = NULL;
1662         int r = 1;
1663
1664         // Fetch the package's UUID
1665         const char* uuid = pakfire_package_get_string(pkg, PAKFIRE_PKG_UUID);
1666         if (!uuid) {
1667                 ERROR(db->pakfire, "Package has no UUID\n");
1668                 goto ERROR;
1669         }
1670
1671         const char* sql = "SELECT scriptlets.scriptlet FROM packages \
1672                 JOIN scriptlets ON packages.id = scriptlets.pkg \
1673                 WHERE packages.uuid = ? AND scriptlets.type = ?";
1674
1675         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
1676         if (r) {
1677                 ERROR(db->pakfire, "Could not prepare SQL statement: %s %s\n",
1678                         sql, sqlite3_errmsg(db->handle));
1679                 goto ERROR;
1680         }
1681
1682         // Bind UUID
1683         r = sqlite3_bind_text(stmt, 1, uuid, -1, NULL);
1684         if (r) {
1685                 ERROR(db->pakfire, "Could not bind uuid: %s\n", sqlite3_errmsg(db->handle));
1686                 goto ERROR;
1687         }
1688
1689         r = sqlite3_bind_text(stmt, 2, type, -1, NULL);
1690         if (r) {
1691                 ERROR(db->pakfire, "Could not bind type: %s\n", sqlite3_errmsg(db->handle));
1692                 goto ERROR;
1693         }
1694
1695         DEBUG(db->pakfire, "Searching for scriptlet for package %s of type %s\n", uuid, type);
1696
1697         // Execute query
1698         do {
1699                 r = sqlite3_step(stmt);
1700         } while (r == SQLITE_BUSY);
1701
1702         // We have some payload
1703         if (r == SQLITE_ROW) {
1704                 const void* data = sqlite3_column_blob(stmt, 1);
1705                 ssize_t size = sqlite3_column_bytes(stmt, 1);
1706
1707                 // Create a scriptlet object
1708                 r = pakfire_scriptlet_create(&scriptlet, db->pakfire, type, data, size);
1709                 if (r)
1710                         goto ERROR;
1711         }
1712
1713 ERROR:
1714         if (stmt)
1715                 sqlite3_finalize(stmt);
1716
1717         return scriptlet;
1718 }
1719
1720 static int pakfire_db_load_package(struct pakfire_db* db, struct pakfire_repo* repo, sqlite3_stmt* stmt) {
1721         struct pakfire_package* pkg = NULL;
1722         int r = 1;
1723
1724         // Name
1725         const char* name = (const char*)sqlite3_column_text(stmt, 0);
1726         if (!name) {
1727                 ERROR(db->pakfire, "Could not read name: %s\n", sqlite3_errmsg(db->handle));
1728                 goto ERROR;
1729         }
1730
1731         // EVR
1732         const char* evr = (const char*)sqlite3_column_text(stmt, 1);
1733         if (!evr) {
1734                 ERROR(db->pakfire, "Could not read evr: %s\n", sqlite3_errmsg(db->handle));
1735                 goto ERROR;
1736         }
1737
1738         // Arch
1739         const char* arch = (const char*)sqlite3_column_text(stmt, 2);
1740         if (!arch) {
1741                 ERROR(db->pakfire, "Could not read arch: %s\n", sqlite3_errmsg(db->handle));
1742                 goto ERROR;
1743         }
1744
1745         // Create package
1746         r = pakfire_package_create(&pkg, db->pakfire, repo, name, evr, arch);
1747         if (r) {
1748                 ERROR(db->pakfire, "Could not create package\n");
1749                 goto ERROR;
1750         }
1751
1752         // ID
1753         uint64_t id = sqlite3_column_int64(stmt, 3);
1754         if (id)
1755                 pakfire_package_set_dbid(pkg, id);
1756
1757         // Groups
1758         const char* groups = (const char*)sqlite3_column_text(stmt, 4);
1759         if (groups) {
1760                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_GROUPS, groups);
1761                 if (r)
1762                         goto ERROR;
1763         }
1764
1765         // Filename
1766         const char* filename = (const char*)sqlite3_column_text(stmt, 5);
1767         if (filename) {
1768                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_FILENAME, filename);
1769                 if (r)
1770                         goto ERROR;
1771         }
1772
1773         // Size
1774         size_t size = sqlite3_column_int64(stmt, 6);
1775         if (size) {
1776                 pakfire_package_set_downloadsize(pkg, size);
1777         }
1778
1779         // Installed size
1780         size = sqlite3_column_int64(stmt, 7);
1781         if (size) {
1782                 pakfire_package_set_installsize(pkg, size);
1783         }
1784
1785         // Digest type
1786         enum pakfire_digest_types digest_type = sqlite3_column_int64(stmt, 8);
1787         size_t digest_length = 0;
1788
1789         // Digest length
1790
1791         // Digest
1792         const unsigned char* digest = sqlite3_column_blob(stmt, 9);
1793         if (digest_type && digest) {
1794                 pakfire_package_set_digest(pkg, digest_type, digest, digest_length);
1795         }
1796
1797         // License
1798         const char* license = (const char*)sqlite3_column_text(stmt, 10);
1799         if (license) {
1800                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_LICENSE, license);
1801                 if (r)
1802                         goto ERROR;
1803         }
1804
1805         // Summary
1806         const char* summary = (const char*)sqlite3_column_text(stmt, 11);
1807         if (summary) {
1808                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_SUMMARY, summary);
1809                 if (r)
1810                         goto ERROR;
1811         }
1812
1813         // Description
1814         const char* description = (const char*)sqlite3_column_text(stmt, 12);
1815         if (description) {
1816                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_DESCRIPTION, description);
1817                 if (r)
1818                         goto ERROR;
1819         }
1820
1821         // UUID
1822         const char* uuid = (const char*)sqlite3_column_text(stmt, 13);
1823         if (uuid) {
1824                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_UUID, uuid);
1825                 if (r)
1826                         goto ERROR;
1827         }
1828
1829         // Vendor
1830         const char* vendor = (const char*)sqlite3_column_text(stmt, 14);
1831         if (vendor) {
1832                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_VENDOR, vendor);
1833                 if (r)
1834                         goto ERROR;
1835         }
1836
1837         // Build Host
1838         const char* build_host = (const char*)sqlite3_column_text(stmt, 15);
1839         if (build_host) {
1840                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_BUILD_HOST, build_host);
1841                 if (r)
1842                         goto ERROR;
1843         }
1844
1845         // Build Time
1846         time_t build_time = sqlite3_column_int64(stmt, 16);
1847         if (build_time) {
1848                 pakfire_package_set_build_time(pkg, build_time);
1849         }
1850
1851         // Install Time
1852         time_t install_time = sqlite3_column_int64(stmt, 17);
1853         if (install_time) {
1854                 pakfire_package_set_install_time(pkg, install_time);
1855         }
1856
1857         // installed by user?
1858         int userinstalled = sqlite3_column_int(stmt, 18);
1859         if (userinstalled)
1860                 pakfire_db_add_userinstalled(db->pakfire, name);
1861
1862         // Files
1863         const char* files = (const char*)sqlite3_column_text(stmt, 19);
1864         if (files) {
1865                 r = pakfire_package_set_filelist_from_string(pkg, files);
1866                 if (r)
1867                         goto ERROR;
1868         }
1869
1870         // Dependencies
1871
1872         const struct dependency {
1873                 unsigned int field;
1874                 void (*func)(struct pakfire_package* pkg, const char* dep);
1875         } dependencies[] = {
1876                 { 20, pakfire_package_add_provides },
1877                 { 21, pakfire_package_add_prerequires },
1878                 { 22, pakfire_package_add_requires },
1879                 { 23, pakfire_package_add_conflicts },
1880                 { 24, pakfire_package_add_obsoletes },
1881                 { 25, pakfire_package_add_recommends },
1882                 { 26, pakfire_package_add_suggests },
1883                 { 27, pakfire_package_add_supplements },
1884                 { 28, pakfire_package_add_enhances },
1885                 { 0, NULL },
1886         };
1887
1888         for (const struct dependency* deps = dependencies; deps->field; deps++) {
1889                 const char* relations = (const char*)sqlite3_column_text(stmt, deps->field);
1890                 if (relations) {
1891                         pakfire_str2deps(db->pakfire, pkg, deps->func, relations);
1892                 }
1893         }
1894
1895         // Source package
1896         const char* source_name = (const char*)sqlite3_column_text(stmt, 29);
1897         if (source_name)
1898                 pakfire_package_set_source_name(pkg, source_name);
1899
1900         // Source EVR
1901         const char* source_evr = (const char*)sqlite3_column_text(stmt, 30);
1902         if (source_evr)
1903                 pakfire_package_set_source_evr(pkg, source_evr);
1904
1905         // Source arch
1906         const char* source_arch = (const char*)sqlite3_column_text(stmt, 31);
1907         if (source_arch)
1908                 pakfire_package_set_source_arch(pkg, source_arch);
1909
1910         // Distribution
1911         const char* distribution = (const char*)sqlite3_column_text(stmt, 32);
1912         if (distribution) {
1913                 r = pakfire_package_set_string(pkg, PAKFIRE_PKG_DESCRIPTION, description);
1914                 if (r)
1915                         goto ERROR;
1916         }
1917
1918         // Success
1919         r = 0;
1920
1921 ERROR:
1922         if (pkg)
1923                 pakfire_package_unref(pkg);
1924
1925         return r;
1926 }
1927
1928 int pakfire_db_load(struct pakfire_db* db, struct pakfire_repo* repo) {
1929         sqlite3_stmt* stmt = NULL;
1930         int r = 1;
1931
1932         DEBUG(db->pakfire, "Loading package database...\n");
1933
1934         // Drop contents of the repository
1935         pakfire_repo_clear(repo);
1936
1937         // Save starting time
1938         clock_t t_start = clock();
1939         clock_t t_end;
1940
1941         const char* sql =
1942                 "SELECT "
1943                         "name, "
1944                         "evr, "
1945                         "arch, "
1946                         "id, "
1947                         "groups, "
1948                         "filename, "
1949                         "size, "
1950                         "inst_size, "
1951                         "digest_type, "
1952                         "digest, "
1953                         "license, "
1954                         "summary, "
1955                         "description, "
1956                         "uuid, "
1957                         "vendor, "
1958                         "build_host, "
1959                         "build_time, "
1960                         "strftime('%s', installed) AS installed, "
1961                         "userinstalled, "
1962                         "("
1963                                 "SELECT group_concat(path, '\n') FROM files WHERE files.pkg = packages.id"
1964                         ") AS files, "
1965                         "("
1966                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1967                                         "WHERE d.pkg = packages.id AND d.type = 'provides'"
1968                         ") AS provides, "
1969                         "("
1970                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1971                                         "WHERE d.pkg = packages.id AND d.type = 'prerequires'"
1972                         ") AS prerequires, "
1973                         "("
1974                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1975                                         "WHERE d.pkg = packages.id AND d.type = 'requires'"
1976                         ") AS requires, "
1977                         "("
1978                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1979                                         "WHERE d.pkg = packages.id AND d.type = 'conflicts'"
1980                         ") AS conflicts, "
1981                         "("
1982                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1983                                         "WHERE d.pkg = packages.id AND d.type = 'obsoletes'"
1984                         ") AS obsoletes, "
1985                         "("
1986                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1987                                         "WHERE d.pkg = packages.id AND d.type = 'recommends'"
1988                         ") AS recommends, "
1989                         "("
1990                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1991                                         "WHERE d.pkg = packages.id AND d.type = 'suggests'"
1992                         ") AS suggests, "
1993                         "("
1994                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1995                                         "WHERE d.pkg = packages.id AND d.type = 'supplements'"
1996                         ") AS supplements, "
1997                         "("
1998                                 "SELECT group_concat(dependency, '\n') FROM dependencies d "
1999                                         "WHERE d.pkg = packages.id AND d.type = 'enhances'"
2000                         ") AS enhances, "
2001                         "source_name, "
2002                         "source_evr, "
2003                         "source_arch, "
2004                         "distribution "
2005                 "FROM "
2006                         "packages"
2007                 ";";
2008
2009         // Prepare the statement
2010         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
2011         if (r) {
2012                 ERROR(db->pakfire, "Could not prepare SQL statement: %s %s\n",
2013                         sql, sqlite3_errmsg(db->handle));
2014                 goto ERROR;
2015         }
2016
2017         for (;;) {
2018                 // Execute query
2019                 r = sqlite3_step(stmt);
2020
2021                 switch (r) {
2022                         // Retry if the database was busy
2023                         case SQLITE_BUSY:
2024                                 continue;
2025
2026                         // Read a row
2027                         case SQLITE_ROW:
2028                                 r = pakfire_db_load_package(db, repo, stmt);
2029                                 if (r)
2030                                         goto ERROR;
2031                                 break;
2032
2033                         // All rows have been processed
2034                         case SQLITE_DONE:
2035                                 goto END;
2036
2037                         // Go to error in any other cases
2038                         default:
2039                                 goto ERROR;
2040                 }
2041         }
2042
2043 END:
2044         // Save time when we finished
2045         t_end = clock();
2046
2047         DEBUG(db->pakfire, "Loading package database completed in %.4fms\n",
2048                 (double)(t_end - t_start) * 1000 / CLOCKS_PER_SEC);
2049
2050         // Mark repository as changed
2051         pakfire_repo_has_changed(repo);
2052
2053         // All done
2054         r = 0;
2055
2056 ERROR:
2057         if (r) {
2058                 ERROR(db->pakfire, "Failed reading package database: %d\n", r);
2059                 pakfire_repo_clear(repo);
2060         }
2061
2062         if (stmt)
2063                 sqlite3_finalize(stmt);
2064
2065         return r;
2066 }
2067
2068 static int pakfire_db_load_file_digest(struct pakfire_db* db, struct pakfire_file* file,
2069                 sqlite3_stmt* stmt, const enum pakfire_digest_types type, const int field) {
2070         // Fetch digest
2071         const unsigned char* digest = sqlite3_column_blob(stmt, field);
2072
2073         // Nothing further to do if field is NULL
2074         if (!digest)
2075                 return 0;
2076
2077         // Length of the stored value
2078         const size_t length = sqlite3_column_bytes(stmt, field);
2079
2080         // Store digest
2081         return pakfire_file_set_digest(file, type, digest, length);
2082 }
2083
2084 static int pakfire_db_load_file(struct pakfire_db* db, struct pakfire_filelist* filelist,
2085                 sqlite3_stmt* stmt) {
2086         struct pakfire_file* file = NULL;
2087         int r;
2088
2089         // Create a new file object
2090         r = pakfire_file_create(&file, db->pakfire);
2091         if (r)
2092                 goto ERROR;
2093
2094         // Path
2095         const char* path = (const char*)sqlite3_column_text(stmt, 0);
2096
2097         // Abort if no path is set
2098         if (!path) {
2099                 ERROR(db->pakfire, "File has no path\n");
2100                 r = 1;
2101                 goto ERROR;
2102         }
2103
2104         // Set path
2105         r = pakfire_file_set_path(file, path);
2106         if (r) {
2107                 ERROR(db->pakfire, "%s: Could not set path '%s': %m\n", path, path);
2108                 goto ERROR;
2109         }
2110
2111         // Size
2112         size_t size = sqlite3_column_int64(stmt, 1);
2113         if (size)
2114                 pakfire_file_set_size(file, size);
2115
2116         // Mode
2117         mode_t mode = sqlite3_column_int(stmt, 2);
2118         if (mode)
2119                 pakfire_file_set_mode(file, mode);
2120
2121         // uname
2122         const char* uname = (const char*)sqlite3_column_text(stmt, 3);
2123
2124         // Abort if no user is set
2125         if (!uname) {
2126                 ERROR(db->pakfire, "%s: No user\n", path);
2127                 r = 1;
2128                 goto ERROR;
2129         }
2130
2131         // Set uname
2132         r = pakfire_file_set_uname(file, uname);
2133         if (r) {
2134                 ERROR(db->pakfire, "%s: Could not set user '%s': %m\n", path, uname);
2135                 goto ERROR;
2136         }
2137
2138         // gname
2139         const char* gname = (const char*)sqlite3_column_text(stmt, 4);
2140
2141         // Abort if no group is set
2142         if (!gname) {
2143                 ERROR(db->pakfire, "%s: No group\n", path);
2144                 r = 1;
2145                 goto ERROR;
2146         }
2147
2148         // Set gname
2149         r = pakfire_file_set_gname(file, gname);
2150         if (r) {
2151                 ERROR(db->pakfire, "%s: Could not set group '%s': %m\n", path, gname);
2152                 goto ERROR;
2153         }
2154
2155         // ctime
2156         time_t ctime = sqlite3_column_int64(stmt, 5);
2157         if (ctime)
2158                 pakfire_file_set_ctime(file, ctime);
2159
2160         // mtime
2161         time_t mtime = sqlite3_column_int64(stmt, 6);
2162         if (mtime)
2163                 pakfire_file_set_mtime(file, mtime);
2164
2165         // SHA2-512 Digest
2166         r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA2_512, 7);
2167         if (r)
2168                 goto ERROR;
2169
2170         // SHA2-256 Digest
2171         r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA2_256, 8);
2172         if (r)
2173                 goto ERROR;
2174
2175         // BLAKE2b512 Digest
2176         r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_BLAKE2B512, 9);
2177         if (r)
2178                 goto ERROR;
2179
2180         // BLAKE2s256 Digest
2181         r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_BLAKE2S256, 10);
2182         if (r)
2183                 goto ERROR;
2184
2185         // SHA3-512 Digest
2186         r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA3_512, 11);
2187         if (r)
2188                 goto ERROR;
2189
2190         // SHA3-256 Digest
2191         r = pakfire_db_load_file_digest(db, file, stmt, PAKFIRE_DIGEST_SHA3_256, 12);
2192         if (r)
2193                 goto ERROR;
2194
2195         // Append the file to the filelist
2196         r = pakfire_filelist_append(filelist, file);
2197         if (r)
2198                 goto ERROR;
2199
2200 ERROR:
2201         if (file)
2202                 pakfire_file_unref(file);
2203
2204         return r;
2205 }
2206
2207 int pakfire_db_filelist(struct pakfire_db* db, struct pakfire_filelist** filelist) {
2208         struct pakfire_filelist* list = NULL;
2209         sqlite3_stmt* stmt = NULL;
2210         int r;
2211
2212         const char* sql =
2213                 "SELECT "
2214                         "path, "
2215                         "size, "
2216                         "mode, "
2217                         "uname, "
2218                         "gname, "
2219                         "ctime, "
2220                         "mtime, "
2221                         "digest_sha2_512, "
2222                         "digest_sha2_256, "
2223                         "digest_blake2b512, "
2224                         "digest_blake2s256, "
2225                         "digest_sha3_512, "
2226                         "digest_sha3_256 "
2227                 "FROM files "
2228                 "ORDER BY path"
2229                 ";";
2230
2231         // Prepare the statement
2232         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
2233         if (r) {
2234                 ERROR(db->pakfire, "Could not prepare SQL statement: %s %s\n",
2235                         sql, sqlite3_errmsg(db->handle));
2236                 goto ERROR;
2237         }
2238
2239         // Create a new filelist
2240         r = pakfire_filelist_create(&list, db->pakfire);
2241         if (r)
2242                 goto ERROR;
2243
2244         // Iterate over all rows
2245         for (;;) {
2246                 // Execute query
2247                 r = sqlite3_step(stmt);
2248
2249                 switch (r) {
2250                         // Retry if the database was busy
2251                         case SQLITE_BUSY:
2252                                 continue;
2253
2254                         // Read a row
2255                         case SQLITE_ROW:
2256                                 r = pakfire_db_load_file(db, list, stmt);
2257                                 if (r)
2258                                         goto ERROR;
2259                                 break;
2260
2261                         // All rows have been processed
2262                         case SQLITE_DONE:
2263                                 r = 0;
2264                                 goto END;
2265
2266                         // Go to error in any other cases
2267                         default:
2268                                 goto ERROR;
2269                 }
2270         }
2271
2272 END:
2273         // Return the filelist
2274         *filelist = pakfire_filelist_ref(list);
2275
2276 ERROR:
2277         if (r)
2278                 ERROR(db->pakfire, "Could not fetch filelist: %m\n");
2279
2280         if (stmt)
2281                 sqlite3_finalize(stmt);
2282         if (list)
2283                 pakfire_filelist_unref(list);
2284
2285         return r;
2286 }
2287
2288 int pakfire_db_package_filelist(struct pakfire_db* db, struct pakfire_filelist** filelist,
2289                 struct pakfire_package* pkg) {
2290         struct pakfire_filelist* fl = NULL;
2291         sqlite3_stmt* stmt = NULL;
2292         int r = 1;
2293
2294         // Fetch the package ID
2295         uint64_t id = pakfire_package_get_dbid(pkg);
2296         if (!id) {
2297                 ERROR(db->pakfire, "Package did not have an ID\n");
2298                 return 1;
2299         }
2300
2301         // Create a new filelist
2302         r = pakfire_filelist_create(&fl, db->pakfire);
2303         if (r) {
2304                 ERROR(db->pakfire, "Could not create filelist: %m\n");
2305                 goto ERROR;
2306         }
2307
2308         const char* sql =
2309                 "SELECT "
2310                         "path, "
2311                         "size, "
2312                         "mode, "
2313                         "uname, "
2314                         "gname, "
2315                         "ctime, "
2316                         "mtime, "
2317                         "digest_sha2_512, "
2318                         "digest_sha2_256, "
2319                         "digest_blake2b512, "
2320                         "digest_blake2s256, "
2321                         "digest_sha3_512, "
2322                         "digest_sha3_256 "
2323                 "FROM files "
2324
2325                 // Select all files that belong to this package
2326                 "WHERE "
2327                         "pkg = ? "
2328
2329                 // Filter out any files that are also in a different package (i.e. an update
2330                 // that has already been installed and this is the cleanup of the obsolete pkg)
2331                 "AND "
2332                         "NOT EXISTS ("
2333                                 "SELECT "
2334                                         "1 "
2335                                 "FROM files AS duplicates "
2336                                 "WHERE "
2337                                         "files.path = duplicates.path "
2338                                 "AND "
2339                                         "files.pkg != duplicates.pkg"
2340                         ") "
2341
2342                 // Return the longest paths first
2343                 "ORDER BY "
2344                         "length(path) DESC"
2345                 ";";
2346
2347         // Prepare the statement
2348         r = sqlite3_prepare_v2(db->handle, sql, strlen(sql), &stmt, NULL);
2349         if (r) {
2350                 ERROR(db->pakfire, "Could not prepare SQL statement: %s %s\n",
2351                         sql, sqlite3_errmsg(db->handle));
2352                 goto ERROR;
2353         }
2354
2355         // Bind package ID
2356         r = sqlite3_bind_int64(stmt, 1, id);
2357         if (r) {
2358                 ERROR(db->pakfire, "Could not bind package ID: %s\n", sqlite3_errmsg(db->handle));
2359                 goto ERROR;
2360         }
2361
2362         for (;;) {
2363                 // Execute query
2364                 r = sqlite3_step(stmt);
2365
2366                 switch (r) {
2367                         // Retry if the database was busy
2368                         case SQLITE_BUSY:
2369                                 continue;
2370
2371                         // Read a row
2372                         case SQLITE_ROW:
2373                                 r = pakfire_db_load_file(db, fl, stmt);
2374                                 if (r)
2375                                         goto ERROR;
2376                                 break;
2377
2378                         // All rows have been processed
2379                         case SQLITE_DONE:
2380                                 goto END;
2381
2382                         // Go to error in any other cases
2383                         default:
2384                                 goto ERROR;
2385                 }
2386         }
2387
2388 END:
2389         *filelist = pakfire_filelist_ref(fl);
2390         r = 0;
2391
2392 ERROR:
2393         if (stmt)
2394                 sqlite3_finalize(stmt);
2395         if (fl)
2396                 pakfire_filelist_unref(fl);
2397
2398         return r;
2399 }