pkgdb.c
1 /*- 2 * Copyright (c) 2011-2025 Baptiste Daroussin <bapt@FreeBSD.org> 3 * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org> 4 * Copyright (c) 2011 Will Andrews <will@FreeBSD.org> 5 * Copyright (c) 2011 Philippe Pepiot <phil@philpep.org> 6 * Copyright (c) 2011-2012 Marin Atanasov Nikolov <dnaeon@gmail.com> 7 * Copyright (c) 2012-2013 Matthew Seaman <matthew@FreeBSD.org> 8 * Copyright (c) 2012 Bryan Drewery <bryan@shatow.net> 9 * Copyright (c) 2013 Gerald Pfeifer <gerald@pfeifer.com> 10 * Copyright (c) 2013-2014 Vsevolod Stakhov <vsevolod@FreeBSD.org> 11 * Copyright (c) 2023 Serenity Cyber Security, LLC 12 * Author: Gleb Popov <arrowd@FreeBSD.org> 13 * 14 * SPDX-License-Identifier: BSD-2-Clause 15 */ 16 17 #ifdef HAVE_CONFIG_H 18 #include "pkg_config.h" 19 #endif 20 21 #include <bsd_compat.h> 22 23 #include <sys/param.h> 24 #include <sys/mount.h> 25 26 #include <assert.h> 27 #include <errno.h> 28 #include <regex.h> 29 #include <grp.h> 30 #if __has_include(<libutil.h>) 31 #include <libutil.h> 32 #endif 33 #include <stdlib.h> 34 #include <stdio.h> 35 #include <stdbool.h> 36 #include <string.h> 37 #include <unistd.h> 38 #include <signal.h> 39 #include <fcntl.h> 40 41 #include <sqlite3.h> 42 43 #if __has_include(<sys/statvfs.h>) 44 #include <sys/statvfs.h> 45 #define HAVE_SYS_STATVFS_H 1 46 #endif 47 48 #include "pkg.h" 49 #include "private/event.h" 50 #include "private/pkg.h" 51 #include "private/pkgdb.h" 52 #include "private/utils.h" 53 #include "private/pkg_deps.h" 54 #include "pkg/vec.h" 55 56 #include "private/db_upgrades.h" 57 58 extern struct pkg_ctx ctx; 59 60 #define dbg(x, ...) pkg_dbg(PKG_DBG_DB, x, __VA_ARGS__) 61 62 /* An application using a libpkg() DBVERSION is assumed to be compatible 63 with: 64 65 * Any lower schema version of the DB, by updating the schema to DBVERSION 66 * Any equal schema version of the DB 67 * Any greater schema version of the DB with the same DB_SCHEMA_MAJOR 68 -- In general, it is OK to add new tables, but modifying or removing old 69 tables must be avoided. If necessary, this may be achieved by creating 70 appropriate VIEWS and TRIGGERS to mimic the older structure. 71 72 Anyone wishing to make a schema change that necessitates incrementing 73 DB_SCHEMA_MAJOR must first present every other pkgng developer with one 74 of the Golden Apples of the Hesperides 75 */ 76 77 #define DB_SCHEMA_MAJOR 0 78 #define DB_SCHEMA_MINOR 39 79 80 #define DBVERSION (DB_SCHEMA_MAJOR * 1000 + DB_SCHEMA_MINOR) 81 82 static int pkgdb_upgrade(struct pkgdb *); 83 static int pkgdb_init(sqlite3 *sdb); 84 static int prstmt_initialize(struct pkgdb *db); 85 static void prstmt_finalize(struct pkgdb *db); 86 static int pkgdb_insert_scripts(struct pkg *pkg, int64_t package_id, sqlite3 *s); 87 static int pkgdb_insert_lua_scripts(struct pkg *pkg, int64_t package_id, sqlite3 *s); 88 89 extern int sqlite3_shell(int, char**); 90 91 struct sqlite3_stmt * 92 prepare_sql(sqlite3 *s, const char *sql) 93 { 94 int ret; 95 sqlite3_stmt *stmt; 96 97 ret = sqlite3_prepare_v2(s, sql, strlen(sql), &stmt, 98 NULL); 99 if (ret != SQLITE_OK) { 100 ERROR_SQLITE(s, sql); 101 return (NULL); 102 } 103 return (stmt); 104 } 105 106 void 107 pkgdb_regex(sqlite3_context *ctx, int argc, sqlite3_value **argv) 108 { 109 const unsigned char *regex = NULL; 110 const unsigned char *str; 111 regex_t *re; 112 int ret; 113 114 if (argc != 2) { 115 sqlite3_result_error(ctx, "SQL function regex() called " 116 "with invalid number of arguments.\n", -1); 117 return; 118 } 119 if ((regex = sqlite3_value_text(argv[0])) == NULL) { 120 sqlite3_result_error(ctx, "SQL function regex() called " 121 "without a regular expression.\n", -1); 122 return; 123 } 124 125 re = (regex_t *)sqlite3_get_auxdata(ctx, 0); 126 if (re == NULL) { 127 int cflags; 128 129 if (pkgdb_case_sensitive()) 130 cflags = REG_EXTENDED | REG_NOSUB; 131 else 132 cflags = REG_EXTENDED | REG_NOSUB | REG_ICASE; 133 134 re = xmalloc(sizeof(regex_t)); 135 if (regcomp(re, regex, cflags) != 0) { 136 sqlite3_result_error(ctx, "Invalid regex\n", -1); 137 free(re); 138 return; 139 } 140 141 sqlite3_set_auxdata(ctx, 0, re, pkgdb_regex_delete); 142 } 143 144 if ((str = sqlite3_value_text(argv[1])) != NULL) { 145 ret = regexec(re, str, 0, NULL, 0); 146 sqlite3_result_int(ctx, (ret != REG_NOMATCH)); 147 } 148 } 149 150 void 151 pkgdb_regex_delete(void *p) 152 { 153 regex_t *re = (regex_t *)p; 154 155 regfree(re); 156 free(re); 157 } 158 159 void 160 pkgdb_now(sqlite3_context *ctx, int argc, __unused sqlite3_value **argv) 161 { 162 int64_t t = (int64_t)time(NULL); 163 const char *date_env; 164 165 if (argc != 0) { 166 sqlite3_result_error(ctx, "Invalid usage of now() " 167 "no arguments expected\n", -1); 168 return; 169 } 170 171 if ((date_env = getenv("PKG_INSTALL_EPOCH")) != NULL) 172 { 173 const char *errstr = NULL; 174 int64_t temp_t = strtonum(date_env, 0, INT64_MAX, &errstr); 175 if (errstr == NULL) { 176 t = temp_t; 177 } 178 } 179 180 sqlite3_result_int64(ctx, t); 181 } 182 183 static void 184 pkgdb_vercmp(sqlite3_context *ctx, int argc, sqlite3_value **argv) 185 { 186 const char *op_str, *arg1, *arg2; 187 enum pkg_dep_version_op op; 188 int cmp; 189 bool ret; 190 191 if (argc != 3) { 192 sqlite3_result_error(ctx, "Invalid usage of vercmp\n", -1); 193 return; 194 } 195 196 op_str = sqlite3_value_text(argv[0]); 197 arg1 = sqlite3_value_text(argv[1]); 198 arg2 = sqlite3_value_text(argv[2]); 199 200 if (op_str == NULL || arg1 == NULL || arg2 == NULL) { 201 sqlite3_result_error(ctx, "Invalid usage of vercmp\n", -1); 202 return; 203 } 204 205 op = pkg_deps_string_toop(op_str); 206 cmp = pkg_version_cmp(arg1, arg2); 207 208 switch(op) { 209 case VERSION_ANY: 210 default: 211 ret = true; 212 break; 213 case VERSION_EQ: 214 ret = (cmp == 0); 215 break; 216 case VERSION_GE: 217 ret = (cmp >= 0); 218 break; 219 case VERSION_LE: 220 ret = (cmp <= 0); 221 break; 222 case VERSION_GT: 223 ret = (cmp > 0); 224 break; 225 case VERSION_LT: 226 ret = (cmp < 0); 227 break; 228 case VERSION_NOT: 229 ret = (cmp != 0); 230 break; 231 } 232 233 sqlite3_result_int(ctx, ret); 234 } 235 236 static int 237 pkgdb_upgrade(struct pkgdb *db) 238 { 239 int64_t db_version = -1; 240 const char *sql_upgrade; 241 int i, ret; 242 243 assert(db != NULL); 244 245 ret = get_pragma(db->sqlite, "PRAGMA user_version;", &db_version, false); 246 if (ret != EPKG_OK) 247 return (EPKG_FATAL); 248 249 if (db_version == DBVERSION) 250 return (EPKG_OK); 251 252 /* 253 * If user_version is 0 the database has no schema yet. This 254 * can happen when another process created the file but has not 255 * yet committed pkgdb_init(). Initialize from scratch instead 256 * of running incremental migrations which would fail because 257 * the base tables do not exist. 258 */ 259 if (db_version == 0) 260 return (pkgdb_init(db->sqlite)); 261 262 if (db_version > DBVERSION) { 263 if (db_version / 1000 <= DB_SCHEMA_MAJOR) { 264 /* VIEWS and TRIGGERS used as compatibility hack */ 265 pkg_emit_error("warning: database version %" PRId64 266 " is newer than libpkg(3) version %d, but still " 267 "compatible", db_version, DBVERSION); 268 return (EPKG_OK); 269 } else { 270 pkg_emit_error("database version %" PRId64 " is newer " 271 "than and incompatible with libpkg(3) version %d", 272 db_version, DBVERSION); 273 return (EPKG_FATAL); 274 } 275 } 276 277 while (db_version < DBVERSION) { 278 const char *sql_str; 279 if (sqlite3_db_readonly(db->sqlite, "main")) { 280 pkg_emit_error("The database is outdated and " 281 "opened readonly"); 282 return (EPKG_FATAL); 283 } 284 db_version++; 285 286 i = 0; 287 sql_upgrade = NULL; 288 while (db_upgrades[i].version != -1) { 289 if (db_upgrades[i].version == db_version) { 290 sql_upgrade = db_upgrades[i].sql; 291 break; 292 } 293 i++; 294 } 295 296 /* 297 * We can't find the statements to upgrade to the next version, 298 * maybe because the current version is too old and upgrade 299 * support has been removed. 300 */ 301 if (sql_upgrade == NULL) { 302 pkg_emit_error("can not upgrade to db version %" PRId64, 303 db_version); 304 return (EPKG_FATAL); 305 } 306 307 if (pkgdb_transaction_begin_sqlite(db->sqlite, NULL) != EPKG_OK) 308 return (EPKG_FATAL); 309 310 if (sql_exec(db->sqlite, sql_upgrade) != EPKG_OK) { 311 pkgdb_transaction_rollback_sqlite(db->sqlite, NULL); 312 return (EPKG_FATAL); 313 } 314 315 sql_str = "PRAGMA user_version = %" PRId64 ";"; 316 ret = sql_exec(db->sqlite, sql_str, db_version); 317 if (ret != EPKG_OK) { 318 pkgdb_transaction_rollback_sqlite(db->sqlite, NULL); 319 return (EPKG_FATAL); 320 } 321 322 if (pkgdb_transaction_commit_sqlite(db->sqlite, NULL) != EPKG_OK) 323 return (EPKG_FATAL); 324 } 325 326 return (EPKG_OK); 327 } 328 329 /* 330 * in the database : 331 * scripts.type can be: 332 * - 0: PRE_INSTALL 333 * - 1: POST_INSTALL 334 * - 2: PRE_DEINSTALL 335 * - 3: POST_DEINSTALL 336 * - 4: PRE_UPGRADE 337 * - 5: POST_UPGRADE 338 * - 6: INSTALL 339 * - 7: DEINSTALL 340 * - 8: UPGRADE 341 */ 342 343 static int 344 pkgdb_init(sqlite3 *sdb) 345 { 346 const char sql[] = "" 347 "PRAGMA journal_mode = TRUNCATE;" 348 "PRAGMA synchronous = FULL;" 349 "BEGIN;" 350 "CREATE TABLE packages (" 351 "id INTEGER PRIMARY KEY," 352 "origin TEXT NOT NULL," 353 "name TEXT NOT NULL," 354 "version TEXT NOT NULL," 355 "comment TEXT NOT NULL," 356 "desc TEXT NOT NULL," 357 "mtree_id INTEGER, " 358 "message TEXT," 359 "arch TEXT NOT NULL," 360 "maintainer TEXT NOT NULL, " 361 "www TEXT," 362 "prefix TEXT NOT NULL," 363 "flatsize INTEGER NOT NULL," 364 "automatic INTEGER NOT NULL," 365 "locked INTEGER NOT NULL DEFAULT 0," 366 "licenselogic INTEGER NOT NULL," 367 "time INTEGER, " 368 "manifestdigest TEXT NULL, " 369 "pkg_format_version INTEGER," 370 "dep_formula TEXT NULL" 371 ",vital INTEGER NOT NULL DEFAULT 0" 372 ");" 373 "CREATE UNIQUE INDEX packages_unique ON packages(name);" 374 "CREATE TABLE pkg_script (" 375 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 376 " ON UPDATE CASCADE," 377 "type INTEGER," 378 "script_id INTEGER REFERENCES script(script_id)" 379 " ON DELETE RESTRICT ON UPDATE CASCADE," 380 "PRIMARY KEY (package_id, type)" 381 ");" 382 "CREATE TABLE script (" 383 "script_id INTEGER PRIMARY KEY," 384 "script TEXT NOT NULL UNIQUE" 385 ");" 386 "CREATE TABLE option (" 387 "option_id INTEGER PRIMARY KEY," 388 "option TEXT NOT NULL UNIQUE" 389 ");" 390 "CREATE TABLE option_desc (" 391 "option_desc_id INTEGER PRIMARY KEY," 392 "option_desc TEXT NOT NULL UNIQUE" 393 ");" 394 "CREATE TABLE pkg_option (" 395 "package_id INTEGER NOT NULL REFERENCES packages(id) " 396 "ON DELETE CASCADE ON UPDATE CASCADE," 397 "option_id INTEGER NOT NULL REFERENCES option(option_id) " 398 "ON DELETE RESTRICT ON UPDATE CASCADE," 399 "value TEXT NOT NULL," 400 "PRIMARY KEY(package_id, option_id)" 401 ");" 402 "CREATE TABLE pkg_option_desc (" 403 "package_id INTEGER NOT NULL REFERENCES packages(id) " 404 "ON DELETE CASCADE ON UPDATE CASCADE," 405 "option_id INTEGER NOT NULL REFERENCES option(option_id) " 406 "ON DELETE RESTRICT ON UPDATE CASCADE," 407 "option_desc_id INTEGER NOT NULL " 408 "REFERENCES option_desc(option_desc_id) " 409 "ON DELETE RESTRICT ON UPDATE CASCADE," 410 "PRIMARY KEY(package_id, option_id)" 411 ");" 412 "CREATE TABLE pkg_option_default (" 413 "package_id INTEGER NOT NULL REFERENCES packages(id) " 414 "ON DELETE CASCADE ON UPDATE CASCADE," 415 "option_id INTEGER NOT NULL REFERENCES option(option_id) " 416 "ON DELETE RESTRICT ON UPDATE CASCADE," 417 "default_value TEXT NOT NULL," 418 "PRIMARY KEY(package_id, option_id)" 419 ");" 420 "CREATE TABLE deps (" 421 "origin TEXT NOT NULL," 422 "name TEXT NOT NULL," 423 "version TEXT NOT NULL," 424 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 425 " ON UPDATE CASCADE" 426 ");" 427 "CREATE UNIQUE INDEX deps_unique ON deps(name, version, package_id);" 428 "CREATE TABLE files (" 429 "path TEXT PRIMARY KEY," 430 "sha256 TEXT," 431 "uname TEXT," 432 "gname TEXT," 433 "perm INTEGER," 434 "fflags INTEGER," 435 "mtime INTEGER," 436 "symlink_target TEXT," 437 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 438 " ON UPDATE CASCADE" 439 ");" 440 "CREATE TABLE directories (" 441 "id INTEGER PRIMARY KEY," 442 "path TEXT NOT NULL UNIQUE," 443 "uname TEXT," 444 "gname TEXT," 445 "perm INTEGER," 446 "fflags INTEGER" 447 ");" 448 "CREATE TABLE pkg_directories (" 449 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 450 " ON UPDATE CASCADE," 451 "directory_id INTEGER REFERENCES directories(id) ON DELETE RESTRICT" 452 " ON UPDATE RESTRICT," 453 "try INTEGER," 454 "PRIMARY KEY (package_id, directory_id)" 455 ");" 456 "CREATE TABLE categories (" 457 "id INTEGER PRIMARY KEY," 458 "name TEXT NOT NULL UNIQUE" 459 ");" 460 "CREATE TABLE pkg_categories (" 461 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 462 " ON UPDATE CASCADE," 463 "category_id INTEGER REFERENCES categories(id) ON DELETE RESTRICT" 464 " ON UPDATE RESTRICT," 465 "PRIMARY KEY (package_id, category_id)" 466 ");" 467 "CREATE TABLE licenses (" 468 "id INTEGER PRIMARY KEY," 469 "name TEXT NOT NULL UNIQUE" 470 ");" 471 "CREATE TABLE pkg_licenses (" 472 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 473 " ON UPDATE CASCADE," 474 "license_id INTEGER REFERENCES licenses(id) ON DELETE RESTRICT" 475 " ON UPDATE RESTRICT," 476 "PRIMARY KEY (package_id, license_id)" 477 ");" 478 "CREATE TABLE users (" 479 "id INTEGER PRIMARY KEY," 480 "name TEXT NOT NULL UNIQUE" 481 ");" 482 "CREATE TABLE pkg_users (" 483 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 484 " ON UPDATE CASCADE," 485 "user_id INTEGER REFERENCES users(id) ON DELETE RESTRICT" 486 " ON UPDATE RESTRICT," 487 "UNIQUE(package_id, user_id)" 488 ");" 489 "CREATE TABLE groups (" 490 "id INTEGER PRIMARY KEY," 491 "name TEXT NOT NULL UNIQUE" 492 ");" 493 "CREATE TABLE pkg_groups (" 494 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 495 " ON UPDATE CASCADE," 496 "group_id INTEGER REFERENCES groups(id) ON DELETE RESTRICT" 497 " ON UPDATE RESTRICT," 498 "UNIQUE(package_id, group_id)" 499 ");" 500 "CREATE TABLE shlibs (" 501 "id INTEGER PRIMARY KEY," 502 "name TEXT NOT NULL UNIQUE" 503 ");" 504 "CREATE TABLE pkg_shlibs_required (" 505 "package_id INTEGER NOT NULL REFERENCES packages(id)" 506 " ON DELETE CASCADE ON UPDATE CASCADE," 507 "shlib_id INTEGER NOT NULL REFERENCES shlibs(id)" 508 " ON DELETE RESTRICT ON UPDATE RESTRICT," 509 "UNIQUE (package_id, shlib_id)" 510 ");" 511 "CREATE TABLE pkg_shlibs_required_ignore (" 512 "package_id INTEGER NOT NULL REFERENCES packages(id)" 513 " ON DELETE CASCADE ON UPDATE CASCADE," 514 "shlib_id INTEGER NOT NULL REFERENCES shlibs(id)" 515 " ON DELETE RESTRICT ON UPDATE RESTRICT," 516 "UNIQUE (package_id, shlib_id)" 517 ");" 518 "CREATE TABLE pkg_shlibs_provided (" 519 "package_id INTEGER NOT NULL REFERENCES packages(id)" 520 " ON DELETE CASCADE ON UPDATE CASCADE," 521 "shlib_id INTEGER NOT NULL REFERENCES shlibs(id)" 522 " ON DELETE RESTRICT ON UPDATE RESTRICT," 523 "UNIQUE (package_id, shlib_id)" 524 ");" 525 "CREATE TABLE pkg_shlibs_provided_ignore (" 526 "package_id INTEGER NOT NULL REFERENCES packages(id)" 527 " ON DELETE CASCADE ON UPDATE CASCADE," 528 "shlib_id INTEGER NOT NULL REFERENCES shlibs(id)" 529 " ON DELETE RESTRICT ON UPDATE RESTRICT," 530 "UNIQUE (package_id, shlib_id)" 531 ");" 532 "CREATE TABLE annotation (" 533 "annotation_id INTEGER PRIMARY KEY," 534 "annotation TEXT NOT NULL UNIQUE" 535 ");" 536 "CREATE TABLE pkg_annotation (" 537 "package_id INTEGER REFERENCES packages(id)" 538 " ON DELETE CASCADE ON UPDATE RESTRICT," 539 "tag_id INTEGER NOT NULL REFERENCES annotation(annotation_id)" 540 " ON DELETE CASCADE ON UPDATE RESTRICT," 541 "value_id INTEGER NOT NULL REFERENCES annotation(annotation_id)" 542 " ON DELETE CASCADE ON UPDATE RESTRICT," 543 "UNIQUE (package_id, tag_id)" 544 ");" 545 "CREATE TABLE pkg_conflicts (" 546 "package_id INTEGER NOT NULL REFERENCES packages(id)" 547 " ON DELETE CASCADE ON UPDATE CASCADE," 548 "conflict_id INTEGER NOT NULL," 549 "UNIQUE(package_id, conflict_id)" 550 ");" 551 "CREATE TABLE pkg_lock (" 552 "exclusive INTEGER(1)," 553 "advisory INTEGER(1)," 554 "read INTEGER(8)" 555 ");" 556 "CREATE TABLE pkg_lock_pid (" 557 "pid INTEGER PRIMARY KEY" 558 ");" 559 "INSERT INTO pkg_lock VALUES(0,0,0);" 560 "CREATE TABLE provides(" 561 " id INTEGER PRIMARY KEY," 562 " provide TEXT NOT NULL" 563 ");" 564 "CREATE TABLE pkg_provides (" 565 "package_id INTEGER NOT NULL REFERENCES packages(id)" 566 " ON DELETE CASCADE ON UPDATE CASCADE," 567 "provide_id INTEGER NOT NULL REFERENCES provides(id)" 568 " ON DELETE RESTRICT ON UPDATE RESTRICT," 569 "UNIQUE(package_id, provide_id)" 570 ");" 571 "CREATE TABLE config_files (" 572 "path TEXT NOT NULL UNIQUE, " 573 "content TEXT, " 574 "package_id INTEGER REFERENCES packages(id) ON DELETE CASCADE" 575 " ON UPDATE CASCADE" 576 ");" 577 578 /* Mark the end of the array */ 579 580 "CREATE INDEX deporigini on deps(origin);" 581 "CREATE INDEX pkg_script_package_id ON pkg_script(package_id);" 582 "CREATE INDEX deps_package_id ON deps (package_id);" 583 "CREATE INDEX files_package_id ON files (package_id);" 584 "CREATE INDEX pkg_directories_package_id ON pkg_directories (package_id);" 585 "CREATE INDEX pkg_categories_package_id ON pkg_categories (package_id);" 586 "CREATE INDEX pkg_licenses_package_id ON pkg_licenses (package_id);" 587 "CREATE INDEX pkg_users_package_id ON pkg_users (package_id);" 588 "CREATE INDEX pkg_groups_package_id ON pkg_groups (package_id);" 589 "CREATE INDEX pkg_shlibs_required_package_id ON pkg_shlibs_required (package_id);" 590 "CREATE INDEX pkg_shlibs_required_ignore_package_id ON pkg_shlibs_required_ignore (package_id);" 591 "CREATE INDEX pkg_shlibs_provided_package_id ON pkg_shlibs_provided (package_id);" 592 "CREATE INDEX pkg_shlibs_provided_ignore_package_id ON pkg_shlibs_provided_ignore (package_id);" 593 "CREATE INDEX pkg_directories_directory_id ON pkg_directories (directory_id);" 594 "CREATE INDEX pkg_annotation_package_id ON pkg_annotation(package_id);" 595 "CREATE INDEX pkg_digest_id ON packages(origin, manifestdigest);" 596 "CREATE INDEX pkg_conflicts_pid ON pkg_conflicts(package_id);" 597 "CREATE INDEX pkg_conflicts_cid ON pkg_conflicts(conflict_id);" 598 "CREATE INDEX pkg_provides_id ON pkg_provides(package_id);" 599 "CREATE INDEX provides_provide ON provides(provide);" 600 "CREATE INDEX pkg_provides_provide_id ON pkg_provides(provide_id);" 601 "CREATE INDEX packages_origin ON packages(origin COLLATE NOCASE);" 602 "CREATE INDEX packages_name ON packages(name COLLATE NOCASE);" 603 "CREATE TABLE requires(" 604 " id INTEGER PRIMARY KEY," 605 " require TEXT NOT NULL" 606 ");" 607 "CREATE TABLE pkg_requires (" 608 "package_id INTEGER NOT NULL REFERENCES packages(id)" 609 " ON DELETE CASCADE ON UPDATE CASCADE," 610 "require_id INTEGER NOT NULL REFERENCES requires(id)" 611 " ON DELETE RESTRICT ON UPDATE RESTRICT," 612 "UNIQUE(package_id, require_id)" 613 ");" 614 "CREATE INDEX requires_require ON requires(require);" 615 "CREATE INDEX pkg_requires_require_id ON pkg_requires(require_id);" 616 "CREATE INDEX pkg_requires_package_id ON pkg_requires(package_id);" 617 "CREATE INDEX config_files_package_id ON config_files(package_id);" 618 "CREATE TABLE lua_script(" 619 " lua_script_id INTEGER PRIMARY KEY," 620 " lua_script TEXT NOT NULL UNIQUE" 621 ");" 622 "CREATE TABLE pkg_lua_script (" 623 "package_id INTEGER NOT NULL REFERENCES packages(id)" 624 " ON DELETE CASCADE ON UPDATE CASCADE," 625 "lua_script_id INTEGER NOT NULL REFERENCES lua_script(lua_script_id)" 626 " ON DELETE RESTRICT ON UPDATE RESTRICT," 627 "type INTEGER," 628 "UNIQUE(package_id, lua_script_id)" 629 ");" 630 "CREATE INDEX pkg_lua_script_package_id ON pkg_lua_script(package_id);" 631 "PRAGMA user_version = %d;" 632 "COMMIT;" 633 ; 634 635 return (sql_exec(sdb, sql, DBVERSION)); 636 } 637 638 static int 639 pkgdb_is_insecure_mode(int dbdirfd, const char *path, bool install_as_user) 640 { 641 uid_t fileowner; 642 gid_t filegroup; 643 bool bad_perms = false; 644 bool wrong_owner = false; 645 struct stat sb; 646 647 if (dbdirfd == -1) 648 return (EPKG_ENODB); 649 650 if (install_as_user) { 651 fileowner = geteuid(); 652 filegroup = getegid(); 653 } else { 654 fileowner = 0; 655 filegroup = 0; 656 } 657 658 if (fstatat(dbdirfd, path, &sb, 0) != 0) { 659 if (errno == EACCES) 660 return (EPKG_ENOACCESS); 661 else if (errno == ENOENT) 662 return (EPKG_ENODB); 663 else 664 return (EPKG_FATAL); 665 } 666 667 /* if fileowner == 0, root ownership and no group or other 668 read access. if fileowner != 0, require no other read 669 access and group read access IFF the group ownership == 670 filegroup */ 671 672 if ( fileowner == 0 ) { 673 if ((sb.st_mode & (S_IWGRP|S_IWOTH)) != 0) 674 bad_perms = true; 675 if (sb.st_uid != fileowner) 676 wrong_owner = true; 677 } else { 678 if ((sb.st_mode & S_IWOTH) != 0) 679 bad_perms = true; 680 if (sb.st_gid != filegroup && (sb.st_mode & S_IWGRP) != 0) 681 bad_perms = true; 682 if (sb.st_uid != 0 && sb.st_uid != fileowner && sb.st_gid != filegroup) 683 wrong_owner = true; 684 } 685 686 if (bad_perms) { 687 pkg_emit_error("%s permissions (%#o) too lax", path, 688 (sb.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO))); 689 return (EPKG_INSECURE); 690 } 691 if (wrong_owner) { 692 pkg_emit_error("%s wrong user or group ownership" 693 " (expected %d/%d versus actual %d/%d)", 694 path, fileowner, filegroup, sb.st_uid, sb.st_gid); 695 return (EPKG_INSECURE); 696 } 697 698 return (EPKG_OK); 699 } 700 701 int 702 pkgdb_check_access(unsigned mode, const char *dbname) 703 { 704 const char *dbpath = "."; 705 int retval; 706 bool database_exists; 707 bool install_as_user; 708 int dbdirfd = pkg_get_dbdirfd(); 709 710 if (dbname != NULL) 711 dbpath = dbname; 712 713 install_as_user = (getenv("INSTALL_AS_USER") != NULL); 714 715 retval = pkgdb_is_insecure_mode(dbdirfd, dbpath, install_as_user); 716 717 database_exists = (retval != EPKG_ENODB); 718 719 if (database_exists && retval != EPKG_OK) 720 return (retval); 721 722 if (!database_exists && (mode & PKGDB_MODE_CREATE) != 0) 723 return (EPKG_OK); 724 725 retval = -1; 726 switch(mode & (PKGDB_MODE_READ|PKGDB_MODE_WRITE)) { 727 case 0: /* Existence test */ 728 if (dbdirfd == -1) 729 goto out; 730 retval = faccessat(dbdirfd, dbpath, F_OK, AT_EACCESS); 731 break; 732 case PKGDB_MODE_READ: 733 if (dbdirfd == -1) 734 goto out; 735 retval = faccessat(dbdirfd, dbpath, R_OK, AT_EACCESS); 736 break; 737 case PKGDB_MODE_WRITE: 738 if (dbdirfd == -1) { 739 pkg_mkdirs(ctx.dbdir); 740 dbdirfd = pkg_get_dbdirfd(); 741 if (dbdirfd == -1) 742 goto out; 743 } 744 retval = faccessat(dbdirfd, dbpath, W_OK, AT_EACCESS); 745 break; 746 case PKGDB_MODE_READ|PKGDB_MODE_WRITE: 747 if (dbdirfd == -1) { 748 pkg_mkdirs(ctx.dbdir); 749 dbdirfd = pkg_get_dbdirfd(); 750 if (dbdirfd == -1) 751 goto out; 752 } 753 retval = faccessat(dbdirfd, dbpath, R_OK|W_OK, AT_EACCESS); 754 break; 755 } 756 757 out: 758 if (retval != 0) { 759 if (errno == ENOENT) 760 return (EPKG_ENODB); 761 else if (errno == EACCES || errno == EROFS) 762 return (EPKG_ENOACCESS); 763 else 764 return (EPKG_FATAL); 765 } 766 767 return (EPKG_OK); 768 } 769 770 int 771 pkgdb_access(unsigned mode, unsigned database) 772 { 773 774 return (pkgdb_access2(mode, database, NULL)); 775 } 776 777 int 778 pkgdb_access2(unsigned mode, unsigned database, c_charv_t *dbs) 779 { 780 int retval = EPKG_OK; 781 782 /* 783 * This will return one of: 784 * 785 * EPKG_ENODB: a database doesn't exist and we don't want to create 786 * it, or dbdir doesn't exist 787 * 788 * EPKG_INSECURE: the dbfile or one of the directories in the 789 * path to it are writable by other than root or 790 * (if $INSTALL_AS_USER is set) the current euid 791 * and egid 792 * 793 * EPKG_ENOACCESS: we don't have privileges to read or write 794 * 795 * EPKG_FATAL: Couldn't determine the answer for other reason, 796 * like configuration screwed up, invalid argument values, 797 * read-only filesystem, etc. 798 * 799 * EPKG_OK: We can go ahead 800 */ 801 802 803 if ((mode & ~(PKGDB_MODE_READ|PKGDB_MODE_WRITE|PKGDB_MODE_CREATE)) 804 != 0) 805 return (EPKG_FATAL); /* EINVAL */ 806 807 if ((database & ~(PKGDB_DB_LOCAL|PKGDB_DB_REPO)) != 0) 808 return (EPKG_FATAL); /* EINVAL */ 809 810 /* Test the enclosing directory: if we're going to create the 811 DB, then we need read and write permissions on the dir. 812 Otherwise, just test for read access */ 813 814 if ((mode & PKGDB_MODE_CREATE) != 0) { 815 retval = pkgdb_check_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE, 816 NULL); 817 } else 818 retval = pkgdb_check_access(PKGDB_MODE_READ, NULL); 819 if (retval != EPKG_OK) 820 return (retval); 821 822 /* Test local.sqlite, if required */ 823 824 if ((database & PKGDB_DB_LOCAL) != 0) { 825 retval = pkgdb_check_access(mode, "local.sqlite"); 826 if (retval != EPKG_OK) 827 return (retval); 828 } 829 830 if ((database & PKGDB_DB_REPO) != 0) { 831 struct pkg_repo *r = NULL; 832 833 while (pkg_repos(&r) == EPKG_OK) { 834 /* Ignore any repos marked as inactive */ 835 if (!pkg_repo_enabled(r)) 836 continue; 837 838 if (dbs != NULL && dbs->len > 0 && r->name && 839 !c_charv_contains(dbs, r->name, true)) { 840 /* Skip what is not needed */ 841 continue; 842 } 843 844 retval = r->ops->access(r, mode); 845 if (retval != EPKG_OK) { 846 if (retval == EPKG_ENODB && 847 (mode & PKGDB_MODE_READ) != PKGDB_MODE_READ) { 848 pkg_emit_error("Repository %s missing." 849 " 'pkg update' required", 850 r->name); 851 } 852 853 return (retval); 854 } 855 } 856 } 857 return (retval); 858 } 859 860 static int 861 pkgdb_profile_callback(unsigned type __unused, void *ud __unused, 862 void *stmt, void *X) 863 { 864 sqlite3_uint64 nsec = *((sqlite3_uint64*)X); 865 const char *req = sqlite3_sql((sqlite3_stmt *)stmt); 866 /* According to sqlite3 documentation, nsec has milliseconds accuracy */ 867 nsec /= 1000000LLU; 868 if (nsec > 0) 869 dbg(1, "Sqlite request %s was executed in %lu milliseconds", 870 req, (unsigned long)nsec); 871 return (0); 872 } 873 874 int 875 pkgdb_open(struct pkgdb **db_p, pkgdb_t type) 876 { 877 return (pkgdb_open_all(db_p, type, NULL)); 878 } 879 880 /* the higher the better */ 881 static int 882 repos_prio_cmp(const void *a, const void *b) 883 { 884 struct pkg_repo *ra = *(struct pkg_repo **)a; 885 struct pkg_repo *rb = *(struct pkg_repo **)b; 886 887 return ((ra->priority < rb->priority) - (ra->priority > rb->priority)); 888 } 889 890 static int 891 pkgdb_open_repos(struct pkgdb *db, const char *reponame) 892 { 893 struct pkg_repo *r = NULL; 894 895 while (pkg_repos(&r) == EPKG_OK) { 896 if (!r->enable && reponame == NULL) { 897 continue; 898 } 899 900 if (reponame == NULL || STRIEQ(r->name, reponame)) { 901 /* We need read only access here */ 902 if (r->ops->open(r, R_OK) == EPKG_OK) { 903 r->ops->init(r); 904 vec_push(&db->repos, r); 905 } else 906 pkg_emit_error("Repository %s cannot be opened." 907 " 'pkg update' required", r->name); 908 } 909 } 910 qsort(db->repos.d, db->repos.len, sizeof(db->repos.d[0]), repos_prio_cmp); 911 912 return (EPKG_OK); 913 } 914 915 static const char* 916 _dbdir_trim_path(const char*path) 917 { 918 static size_t l = 0; 919 const char *p; 920 921 if (l == 0) 922 l = strlen(ctx.dbdir); 923 924 if (strncmp(ctx.dbdir, path, l) == 0) { 925 p = path + l; 926 while (*p == '/') 927 p++; 928 return (p); 929 } 930 if (*path == '/') 931 return (path + 1); 932 return (path); 933 } 934 935 static int 936 _dbdir_open(const char *path, int flags, int mode) 937 { 938 int dfd = pkg_get_dbdirfd(); 939 940 return (openat(dfd, _dbdir_trim_path(path), flags, mode)); 941 } 942 943 static int 944 _dbdir_access(const char *path, int mode) 945 { 946 int dfd = pkg_get_dbdirfd(); 947 948 return (faccessat(dfd, _dbdir_trim_path(path), mode, 0)); 949 } 950 951 static int 952 _dbdir_stat(const char * path, struct stat * sb) 953 { 954 int dfd = pkg_get_dbdirfd(); 955 956 return (fstatat(dfd, _dbdir_trim_path(path), sb, 0)); 957 } 958 959 static int 960 _dbdir_lstat(const char * path, struct stat * sb) 961 { 962 int dfd = pkg_get_dbdirfd(); 963 964 return (fstatat(dfd, _dbdir_trim_path(path), sb, AT_SYMLINK_NOFOLLOW)); 965 } 966 967 static int 968 _dbdir_unlink(const char *path) 969 { 970 int dfd = pkg_get_dbdirfd(); 971 972 return (unlinkat(dfd, _dbdir_trim_path(path), 0)); 973 } 974 975 static int 976 _dbdir_mkdir(const char *path, mode_t mode) 977 { 978 int dfd = pkg_get_dbdirfd(); 979 980 return (mkdirat(dfd, _dbdir_trim_path(path), mode)); 981 } 982 983 static char * 984 _dbdir_getcwd(char *path, size_t sz) 985 { 986 if (0 == sz) { 987 errno = EINVAL; 988 } else if (sz >= 2) { 989 path[0] = '/'; 990 path[1] = '\0'; 991 return path; 992 } else { 993 errno = ERANGE; 994 } 995 return 0; 996 } 997 998 static bool 999 pkgdb_is_local_fs(int fd) { 1000 #if defined(HAVE_SYS_STATVFS_H) && defined(ST_LOCAL) 1001 struct statvfs stfs; 1002 if (fstatvfs(fd, &stfs) == 0) { 1003 return (stfs.f_flag & ST_LOCAL); 1004 } 1005 #elif defined(MNT_LOCAL) 1006 struct statfs stfs; 1007 if (fstatfs(fd, &stfs) == 0) { 1008 return (stfs.f_flags & MNT_LOCAL); 1009 } 1010 #endif 1011 return (true); 1012 } 1013 1014 void 1015 pkgdb_syscall_overload(void) 1016 { 1017 sqlite3_vfs *vfs; 1018 1019 vfs = sqlite3_vfs_find(NULL); 1020 vfs->xSetSystemCall(vfs, "open", (sqlite3_syscall_ptr)_dbdir_open); 1021 vfs->xSetSystemCall(vfs, "access", (sqlite3_syscall_ptr)_dbdir_access); 1022 vfs->xSetSystemCall(vfs, "stat", (sqlite3_syscall_ptr)_dbdir_stat); 1023 vfs->xSetSystemCall(vfs, "lstat", (sqlite3_syscall_ptr)_dbdir_lstat); 1024 vfs->xSetSystemCall(vfs, "unlink", (sqlite3_syscall_ptr)_dbdir_unlink); 1025 vfs->xSetSystemCall(vfs, "mkdir", (sqlite3_syscall_ptr)_dbdir_mkdir); 1026 vfs->xSetSystemCall(vfs, "getcwd", (sqlite3_syscall_ptr)_dbdir_getcwd); 1027 } 1028 1029 void 1030 pkgdb_nfs_corruption(sqlite3 *db) 1031 { 1032 1033 if (sqlite3_errcode(db) != SQLITE_CORRUPT) 1034 return; 1035 1036 /* 1037 * Fall back on unix-dotfile locking strategy if on a network filesystem 1038 */ 1039 1040 int dbdirfd = pkg_get_dbdirfd(); 1041 if (!pkgdb_is_local_fs(dbdirfd)) { 1042 pkg_emit_error("You are running on a remote filesystem," 1043 " please make sure, the locking mechanism is " 1044 " properly setup\n"); 1045 } 1046 } 1047 1048 int 1049 pkgdb_open_all(struct pkgdb **db_p, pkgdb_t type, const char *reponame) 1050 { 1051 c_charv_t r = vec_init(); 1052 int ret; 1053 1054 if (reponame != NULL) 1055 vec_push(&r, reponame); 1056 1057 ret = pkgdb_open_all2(db_p, type, &r); 1058 vec_free(&r); 1059 return (ret); 1060 } 1061 int 1062 pkgdb_open_all2(struct pkgdb **db_p, pkgdb_t type, c_charv_t *reponames) 1063 { 1064 struct pkgdb *db = NULL; 1065 bool reopen = false; 1066 bool profile = false; 1067 bool create = false; 1068 int ret; 1069 int dbdirfd; 1070 1071 if (*db_p != NULL) { 1072 reopen = true; 1073 db = *db_p; 1074 } 1075 1076 if (!reopen) 1077 db = xcalloc(1, sizeof(struct pkgdb)); 1078 db->prstmt_initialized = false; 1079 1080 if (!reopen) { 1081 retry: 1082 dbdirfd = pkg_get_dbdirfd(); 1083 if (dbdirfd == -1) { 1084 if (errno == ENOENT) { 1085 if (pkg_mkdirs(ctx.dbdir) != EPKG_OK) { 1086 pkgdb_close(db); 1087 return (EPKG_FATAL); 1088 } 1089 goto retry; 1090 } 1091 } 1092 if (faccessat(dbdirfd, "local.sqlite", R_OK, AT_EACCESS) != 0) { 1093 if (errno != ENOENT) { 1094 pkg_emit_nolocaldb(); 1095 pkgdb_close(db); 1096 return (EPKG_ENODB); 1097 } else if ((faccessat(dbdirfd, ".", W_OK, AT_EACCESS) != 0)) { 1098 /* 1099 * If we need to create the db but cannot 1100 * write to it, fail early 1101 */ 1102 pkg_emit_nolocaldb(); 1103 pkgdb_close(db); 1104 return (EPKG_ENODB); 1105 } else { 1106 create = true; 1107 } 1108 } 1109 1110 sqlite3_initialize(); 1111 1112 pkgdb_syscall_overload(); 1113 1114 /* 1115 * When we don't have write access, open with immutable=1 1116 * to handle databases that are in WAL journal mode. WAL 1117 * requires -shm/-wal sidecar files which cannot be created 1118 * without write access, causing all queries to fail. 1119 * Immutable mode bypasses WAL/SHM entirely and reads 1120 * directly from the main database file. 1121 */ 1122 if (!create && (type == PKGDB_DEFAULT_READONLY || 1123 faccessat(dbdirfd, "local.sqlite", 1124 W_OK, AT_EACCESS) != 0)) { 1125 ret = sqlite3_open_v2( 1126 "file:/local.sqlite?immutable=1", 1127 &db->sqlite, 1128 SQLITE_OPEN_READONLY | SQLITE_OPEN_URI, 1129 NULL); 1130 } else { 1131 ret = sqlite3_open("/local.sqlite", &db->sqlite); 1132 } 1133 if (ret != SQLITE_OK) { 1134 ERROR_SQLITE(db->sqlite, "sqlite open"); 1135 pkgdb_nfs_corruption(db->sqlite); 1136 pkgdb_close(db); 1137 return (EPKG_FATAL); 1138 } 1139 1140 /* Wait up to 5 seconds if database is busy */ 1141 sqlite3_busy_timeout(db->sqlite, 5000); 1142 1143 /* If the database is missing we have to initialize it */ 1144 if (create && pkgdb_init(db->sqlite) != EPKG_OK) { 1145 pkgdb_close(db); 1146 return (EPKG_FATAL); 1147 } 1148 1149 if (pkgdb_is_local_fs(dbdirfd) && 1150 !sqlite3_db_readonly(db->sqlite, "main")) { 1151 sql_exec(db->sqlite, "PRAGMA journal_mode = WAL;"); 1152 } 1153 1154 /* Create our functions */ 1155 pkgdb_sqlcmd_init(db->sqlite, NULL, NULL); 1156 1157 if (!sqlite3_db_readonly(db->sqlite, "main")) { 1158 if (pkgdb_upgrade(db) != EPKG_OK) { 1159 pkgdb_close(db); 1160 return (EPKG_FATAL); 1161 } 1162 } 1163 1164 /* 1165 * allow foreign key option which will allow to have 1166 * clean support for reinstalling 1167 */ 1168 ret = sql_exec(db->sqlite, "PRAGMA foreign_keys = ON;"); 1169 if (ret != EPKG_OK) { 1170 pkgdb_close(db); 1171 return (EPKG_FATAL); 1172 } 1173 sql_exec(db->sqlite, "PRAGMA mmap_size=268435456;"); 1174 } 1175 1176 if (type == PKGDB_REMOTE || type == PKGDB_MAYBE_REMOTE) { 1177 if (pkg_repos_activated_count() > 0) { 1178 if (reponames == NULL || reponames->len == 0) { 1179 ret = pkgdb_open_repos(db, NULL); 1180 } else { 1181 for (size_t i = 0; i < reponames->len; i++) 1182 ret = pkgdb_open_repos(db, reponames->d[i]); 1183 } 1184 if (ret != EPKG_OK) { 1185 pkgdb_close(db); 1186 return (ret); 1187 } 1188 } else if (type == PKGDB_REMOTE) { 1189 if (*db_p == NULL) 1190 pkgdb_close(db); 1191 pkg_emit_error("No active remote repositories configured"); 1192 return (EPKG_FATAL); 1193 } 1194 } 1195 1196 if (prstmt_initialize(db) != EPKG_OK) { 1197 pkgdb_close(db); 1198 return (EPKG_FATAL); 1199 } 1200 1201 1202 profile = pkg_object_bool(pkg_config_get("SQLITE_PROFILE")); 1203 if (profile) { 1204 dbg(1, "pkgdb profiling is enabled"); 1205 sqlite3_trace_v2(db->sqlite, SQLITE_TRACE_PROFILE, 1206 pkgdb_profile_callback, NULL); 1207 } 1208 1209 *db_p = db; 1210 return (EPKG_OK); 1211 } 1212 1213 static void 1214 pkgdb_free_repo(struct pkg_repo *repo) 1215 { 1216 repo->ops->close(repo, false); 1217 } 1218 1219 void 1220 pkgdb_close(struct pkgdb *db) 1221 { 1222 if (db == NULL) 1223 return; 1224 1225 if (db->prstmt_initialized) 1226 prstmt_finalize(db); 1227 1228 if (db->sqlite != NULL) { 1229 1230 vec_free_and_free(&db->repos, pkgdb_free_repo); 1231 1232 if (!sqlite3_db_readonly(db->sqlite, "main")) { 1233 pkg_plugins_hook_run(PKG_PLUGIN_HOOK_PKGDB_CLOSE_RW, NULL, db); 1234 /* 1235 * Force a full WAL checkpoint so that all data is 1236 * written back into the main database file. This 1237 * ensures that read-only users opening with 1238 * immutable=1 (which bypasses the WAL) see the 1239 * complete and up-to-date database. 1240 */ 1241 sqlite3_wal_checkpoint_v2(db->sqlite, NULL, 1242 SQLITE_CHECKPOINT_TRUNCATE, NULL, NULL); 1243 } 1244 1245 if (sqlite3_close(db->sqlite) != SQLITE_OK) 1246 pkg_emit_error("Package database is busy while closing!"); 1247 } 1248 1249 free(db); 1250 } 1251 1252 /* How many times to try COMMIT or ROLLBACK if the DB is busy */ 1253 #define BUSY_RETRIES 6 1254 #define BUSY_SLEEP 200 1255 1256 /* This is a MACRO instead of a function as any sqlite3_* function that 1257 * queries the DB can return SQLITE_BUSY. We would need a function to 1258 * wrap all sqlite3_* API since we cannot pass anonymous functions/blocks 1259 * in C. This can be used to wrap existing code. */ 1260 #define PKGDB_SQLITE_RETRY_ON_BUSY(ret) \ 1261 ret = SQLITE_BUSY; \ 1262 for (int _sqlite_busy_retries = 0; \ 1263 _sqlite_busy_retries < BUSY_RETRIES && ret == SQLITE_BUSY; \ 1264 ++_sqlite_busy_retries, ret == SQLITE_BUSY && \ 1265 sqlite3_sleep(BUSY_SLEEP)) 1266 1267 static int 1268 run_transaction(sqlite3 *sqlite, const char *query, const char *savepoint) 1269 { 1270 int ret = SQLITE_OK; 1271 sqlite3_stmt *stmt; 1272 char *sql = NULL; 1273 1274 assert(sqlite != NULL); 1275 1276 xasprintf(&sql, "%s %s", query, savepoint != NULL ? savepoint : ""); 1277 stmt = prepare_sql(sqlite, sql); 1278 if (stmt == NULL) 1279 return (EPKG_FATAL); 1280 pkgdb_debug(4, stmt); 1281 1282 PKGDB_SQLITE_RETRY_ON_BUSY(ret) 1283 ret = sqlite3_step(stmt); 1284 1285 if (ret != SQLITE_OK && ret != SQLITE_DONE) { 1286 ERROR_STMT_SQLITE(sqlite, stmt); 1287 } 1288 sqlite3_finalize(stmt); 1289 free(sql); 1290 return (ret == SQLITE_OK || ret == SQLITE_DONE ? EPKG_OK : EPKG_FATAL); 1291 } 1292 1293 int 1294 pkgdb_transaction_begin_sqlite(sqlite3 *sqlite, const char *savepoint) 1295 { 1296 1297 if (savepoint == NULL || savepoint[0] == '\0') { 1298 return (run_transaction(sqlite, "BEGIN IMMEDIATE TRANSACTION", 1299 NULL)); 1300 } 1301 return (run_transaction(sqlite, "SAVEPOINT", savepoint)); 1302 } 1303 1304 int 1305 pkgdb_transaction_commit_sqlite(sqlite3 *sqlite, const char *savepoint) 1306 { 1307 1308 if (savepoint == NULL || savepoint[0] == '\0') { 1309 return (run_transaction(sqlite, "COMMIT TRANSACTION", NULL)); 1310 } 1311 return (run_transaction(sqlite, "RELEASE SAVEPOINT", savepoint)); 1312 } 1313 1314 int 1315 pkgdb_transaction_rollback_sqlite(sqlite3 *sqlite, const char *savepoint) 1316 { 1317 1318 if (savepoint == NULL || savepoint[0] == '\0') { 1319 return (run_transaction(sqlite, "ROLLBACK TRANSACTION", NULL)); 1320 } 1321 return (run_transaction(sqlite, "ROLLBACK TO SAVEPOINT", savepoint)); 1322 } 1323 1324 /* 1325 * Public API 1326 */ 1327 int 1328 pkgdb_transaction_begin(struct pkgdb *db, const char *savepoint) 1329 { 1330 dbg(2, "new transaction"); 1331 return (pkgdb_transaction_begin_sqlite(db->sqlite, savepoint)); 1332 } 1333 int 1334 pkgdb_transaction_commit(struct pkgdb *db, const char *savepoint) 1335 { 1336 dbg(2, "end transaction"); 1337 return (pkgdb_transaction_commit_sqlite(db->sqlite, savepoint)); 1338 } 1339 int 1340 pkgdb_transaction_rollback(struct pkgdb *db, const char *savepoint) 1341 { 1342 dbg(2, "end transaction"); 1343 return (pkgdb_transaction_rollback_sqlite(db->sqlite, savepoint)); 1344 } 1345 1346 1347 /* By default, MATCH_EXACT and MATCH_REGEX are case sensitive. This 1348 * is modified in many actions according to the value of 1349 * CASE_SENSITIVE_MATCH in pkg.conf and then possbily reset again in 1350 * pkg search et al according to command line flags */ 1351 1352 void 1353 pkgdb_set_case_sensitivity(bool case_sensitive) 1354 { 1355 ctx.case_sensitive = case_sensitive; 1356 } 1357 1358 bool 1359 pkgdb_case_sensitive(void) 1360 { 1361 return (ctx.case_sensitive); 1362 } 1363 1364 typedef enum _sql_prstmt_index { 1365 MTREE = 0, 1366 PKG, 1367 DEPS_UPDATE, 1368 DEPS, 1369 FILES, 1370 FILES_REPLACE, 1371 DIRS1, 1372 DIRS2, 1373 CATEGORY1, 1374 CATEGORY2, 1375 LICENSES1, 1376 LICENSES2, 1377 USERS1, 1378 USERS2, 1379 GROUPS1, 1380 GROUPS2, 1381 SCRIPT1, 1382 SCRIPT2, 1383 OPTION1, 1384 OPTION2, 1385 SHLIBS1, 1386 SHLIBS_REQD, 1387 SHLIBS_REQD_IGNORE, 1388 SHLIBS_PROV, 1389 SHLIBS_PROV_IGNORE, 1390 ANNOTATE1, 1391 ANNOTATE2, 1392 ANNOTATE_ADD1, 1393 ANNOTATE_MOD1, 1394 ANNOTATE_DEL1, 1395 ANNOTATE_DEL2, 1396 CONFLICT, 1397 PKG_PROVIDE, 1398 PROVIDE, 1399 UPDATE_DIGEST, 1400 CONFIG_FILES, 1401 UPDATE_CONFIG_FILE, 1402 PKG_REQUIRE, 1403 REQUIRE, 1404 LUASCRIPT1, 1405 LUASCRIPT2, 1406 PRSTMT_LAST, 1407 } sql_prstmt_index; 1408 1409 static sql_prstmt sql_prepared_statements[PRSTMT_LAST] = { 1410 [MTREE] = { 1411 NULL, 1412 NULL, 1413 }, 1414 [PKG] = { 1415 NULL, 1416 "INSERT OR REPLACE INTO packages( " 1417 "origin, name, version, comment, desc, message, arch, " 1418 "maintainer, www, prefix, flatsize, automatic, " 1419 "licenselogic, time, manifestdigest, dep_formula, vital)" 1420 "VALUES( ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, " 1421 "?13, NOW(), ?14, ?15, ?16 )", 1422 }, 1423 [DEPS_UPDATE] = { 1424 NULL, 1425 "UPDATE deps SET origin=?1, version=?2 WHERE name=?3;", 1426 }, 1427 [DEPS] = { 1428 NULL, 1429 "INSERT INTO deps (origin, name, version, package_id) " 1430 "VALUES (?1, ?2, ?3, ?4)", 1431 }, 1432 [FILES] = { 1433 NULL, 1434 "INSERT INTO files (path, sha256, uname, gname, " 1435 "perm, fflags, symlink_target, mtime, package_id) " 1436 "VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", 1437 }, 1438 [FILES_REPLACE] = { 1439 NULL, 1440 "INSERT OR REPLACE INTO files (path, sha256, uname, gname, " 1441 "perm, fflags, symlink_target, mtime, package_id) " 1442 "VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", 1443 }, 1444 [DIRS1] = { 1445 NULL, 1446 "INSERT OR IGNORE INTO directories(path, uname, gname, perm, fflags) " 1447 "VALUES(?1,?2,?3,?4,?5)", 1448 }, 1449 [DIRS2] = { 1450 NULL, 1451 "INSERT INTO pkg_directories(package_id, directory_id, try) " 1452 "VALUES (?1, " 1453 "(SELECT id FROM directories WHERE path = ?2), ?3)", 1454 }, 1455 [CATEGORY1] = { 1456 NULL, 1457 "INSERT OR IGNORE INTO categories(name) VALUES(?1)", 1458 }, 1459 [CATEGORY2] = { 1460 NULL, 1461 "INSERT INTO pkg_categories(package_id, category_id) " 1462 "VALUES (?1, (SELECT id FROM categories WHERE name = ?2))", 1463 }, 1464 [LICENSES1] = { 1465 NULL, 1466 "INSERT OR IGNORE INTO licenses(name) VALUES(?1)", 1467 }, 1468 [LICENSES2] = { 1469 NULL, 1470 "INSERT INTO pkg_licenses(package_id, license_id) " 1471 "VALUES (?1, (SELECT id FROM licenses WHERE name = ?2))", 1472 }, 1473 [USERS1] = { 1474 NULL, 1475 "INSERT OR IGNORE INTO users(name) VALUES(?1)", 1476 }, 1477 [USERS2] = { 1478 NULL, 1479 "INSERT INTO pkg_users(package_id, user_id) " 1480 "VALUES (?1, (SELECT id FROM users WHERE name = ?2))", 1481 }, 1482 [GROUPS1] = { 1483 NULL, 1484 "INSERT OR IGNORE INTO groups(name) VALUES(?1)", 1485 }, 1486 [GROUPS2] = { 1487 NULL, 1488 "INSERT INTO pkg_groups(package_id, group_id) " 1489 "VALUES (?1, (SELECT id FROM groups WHERE name = ?2))", 1490 }, 1491 [SCRIPT1] = { 1492 NULL, 1493 "INSERT OR IGNORE INTO script(script) VALUES (?1)", 1494 }, 1495 [SCRIPT2] = { 1496 NULL, 1497 "INSERT INTO pkg_script(script_id, package_id, type) " 1498 "VALUES ((SELECT script_id FROM script WHERE script = ?1), " 1499 "?2, ?3)", 1500 }, 1501 [OPTION1] = { 1502 NULL, 1503 "INSERT OR IGNORE INTO option (option) " 1504 "VALUES (?1)", 1505 }, 1506 [OPTION2] = { 1507 NULL, 1508 "INSERT INTO pkg_option(package_id, option_id, value) " 1509 "VALUES (?1, " 1510 "(SELECT option_id FROM option WHERE option = ?2)," 1511 "?3)", 1512 }, 1513 [SHLIBS1] = { 1514 NULL, 1515 "INSERT OR IGNORE INTO shlibs(name) VALUES(?1)", 1516 }, 1517 [SHLIBS_REQD] = { 1518 NULL, 1519 "INSERT OR IGNORE INTO pkg_shlibs_required(package_id, shlib_id) " 1520 "VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))", 1521 }, 1522 [SHLIBS_REQD_IGNORE] = { 1523 NULL, 1524 "INSERT OR IGNORE INTO pkg_shlibs_required_ignore(package_id, shlib_id) " 1525 "VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))", 1526 }, 1527 [SHLIBS_PROV] = { 1528 NULL, 1529 "INSERT OR IGNORE INTO pkg_shlibs_provided(package_id, shlib_id) " 1530 "VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))", 1531 }, 1532 [SHLIBS_PROV_IGNORE] = { 1533 NULL, 1534 "INSERT OR IGNORE INTO pkg_shlibs_provided_ignore(package_id, shlib_id) " 1535 "VALUES (?1, (SELECT id FROM shlibs WHERE name = ?2))", 1536 }, 1537 [ANNOTATE1] = { 1538 NULL, 1539 "INSERT OR IGNORE INTO annotation(annotation) " 1540 "VALUES (?1)", 1541 }, 1542 [ANNOTATE2] = { 1543 NULL, 1544 "INSERT OR ROLLBACK INTO pkg_annotation(package_id, tag_id, value_id) " 1545 "VALUES (?1," 1546 " (SELECT annotation_id FROM annotation WHERE annotation = ?2)," 1547 " (SELECT annotation_id FROM annotation WHERE annotation = ?3))", 1548 }, 1549 [ANNOTATE_ADD1] = { 1550 NULL, 1551 "INSERT OR IGNORE INTO pkg_annotation(package_id, tag_id, value_id) " 1552 "VALUES (" 1553 " (SELECT id FROM packages WHERE name = ?1 )," 1554 " (SELECT annotation_id FROM annotation WHERE annotation = ?2)," 1555 " (SELECT annotation_id FROM annotation WHERE annotation = ?3))", 1556 }, 1557 [ANNOTATE_MOD1] = { 1558 NULL, 1559 "INSERT OR REPLACE INTO pkg_annotation(package_id, tag_id, value_id) " 1560 "VALUES (" 1561 " (SELECT id FROM packages WHERE name = ?1 )," 1562 " (SELECT annotation_id FROM annotation WHERE annotation = ?2)," 1563 " (SELECT annotation_id FROM annotation WHERE annotation = ?3))", 1564 }, 1565 [ANNOTATE_DEL1] = { 1566 NULL, 1567 "DELETE FROM pkg_annotation WHERE " 1568 "package_id IN" 1569 " (SELECT id FROM packages WHERE name = ?1) " 1570 "AND tag_id IN" 1571 " (SELECT annotation_id FROM annotation WHERE annotation = ?2)", 1572 }, 1573 [ANNOTATE_DEL2] = { 1574 NULL, 1575 "DELETE FROM annotation WHERE" 1576 " annotation_id NOT IN (SELECT tag_id FROM pkg_annotation) AND" 1577 " annotation_id NOT IN (SELECT value_id FROM pkg_annotation)", 1578 }, 1579 [CONFLICT] = { 1580 NULL, 1581 "INSERT INTO pkg_conflicts(package_id, conflict_id) " 1582 "VALUES (?1, (SELECT id FROM packages WHERE name = ?2))", 1583 }, 1584 [PKG_PROVIDE] = { 1585 NULL, 1586 "INSERT INTO pkg_provides(package_id, provide_id) " 1587 "VALUES (?1, (SELECT id FROM provides WHERE provide = ?2))", 1588 }, 1589 [PROVIDE] = { 1590 NULL, 1591 "INSERT OR IGNORE INTO provides(provide) VALUES(?1)", 1592 }, 1593 [UPDATE_DIGEST] = { 1594 NULL, 1595 "UPDATE packages SET manifestdigest=?1 WHERE id=?2;", 1596 }, 1597 [CONFIG_FILES] = { 1598 NULL, 1599 "INSERT INTO config_files(path, content, package_id) " 1600 "VALUES (?1, ?2, ?3);", 1601 }, 1602 [UPDATE_CONFIG_FILE] = { 1603 NULL, 1604 "UPDATE config_files SET content=?1 WHERE path=?2;", 1605 }, 1606 [PKG_REQUIRE] = { 1607 NULL, 1608 "INSERT INTO pkg_requires(package_id, require_id) " 1609 "VALUES (?1, (SELECT id FROM requires WHERE require = ?2))", 1610 }, 1611 [REQUIRE] = { 1612 NULL, 1613 "INSERT OR IGNORE INTO requires(require) VALUES(?1)", 1614 }, 1615 [LUASCRIPT1] = { 1616 NULL, 1617 "INSERT OR IGNORE INTO lua_script(lua_script) VALUES (?1)", 1618 }, 1619 [LUASCRIPT2] = { 1620 NULL, 1621 "INSERT INTO pkg_lua_script(lua_script_id, package_id, type) " 1622 "VALUES ((SELECT lua_script_id FROM lua_script WHERE " 1623 "lua_script = ?1), ?2, ?3)", 1624 }, 1625 /* PRSTMT_LAST */ 1626 }; 1627 1628 static int 1629 prstmt_initialize(struct pkgdb *db) 1630 { 1631 sql_prstmt_index i; 1632 sqlite3 *sqlite; 1633 1634 assert(db != NULL); 1635 1636 if (!db->prstmt_initialized) { 1637 sqlite = db->sqlite; 1638 1639 for (i = 0; i < PRSTMT_LAST; i++) { 1640 if (SQL(i) == NULL) 1641 continue; 1642 STMT(i) = prepare_sql(sqlite, SQL(i)); 1643 if (STMT(i) == NULL) 1644 return (EPKG_FATAL); 1645 } 1646 db->prstmt_initialized = true; 1647 } 1648 1649 return (EPKG_OK); 1650 } 1651 1652 static int 1653 run_prstmt(sql_prstmt_index s, const sql_arg_t *args, size_t nargs) 1654 { 1655 int retcode; 1656 sqlite3_stmt *stmt; 1657 size_t i; 1658 1659 stmt = STMT(s); 1660 sqlite3_reset(stmt); 1661 1662 for (i = 0; i < nargs; ++i) { 1663 int bind_index = (int)i + 1; 1664 switch (args[i].type) { 1665 case ARG_TEXT: 1666 sqlite3_bind_text(stmt, bind_index, args[i].v.text, -1, SQLITE_STATIC); 1667 break; 1668 case ARG_INT64: 1669 sqlite3_bind_int64(stmt, bind_index, args[i].v.i64); 1670 break; 1671 default: 1672 pkg_emit_error("unexpected type: %d\n", args[i].type); 1673 return (SQLITE_MISUSE); 1674 } 1675 } 1676 1677 char *debug_sql = sqlite3_expanded_sql(stmt); 1678 dbg(4, "running '%s'", debug_sql); 1679 sqlite3_free(debug_sql); 1680 1681 retcode = sqlite3_step(stmt); 1682 return (retcode); 1683 } 1684 1685 static void 1686 prstmt_finalize(struct pkgdb *db) 1687 { 1688 sql_prstmt_index i; 1689 1690 for (i = 0; i < PRSTMT_LAST; i++) 1691 { 1692 if (STMT(i) != NULL) { 1693 sqlite3_finalize(STMT(i)); 1694 STMT(i) = NULL; 1695 } 1696 } 1697 db->prstmt_initialized = false; 1698 } 1699 1700 static int 1701 run_pkg_prstmt(struct pkg *pkg) 1702 { 1703 const char *arch; 1704 char *msg; 1705 int ret; 1706 1707 /* Prefer new ABI over old one */ 1708 arch = pkg->abi != NULL ? pkg->abi : pkg->altabi; 1709 msg = pkg_message_to_str(pkg); 1710 sql_arg_t arg [] = { 1711 SQL_ARG(pkg->origin), 1712 SQL_ARG(pkg->name), 1713 SQL_ARG(pkg->version), 1714 SQL_ARG(pkg->comment), 1715 SQL_ARG(pkg->desc), 1716 SQL_ARG(msg), 1717 SQL_ARG(arch), 1718 SQL_ARG(pkg->maintainer), 1719 SQL_ARG(pkg->www), 1720 SQL_ARG(pkg->prefix), 1721 SQL_ARG(pkg->flatsize), 1722 SQL_ARG(pkg->automatic), 1723 SQL_ARG(pkg->licenselogic), 1724 SQL_ARG(pkg->digest), 1725 SQL_ARG(pkg->dep_formula), 1726 SQL_ARG(pkg->vital), 1727 }; 1728 ret = run_prstmt(PKG, arg, NELEM(arg)); 1729 free(msg); 1730 return (ret); 1731 } 1732 1733 static const char * 1734 _pkgdb_empty_str_null(const char *str) 1735 { 1736 return (str[0] == '\0' ? NULL : str); 1737 } 1738 1739 /* 1740 * Register a package in the database. If successful, the caller is required to 1741 * call pkgdb_register_finale() in order to either commit or roll back the 1742 * transaction. Otherwise, the caller does not need to do any extra cleanup. 1743 */ 1744 int 1745 pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int forced, 1746 const char *savepoint) 1747 { 1748 struct pkg *pkg2 = NULL; 1749 struct pkg_dep *dep = NULL; 1750 struct pkg_file *file = NULL; 1751 struct pkg_dir *dir = NULL; 1752 struct pkg_option *option = NULL; 1753 struct pkg_conflict *conflict = NULL; 1754 struct pkg_config_file *cf = NULL; 1755 struct pkgdb_it *it = NULL; 1756 sqlite3 *s; 1757 int ret; 1758 int64_t package_id; 1759 1760 if (pkg_is_valid(pkg) != EPKG_OK) { 1761 pkg_emit_error("the package is not valid"); 1762 return (EPKG_FATAL); 1763 } 1764 1765 s = db->sqlite; 1766 1767 if (pkgdb_transaction_begin_sqlite(s, savepoint) != EPKG_OK) 1768 return (EPKG_FATAL); 1769 1770 /* 1771 * Insert package record 1772 */ 1773 ret = run_pkg_prstmt(pkg); 1774 if (ret != SQLITE_DONE) { 1775 ERROR_STMT_SQLITE(s, STMT(PKG)); 1776 goto cleanup; 1777 } 1778 1779 package_id = sqlite3_last_insert_rowid(s); 1780 1781 /* 1782 * Update dep information on packages that depend on the inserted 1783 * package 1784 */ 1785 1786 sql_arg_t dep_arg[] = { 1787 SQL_ARG(pkg->origin), 1788 SQL_ARG(pkg->version), 1789 SQL_ARG(pkg->version ? pkg->version : ""), 1790 SQL_ARG(pkg->name), 1791 }; 1792 if (run_prstmt(DEPS_UPDATE, dep_arg, NELEM(dep_arg)) 1793 != SQLITE_DONE) { 1794 ERROR_STMT_SQLITE(s, STMT(DEPS_UPDATE)); 1795 goto cleanup; 1796 } 1797 1798 /* 1799 * Insert dependencies list 1800 */ 1801 1802 while (pkg_deps(pkg, &dep) == EPKG_OK) { 1803 sql_arg_t arg[] = { 1804 SQL_ARG(dep->origin), 1805 SQL_ARG(dep->name), 1806 SQL_ARG(dep->version ? dep->version : ""), 1807 SQL_ARG(package_id), 1808 }; 1809 if (run_prstmt(DEPS, arg, NELEM(arg)) 1810 != SQLITE_DONE) { 1811 ERROR_STMT_SQLITE(s, STMT(DEPS)); 1812 goto cleanup; 1813 } 1814 } 1815 1816 /* 1817 * Insert files. 1818 */ 1819 1820 while (pkg_files(pkg, &file) == EPKG_OK) { 1821 bool permissive = false; 1822 if (match_ucl_lists(file->path, 1823 pkg_config_get("FILES_IGNORE_GLOB"), 1824 pkg_config_get("FILES_IGNORE_REGEX"))) { 1825 continue; 1826 } 1827 1828 sql_arg_t args[] = { 1829 SQL_ARG(file->path), 1830 SQL_ARG(file->sum), 1831 SQL_ARG(file->uname), 1832 SQL_ARG(file->gname), 1833 SQL_ARG(file->perm), 1834 SQL_ARG(file->fflags), 1835 SQL_ARG(file->symlink_target), 1836 SQL_ARG(file->time[1].tv_sec), 1837 SQL_ARG(package_id), 1838 }; 1839 ret = run_prstmt(FILES, args, NELEM(args)); 1840 if (ret == SQLITE_DONE) 1841 continue; 1842 if (ret != SQLITE_CONSTRAINT) { 1843 pkg_emit_error("error: %d", ret); 1844 ERROR_STMT_SQLITE(s, STMT(FILES)); 1845 goto cleanup; 1846 } 1847 it = pkgdb_query_which(db, file->path, false); 1848 if (it == NULL) { 1849 ERROR_SQLITE(s, "pkg which"); 1850 goto cleanup; 1851 } 1852 pkg2 = NULL; 1853 ret = pkgdb_it_next(it, &pkg2, PKG_LOAD_BASIC); 1854 if (ret == EPKG_END) { 1855 /* Stray entry in the files table not related to 1856 any known package: overwrite this */ 1857 ret = run_prstmt(FILES_REPLACE, args, NELEM(args)); 1858 pkgdb_it_free(it); 1859 if (ret == SQLITE_DONE) 1860 continue; 1861 else { 1862 ERROR_STMT_SQLITE(s, STMT(FILES_REPLACE)); 1863 goto cleanup; 1864 } 1865 } 1866 if (ret != EPKG_OK && ret != EPKG_END) { 1867 pkgdb_it_free(it); 1868 ERROR_STMT_SQLITE(s, STMT(FILES_REPLACE)); 1869 goto cleanup; 1870 } 1871 if (!forced) { 1872 if (!ctx.developer_mode) 1873 permissive = pkg_object_bool(pkg_config_get("PERMISSIVE")); 1874 pkg_emit_error("%s-%s conflicts with %s-%s" 1875 " (installs files into the same place). " 1876 " Problematic file: %s%s", 1877 pkg->name, pkg->version, pkg2->name, pkg2->version, file->path, 1878 permissive ? " ignored by permissive mode" : ""); 1879 pkg_free(pkg2); 1880 if (!permissive) { 1881 pkgdb_it_free(it); 1882 goto cleanup; 1883 } 1884 } else { 1885 pkg_emit_error("%s-%s conflicts with %s-%s" 1886 " (installs files into the same place). " 1887 " Problematic file: %s ignored by forced mode", 1888 pkg->name, pkg->version, pkg2->name, pkg2->version, file->path); 1889 pkg_free(pkg2); 1890 } 1891 pkgdb_it_free(it); 1892 } 1893 1894 /* 1895 * Insert config files 1896 */ 1897 while (pkg_config_files(pkg, &cf) == EPKG_OK) { 1898 sql_arg_t args[] = { 1899 SQL_ARG(cf->path), 1900 SQL_ARG(cf->content), 1901 SQL_ARG(package_id), 1902 }; 1903 if ((ret = run_prstmt(CONFIG_FILES, args, NELEM(args))) 1904 != SQLITE_DONE) { 1905 if (ret == SQLITE_CONSTRAINT) { 1906 pkg_emit_error("Another package already owns :%s", 1907 cf->path); 1908 } else 1909 ERROR_STMT_SQLITE(s, STMT(CONFIG_FILES)); 1910 goto cleanup; 1911 } 1912 } 1913 1914 /* 1915 * Insert dirs. 1916 */ 1917 1918 while (pkg_dirs(pkg, &dir) == EPKG_OK) { 1919 sql_arg_t args[] = { 1920 SQL_ARG(dir->path), 1921 SQL_ARG(dir->uname), 1922 SQL_ARG(dir->gname), 1923 SQL_ARG(dir->perm), 1924 SQL_ARG(dir->fflags), 1925 SQL_ARG(dir->time[1].tv_sec), 1926 }; 1927 if (run_prstmt(DIRS1, args, NELEM(args)) != SQLITE_DONE) { 1928 ERROR_STMT_SQLITE(s, STMT(DIRS1)); 1929 goto cleanup; 1930 } 1931 sql_arg_t args2[] = { 1932 SQL_ARG(package_id), 1933 SQL_ARG(dir->path), 1934 SQL_ARG(true), 1935 }; 1936 if ((ret = run_prstmt(DIRS2, args2, NELEM(args2))) != SQLITE_DONE) { 1937 if (ret == SQLITE_CONSTRAINT) { 1938 pkg_emit_error("Another package is already " 1939 "providing directory: %s", 1940 dir->path); 1941 } else 1942 ERROR_STMT_SQLITE(s, STMT(DIRS2)); 1943 goto cleanup; 1944 } 1945 } 1946 1947 /* 1948 * Insert categories 1949 */ 1950 1951 vec_foreach(pkg->categories, i) { 1952 sql_arg_t arg1 [] = { SQL_ARG(pkg->categories.d[i]) }; 1953 sql_arg_t arg2 [] = { SQL_ARG(package_id), SQL_ARG(pkg->categories.d[i]) }; 1954 ret = run_prstmt(CATEGORY1, arg1, NELEM(arg1)); 1955 if (ret == SQLITE_DONE) 1956 ret = run_prstmt(CATEGORY2, arg2, NELEM(arg2)); 1957 if (ret != SQLITE_DONE) { 1958 ERROR_STMT_SQLITE(s, STMT(CATEGORY2)); 1959 goto cleanup; 1960 } 1961 } 1962 1963 /* 1964 * Insert licenses 1965 */ 1966 1967 vec_foreach(pkg->licenses, i) { 1968 sql_arg_t arg1 [] = { SQL_ARG(pkg->licenses.d[i]) }; 1969 sql_arg_t arg2 [] = { SQL_ARG(package_id), SQL_ARG(pkg->licenses.d[i]) }; 1970 ret = run_prstmt(LICENSES1, arg1, NELEM(arg1)); 1971 if (ret == SQLITE_DONE) 1972 ret = run_prstmt(LICENSES2, arg2, NELEM(arg2)); 1973 if (ret != SQLITE_DONE) { 1974 ERROR_STMT_SQLITE(s, STMT(LICENSES2)); 1975 goto cleanup; 1976 } 1977 } 1978 1979 /* 1980 * Insert users 1981 */ 1982 1983 vec_foreach(pkg->users, i) { 1984 sql_arg_t arg1 [] = { SQL_ARG(pkg->users.d[i]) }; 1985 sql_arg_t arg2 [] = { SQL_ARG(package_id), SQL_ARG(pkg->users.d[i]) }; 1986 ret = run_prstmt(USERS1, arg1, NELEM(arg1)); 1987 if (ret == SQLITE_DONE) 1988 ret = run_prstmt(USERS2, arg2, NELEM(arg2)); 1989 if (ret != SQLITE_DONE) { 1990 ERROR_STMT_SQLITE(s, STMT(USERS2)); 1991 goto cleanup; 1992 } 1993 } 1994 1995 /* 1996 * Insert groups 1997 */ 1998 1999 vec_foreach(pkg->groups, i) { 2000 sql_arg_t arg1 [] = { SQL_ARG(pkg->groups.d[i]) }; 2001 sql_arg_t arg2 [] = { SQL_ARG(package_id), SQL_ARG(pkg->groups.d[i]) }; 2002 ret = run_prstmt(GROUPS1, arg1, NELEM(arg1)); 2003 if (ret == SQLITE_DONE) 2004 ret = run_prstmt(GROUPS2, arg2, NELEM(arg2)); 2005 if (ret != SQLITE_DONE) { 2006 ERROR_STMT_SQLITE(s, STMT(GROUPS2)); 2007 goto cleanup; 2008 } 2009 } 2010 2011 /* 2012 * Insert scripts 2013 */ 2014 2015 if (pkgdb_insert_scripts(pkg, package_id, s) != EPKG_OK) 2016 goto cleanup; 2017 2018 /* 2019 * Insert lua scripts 2020 */ 2021 if (pkgdb_insert_lua_scripts(pkg, package_id, s) != EPKG_OK) 2022 goto cleanup; 2023 2024 /* 2025 * Insert options 2026 */ 2027 2028 while (pkg_options(pkg, &option) == EPKG_OK) { 2029 sql_arg_t arg1 [] = { SQL_ARG(option->key) }; 2030 sql_arg_t arg2 [] = { 2031 SQL_ARG(package_id), 2032 SQL_ARG(option->key), 2033 SQL_ARG(option->value) 2034 }; 2035 ret = run_prstmt(OPTION1, arg1, NELEM(arg1)); 2036 if (ret == SQLITE_DONE) 2037 ret = run_prstmt(OPTION2, arg2, NELEM(arg2)); 2038 if (ret != SQLITE_DONE) { 2039 ERROR_STMT_SQLITE(s, STMT(OPTION2)); 2040 goto cleanup; 2041 } 2042 } 2043 2044 /* 2045 * Insert shlibs 2046 */ 2047 if (pkgdb_update_shlibs_required(pkg, package_id, s) != EPKG_OK) 2048 goto cleanup; 2049 if (pkgdb_update_shlibs_required_ignore(pkg, package_id, s) != EPKG_OK) 2050 goto cleanup; 2051 if (pkgdb_update_shlibs_provided(pkg, package_id, s) != EPKG_OK) 2052 goto cleanup; 2053 if (pkgdb_update_shlibs_provided_ignore(pkg, package_id, s) != EPKG_OK) 2054 goto cleanup; 2055 2056 /* 2057 * Insert annotation 2058 */ 2059 if (pkgdb_insert_annotations(pkg, package_id, s) != EPKG_OK) 2060 goto cleanup; 2061 2062 /* 2063 * Insert conflicts 2064 */ 2065 while (pkg_conflicts(pkg, &conflict) == EPKG_OK) { 2066 sql_arg_t args[] = { SQL_ARG(package_id), SQL_ARG(conflict->uid) }; 2067 if (run_prstmt(CONFLICT, args, NELEM(args)) 2068 != SQLITE_DONE) { 2069 ERROR_STMT_SQLITE(s, STMT(CONFLICT)); 2070 goto cleanup; 2071 } 2072 } 2073 2074 /* 2075 * Insert provides 2076 */ 2077 if (pkgdb_update_provides(pkg, package_id, s) != EPKG_OK) 2078 goto cleanup; 2079 if (pkgdb_update_requires(pkg, package_id, s) != EPKG_OK) 2080 goto cleanup; 2081 2082 return (EPKG_OK); 2083 2084 cleanup: 2085 (void)pkgdb_transaction_rollback_sqlite(s, savepoint); 2086 2087 return (EPKG_FATAL); 2088 } 2089 2090 static int 2091 pkgdb_insert_scripts(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2092 { 2093 const char *script; 2094 int64_t i; 2095 2096 for (i = 0; i < PKG_NUM_SCRIPTS; i++) { 2097 script = pkg_script_get(pkg, i); 2098 2099 if (script == NULL) 2100 continue; 2101 sql_arg_t arg1[] = { SQL_ARG(script) }; 2102 sql_arg_t arg2[] = { 2103 SQL_ARG(script), 2104 SQL_ARG(package_id), 2105 SQL_ARG(i) 2106 }; 2107 if (run_prstmt(SCRIPT1, arg1, NELEM(arg1)) != SQLITE_DONE 2108 || 2109 run_prstmt(SCRIPT2, arg2, NELEM(arg2)) != SQLITE_DONE) { 2110 ERROR_STMT_SQLITE(s, STMT(SCRIPT2)); 2111 return (EPKG_FATAL); 2112 } 2113 } 2114 2115 return (EPKG_OK); 2116 } 2117 2118 static int 2119 pkgdb_insert_lua_scripts(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2120 { 2121 int64_t i; 2122 2123 for (i = 0; i < PKG_NUM_LUA_SCRIPTS; i++) { 2124 vec_foreach(pkg->lua_scripts[i], j) { 2125 sql_arg_t arg1[] = { SQL_ARG(pkg->lua_scripts[i].d[j]) }; 2126 sql_arg_t arg2[] = { 2127 SQL_ARG(pkg->lua_scripts[i].d[j]), 2128 SQL_ARG(package_id), 2129 SQL_ARG(i), 2130 }; 2131 if (run_prstmt(LUASCRIPT1, arg1, NELEM(arg1)) != SQLITE_DONE 2132 || 2133 run_prstmt(LUASCRIPT2, arg2, NELEM(arg2)) != SQLITE_DONE) { 2134 ERROR_STMT_SQLITE(s, STMT(LUASCRIPT2)); 2135 return (EPKG_FATAL); 2136 } 2137 } 2138 } 2139 return (EPKG_OK); 2140 } 2141 2142 int 2143 pkgdb_update_shlibs_required(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2144 { 2145 vec_foreach(pkg->shlibs_required, i) { 2146 sql_arg_t arg1[] = { SQL_ARG(pkg->shlibs_required.d[i]) }; 2147 sql_arg_t arg2[] = { 2148 SQL_ARG(package_id), 2149 SQL_ARG(pkg->shlibs_required.d[i]) 2150 }; 2151 if (run_prstmt(SHLIBS1, arg1, NELEM(arg1)) 2152 != SQLITE_DONE 2153 || 2154 run_prstmt(SHLIBS_REQD, arg2, NELEM(arg2)) 2155 != SQLITE_DONE) { 2156 ERROR_STMT_SQLITE(s, STMT(SHLIBS_REQD)); 2157 return (EPKG_FATAL); 2158 } 2159 } 2160 2161 return (EPKG_OK); 2162 } 2163 2164 int 2165 pkgdb_update_shlibs_required_ignore(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2166 { 2167 vec_foreach(pkg->shlibs_required_ignore, i) { 2168 sql_arg_t arg1[] = { SQL_ARG(pkg->shlibs_required_ignore.d[i]) }; 2169 sql_arg_t arg2[] = { 2170 SQL_ARG(package_id), 2171 SQL_ARG(pkg->shlibs_required_ignore.d[i]) 2172 }; 2173 if (run_prstmt(SHLIBS1, arg1, NELEM(arg1)) 2174 != SQLITE_DONE 2175 || 2176 run_prstmt(SHLIBS_REQD_IGNORE, arg2, NELEM(arg2)) 2177 != SQLITE_DONE) { 2178 ERROR_STMT_SQLITE(s, STMT(SHLIBS_REQD_IGNORE)); 2179 return (EPKG_FATAL); 2180 } 2181 } 2182 2183 return (EPKG_OK); 2184 } 2185 2186 int 2187 pkgdb_update_config_file_content(struct pkg *p, sqlite3 *s) 2188 { 2189 struct pkg_config_file *cf = NULL; 2190 2191 while (pkg_config_files(p, &cf) == EPKG_OK) { 2192 sql_arg_t arg[] = { 2193 SQL_ARG(cf->content), 2194 SQL_ARG(cf->path), 2195 }; 2196 if (run_prstmt(UPDATE_CONFIG_FILE, arg, NELEM(arg)) 2197 != SQLITE_DONE) { 2198 ERROR_STMT_SQLITE(s, STMT(SHLIBS_REQD)); 2199 return (EPKG_FATAL); 2200 } 2201 } 2202 2203 return (EPKG_OK); 2204 } 2205 2206 int 2207 pkgdb_update_shlibs_provided(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2208 { 2209 vec_foreach(pkg->shlibs_provided, i) { 2210 sql_arg_t arg1[] = { SQL_ARG(pkg->shlibs_provided.d[i]) }; 2211 sql_arg_t arg2[] = { 2212 SQL_ARG(package_id), 2213 SQL_ARG(pkg->shlibs_provided.d[i]), 2214 }; 2215 if (run_prstmt(SHLIBS1, arg1, NELEM(arg1)) 2216 != SQLITE_DONE 2217 || 2218 run_prstmt(SHLIBS_PROV, arg2, NELEM(arg2)) 2219 != SQLITE_DONE) { 2220 ERROR_STMT_SQLITE(s, STMT(SHLIBS_PROV)); 2221 return (EPKG_FATAL); 2222 } 2223 } 2224 2225 return (EPKG_OK); 2226 } 2227 2228 int 2229 pkgdb_update_shlibs_provided_ignore(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2230 { 2231 vec_foreach(pkg->shlibs_provided_ignore, i) { 2232 sql_arg_t arg1[] = { SQL_ARG(pkg->shlibs_provided_ignore.d[i]) }; 2233 sql_arg_t arg2[] = { 2234 SQL_ARG(package_id), 2235 SQL_ARG(pkg->shlibs_provided_ignore.d[i]), 2236 }; 2237 if (run_prstmt(SHLIBS1, arg1, NELEM(arg1)) 2238 != SQLITE_DONE 2239 || 2240 run_prstmt(SHLIBS_PROV_IGNORE, arg2, NELEM(arg2)) 2241 != SQLITE_DONE) { 2242 ERROR_STMT_SQLITE(s, STMT(SHLIBS_PROV_IGNORE)); 2243 return (EPKG_FATAL); 2244 } 2245 } 2246 2247 return (EPKG_OK); 2248 } 2249 2250 int 2251 pkgdb_update_requires(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2252 { 2253 vec_foreach(pkg->requires, i) { 2254 sql_arg_t arg1[] = { SQL_ARG(pkg->requires.d[i]) }; 2255 sql_arg_t arg2[] = { 2256 SQL_ARG(package_id), 2257 SQL_ARG(pkg->requires.d[i]), 2258 }; 2259 if (run_prstmt(REQUIRE, arg1, NELEM(arg1)) 2260 != SQLITE_DONE 2261 || 2262 run_prstmt(PKG_REQUIRE, arg2, NELEM(arg2)) 2263 != SQLITE_DONE) { 2264 ERROR_STMT_SQLITE(s, STMT(PKG_REQUIRE)); 2265 return (EPKG_FATAL); 2266 } 2267 } 2268 2269 return (EPKG_OK); 2270 } 2271 2272 int 2273 pkgdb_update_provides(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2274 { 2275 vec_foreach(pkg->provides, i) { 2276 sql_arg_t arg1[] = { SQL_ARG(pkg->provides.d[i]) }; 2277 sql_arg_t arg2[] = { 2278 SQL_ARG(package_id), 2279 SQL_ARG(pkg->provides.d[i]), 2280 }; 2281 if (run_prstmt(PROVIDE, arg1, NELEM(arg1)) 2282 != SQLITE_DONE 2283 || 2284 run_prstmt(PKG_PROVIDE, arg2, NELEM(arg2)) 2285 != SQLITE_DONE) { 2286 ERROR_STMT_SQLITE(s, STMT(PKG_PROVIDE)); 2287 return (EPKG_FATAL); 2288 } 2289 } 2290 2291 return (EPKG_OK); 2292 } 2293 2294 int 2295 pkgdb_insert_annotations(struct pkg *pkg, int64_t package_id, sqlite3 *s) 2296 { 2297 struct pkg_kv *kv; 2298 2299 vec_foreach(pkg->annotations, i) { 2300 kv = pkg->annotations.d[i]; 2301 sql_arg_t arg1[] = { SQL_ARG(kv->key) }; 2302 sql_arg_t arg2[] = { SQL_ARG(kv->value) }; 2303 sql_arg_t arg3[] = { 2304 SQL_ARG(package_id), 2305 SQL_ARG(kv->key), 2306 SQL_ARG(kv->value), 2307 }; 2308 if (run_prstmt(ANNOTATE1, arg1, NELEM(arg1)) 2309 != SQLITE_DONE 2310 || 2311 run_prstmt(ANNOTATE1, arg2, NELEM(arg2)) 2312 != SQLITE_DONE 2313 || 2314 run_prstmt(ANNOTATE2, arg3, NELEM(arg3)) 2315 != SQLITE_DONE) { 2316 ERROR_STMT_SQLITE(s, STMT(ANNOTATE2)); 2317 return (EPKG_FATAL); 2318 } 2319 } 2320 return (EPKG_OK); 2321 } 2322 2323 int 2324 pkgdb_add_annotation(struct pkgdb *db, struct pkg *pkg, const char *tag, 2325 const char *value) 2326 { 2327 int rows_changed; 2328 2329 assert(pkg != NULL); 2330 assert(tag != NULL); 2331 assert(value != NULL); 2332 2333 sql_arg_t arg1[] = { SQL_ARG(tag) }; 2334 sql_arg_t arg2[] = { SQL_ARG(value) }; 2335 sql_arg_t arg3[] = { 2336 SQL_ARG(pkg->uid), 2337 SQL_ARG(tag), 2338 SQL_ARG(value), 2339 }; 2340 2341 if (run_prstmt(ANNOTATE1, arg1, NELEM(arg1)) != SQLITE_DONE 2342 || 2343 run_prstmt(ANNOTATE1, arg2, NELEM(arg1)) != SQLITE_DONE 2344 || 2345 run_prstmt(ANNOTATE_ADD1, arg3, NELEM(arg3)) 2346 != SQLITE_DONE) { 2347 ERROR_STMT_SQLITE(db->sqlite, STMT(ANNOTATE_ADD1)); 2348 pkgdb_transaction_rollback_sqlite(db->sqlite, NULL); 2349 return (EPKG_FATAL); 2350 } 2351 2352 /* Expect rows_changed == 1 unless there's already an 2353 annotation using the given tag */ 2354 2355 rows_changed = sqlite3_changes(db->sqlite); 2356 2357 return (rows_changed == 1 ? EPKG_OK : EPKG_WARN); 2358 } 2359 2360 int 2361 pkgdb_set_pkg_digest(struct pkgdb *db, struct pkg *pkg) 2362 { 2363 2364 assert(pkg != NULL); 2365 assert(db != NULL); 2366 2367 sql_arg_t arg[] = { 2368 SQL_ARG(pkg->digest), 2369 SQL_ARG(pkg->id), 2370 }; 2371 if (run_prstmt(UPDATE_DIGEST, arg, NELEM(arg)) != SQLITE_DONE) { 2372 ERROR_STMT_SQLITE(db->sqlite, STMT(UPDATE_DIGEST)); 2373 return (EPKG_FATAL); 2374 } 2375 2376 return (EPKG_OK); 2377 } 2378 2379 int 2380 pkgdb_modify_annotation(struct pkgdb *db, struct pkg *pkg, const char *tag, 2381 const char *value) 2382 { 2383 int rows_changed; 2384 2385 assert(pkg!= NULL); 2386 assert(tag != NULL); 2387 assert(value != NULL); 2388 2389 sql_arg_t arg1[] = { SQL_ARG(tag) }; 2390 sql_arg_t arg2[] = { SQL_ARG(value) }; 2391 sql_arg_t arg3[] = { 2392 SQL_ARG(pkg->uid), 2393 SQL_ARG(tag), 2394 SQL_ARG(value), 2395 }; 2396 2397 if (pkgdb_transaction_begin_sqlite(db->sqlite, NULL) != EPKG_OK) 2398 return (EPKG_FATAL); 2399 2400 if (run_prstmt(ANNOTATE1, arg1, NELEM(arg1)) != SQLITE_DONE 2401 || 2402 run_prstmt(ANNOTATE1, arg2, NELEM(arg2)) != SQLITE_DONE 2403 || 2404 run_prstmt(ANNOTATE_MOD1, arg3, NELEM(arg3)) != 2405 SQLITE_DONE) { 2406 ERROR_STMT_SQLITE(db->sqlite, STMT(ANNOTATE_MOD1)); 2407 pkgdb_transaction_rollback_sqlite(db->sqlite, NULL); 2408 2409 return (EPKG_FATAL); 2410 } 2411 rows_changed = sqlite3_changes(db->sqlite); 2412 2413 if (run_prstmt(ANNOTATE_DEL2, NULL, 0) != SQLITE_DONE) { 2414 ERROR_STMT_SQLITE(db->sqlite, STMT(ANNOTATE_DEL2)); 2415 pkgdb_transaction_rollback_sqlite(db->sqlite, NULL); 2416 2417 return (EPKG_FATAL); 2418 } 2419 2420 if (pkgdb_transaction_commit_sqlite(db->sqlite, NULL) != EPKG_OK) 2421 return (EPKG_FATAL); 2422 2423 /* Something has gone very wrong if rows_changed != 1 here */ 2424 return (rows_changed == 1 ? EPKG_OK : EPKG_WARN); 2425 } 2426 2427 int 2428 pkgdb_delete_annotation(struct pkgdb *db, struct pkg *pkg, const char *tag) 2429 { 2430 int rows_changed; 2431 bool result; 2432 2433 assert(pkg != NULL); 2434 assert(tag != NULL); 2435 2436 if (pkgdb_transaction_begin_sqlite(db->sqlite, NULL) != EPKG_OK) 2437 return (EPKG_FATAL); 2438 2439 sql_arg_t arg[] = { SQL_ARG(pkg->uid), SQL_ARG(tag) }; 2440 result = (run_prstmt(ANNOTATE_DEL1, arg, NELEM(arg)) 2441 == SQLITE_DONE); 2442 2443 rows_changed = sqlite3_changes(db->sqlite); 2444 2445 if (!result 2446 || 2447 run_prstmt(ANNOTATE_DEL2, NULL, 0) != SQLITE_DONE) { 2448 ERROR_STMT_SQLITE(db->sqlite, STMT(ANNOTATE_DEL2)); 2449 pkgdb_transaction_rollback_sqlite(db->sqlite, NULL); 2450 return (EPKG_FATAL); 2451 } 2452 2453 if (pkgdb_transaction_commit_sqlite(db->sqlite, NULL) != EPKG_OK) 2454 return (EPKG_FATAL); 2455 2456 return (rows_changed == 1 ? EPKG_OK : EPKG_WARN); 2457 } 2458 2459 /* 2460 * Complete a transaction started by pkgdb_register_pkg(). 2461 */ 2462 int 2463 pkgdb_register_finale(struct pkgdb *db, int retcode, const char *savepoint) 2464 { 2465 int ret = EPKG_OK; 2466 2467 assert(db != NULL); 2468 2469 if (retcode == EPKG_OK) 2470 ret = pkgdb_transaction_commit_sqlite(db->sqlite, savepoint); 2471 else 2472 ret = pkgdb_transaction_rollback_sqlite(db->sqlite, savepoint); 2473 2474 return (ret); 2475 } 2476 2477 int 2478 pkgdb_unregister_pkg(struct pkgdb *db, int64_t id) 2479 { 2480 sqlite3_stmt *stmt_del; 2481 unsigned int obj; 2482 int ret; 2483 const char sql[] = "" 2484 "DELETE FROM packages WHERE id = ?1;"; 2485 const char *deletions[] = { 2486 "directories WHERE id NOT IN " 2487 "(SELECT DISTINCT directory_id FROM pkg_directories)", 2488 "categories WHERE id NOT IN " 2489 "(SELECT DISTINCT category_id FROM pkg_categories)", 2490 "licenses WHERE id NOT IN " 2491 "(SELECT DISTINCT license_id FROM pkg_licenses)", 2492 /* TODO print the users that are not used anymore */ 2493 "users WHERE id NOT IN " 2494 "(SELECT DISTINCT user_id FROM pkg_users)", 2495 /* TODO print the groups that are not used anymore */ 2496 "groups WHERE id NOT IN " 2497 "(SELECT DISTINCT group_id FROM pkg_groups)", 2498 "shlibs WHERE id NOT IN " 2499 "(SELECT DISTINCT shlib_id FROM pkg_shlibs_required)" 2500 "AND id NOT IN " 2501 "(SELECT DISTINCT shlib_id FROM pkg_shlibs_required_ignore)" 2502 "AND id NOT IN " 2503 "(SELECT DISTINCT shlib_id FROM pkg_shlibs_provided)" 2504 "AND id NOT IN " 2505 "(SELECT DISTINCT shlib_id FROM pkg_shlibs_provided_ignore)", 2506 "script WHERE script_id NOT IN " 2507 "(SELECT DISTINCT script_id FROM pkg_script)", 2508 "lua_script WHERE lua_script_id NOT IN " 2509 "(SELECT DISTINCT lua_script_id FROM pkg_lua_script)", 2510 }; 2511 2512 assert(db != NULL); 2513 2514 stmt_del = prepare_sql(db->sqlite, sql); 2515 if (stmt_del == NULL) 2516 return (EPKG_FATAL); 2517 2518 sqlite3_bind_int64(stmt_del, 1, id); 2519 pkgdb_debug(4, stmt_del); 2520 2521 ret = sqlite3_step(stmt_del); 2522 2523 if (ret != SQLITE_DONE) { 2524 ERROR_STMT_SQLITE(db->sqlite, stmt_del); 2525 sqlite3_finalize(stmt_del); 2526 return (EPKG_FATAL); 2527 } 2528 sqlite3_finalize(stmt_del); 2529 2530 for (obj = 0 ;obj < NELEM(deletions); obj++) { 2531 ret = sql_exec(db->sqlite, "DELETE FROM %s;", deletions[obj]); 2532 if (ret != EPKG_OK) 2533 return (EPKG_FATAL); 2534 } 2535 return (EPKG_OK); 2536 } 2537 2538 int 2539 sql_exec(sqlite3 *s, const char *sql, ...) 2540 { 2541 va_list ap; 2542 const char *sql_to_exec; 2543 char *sqlbuf = NULL; 2544 char *errmsg; 2545 int ret = EPKG_FATAL; 2546 2547 assert(s != NULL); 2548 assert(sql != NULL); 2549 2550 if (strchr(sql, '%') != NULL) { 2551 va_start(ap, sql); 2552 sqlbuf = sqlite3_vmprintf(sql, ap); 2553 va_end(ap); 2554 sql_to_exec = sqlbuf; 2555 } else { 2556 sql_to_exec = sql; 2557 } 2558 2559 dbg(4, "executing '%s'", sql_to_exec); 2560 if (sqlite3_exec(s, sql_to_exec, NULL, NULL, &errmsg) != SQLITE_OK) { 2561 ERROR_SQLITE(s, sql_to_exec); 2562 sqlite3_free(errmsg); 2563 goto cleanup; 2564 } 2565 2566 ret = EPKG_OK; 2567 2568 cleanup: 2569 if (sqlbuf != NULL) 2570 sqlite3_free(sqlbuf); 2571 2572 return (ret); 2573 } 2574 2575 int 2576 get_pragma(sqlite3 *s, const char *sql, int64_t *res, bool silence) 2577 { 2578 sqlite3_stmt *stmt; 2579 int ret; 2580 2581 assert(s != NULL && sql != NULL); 2582 2583 if (sqlite3_prepare_v2(s, sql, -1, &stmt, NULL) != SQLITE_OK) { 2584 if (!silence) 2585 ERROR_SQLITE(s, sql); 2586 return (EPKG_OK); 2587 } 2588 pkgdb_debug(4, stmt); 2589 2590 PKGDB_SQLITE_RETRY_ON_BUSY(ret) 2591 ret = sqlite3_step(stmt); 2592 2593 if (ret == SQLITE_ROW) 2594 *res = sqlite3_column_int64(stmt, 0); 2595 2596 2597 if (ret != SQLITE_ROW && !silence) 2598 ERROR_STMT_SQLITE(s, stmt); 2599 sqlite3_finalize(stmt); 2600 2601 return (ret == SQLITE_ROW ? EPKG_OK : EPKG_FATAL); 2602 } 2603 2604 int 2605 pkgdb_compact(struct pkgdb *db) 2606 { 2607 int64_t page_count = 0; 2608 int64_t freelist_count = 0; 2609 int ret; 2610 2611 assert(db != NULL); 2612 2613 ret = get_pragma(db->sqlite, "PRAGMA page_count;", &page_count, false); 2614 if (ret != EPKG_OK) 2615 return (EPKG_FATAL); 2616 2617 ret = get_pragma(db->sqlite, "PRAGMA freelist_count;", 2618 &freelist_count, false); 2619 if (ret != EPKG_OK) 2620 return (EPKG_FATAL); 2621 2622 /* 2623 * Only compact if we will save 25% (or more) of the current 2624 * used space. 2625 */ 2626 2627 if (freelist_count > 0 && freelist_count / (float)page_count < 0.25) 2628 return (EPKG_OK); 2629 2630 return (sql_exec(db->sqlite, "VACUUM;")); 2631 } 2632 2633 static int 2634 pkgdb_vset(struct pkgdb *db, int64_t id, va_list ap) 2635 { 2636 int attr; 2637 sqlite3_stmt *stmt; 2638 int64_t flatsize; 2639 bool automatic, locked, vital; 2640 char *oldval; 2641 char *newval; 2642 2643 /* Ensure there is an entry for each of the pkg_set_attr enum values */ 2644 const char *sql[PKG_SET_MAX] = { 2645 [PKG_SET_FLATSIZE] = 2646 "UPDATE packages SET flatsize = ?1 WHERE id = ?2", 2647 [PKG_SET_AUTOMATIC] = 2648 "UPDATE packages SET automatic = ?1 WHERE id = ?2", 2649 [PKG_SET_LOCKED] = 2650 "UPDATE packages SET locked = ?1 WHERE id = ?2", 2651 [PKG_SET_DEPORIGIN] = 2652 "UPDATE deps SET origin = ?1, " 2653 "name=(SELECT name FROM packages WHERE origin = ?1), " 2654 "version=(SELECT version FROM packages WHERE origin = ?1) " 2655 "WHERE package_id = ?2 AND origin = ?3", 2656 [PKG_SET_ORIGIN] = 2657 "UPDATE packages SET origin=?1 WHERE id=?2", 2658 [PKG_SET_DEPNAME] = 2659 "UPDATE deps SET name = ?1, " 2660 "version=(SELECT version FROM packages WHERE name = ?1) " 2661 "WHERE package_id = ?2 AND name = ?3", 2662 [PKG_SET_NAME] = 2663 "UPDATE packages SET name=?1 WHERE id=?2", 2664 [PKG_SET_VITAL] = 2665 "UPDATE packages SET vital = ?1 WHERE id = ?2", 2666 }; 2667 2668 while ((attr = va_arg(ap, int)) > 0) { 2669 stmt = prepare_sql(db->sqlite, sql[attr]); 2670 if (stmt == NULL) 2671 return (EPKG_FATAL); 2672 2673 switch (attr) { 2674 case PKG_SET_FLATSIZE: 2675 flatsize = va_arg(ap, int64_t); 2676 sqlite3_bind_int64(stmt, 1, flatsize); 2677 sqlite3_bind_int64(stmt, 2, id); 2678 break; 2679 case PKG_SET_AUTOMATIC: 2680 automatic = (bool)va_arg(ap, int); 2681 sqlite3_bind_int64(stmt, 1, automatic); 2682 sqlite3_bind_int64(stmt, 2, id); 2683 break; 2684 case PKG_SET_LOCKED: 2685 locked = (bool)va_arg(ap, int); 2686 sqlite3_bind_int64(stmt, 1, locked); 2687 sqlite3_bind_int64(stmt, 2, id); 2688 break; 2689 case PKG_SET_DEPORIGIN: 2690 case PKG_SET_DEPNAME: 2691 oldval = va_arg(ap, char *); 2692 newval = va_arg(ap, char *); 2693 sqlite3_bind_text(stmt, 1, newval, -1, SQLITE_STATIC); 2694 sqlite3_bind_int64(stmt, 2, id); 2695 sqlite3_bind_text(stmt, 3, oldval, -1, SQLITE_STATIC); 2696 break; 2697 case PKG_SET_ORIGIN: 2698 case PKG_SET_NAME: 2699 newval = va_arg(ap, char *); 2700 sqlite3_bind_text(stmt, 1, newval, -1, SQLITE_STATIC); 2701 sqlite3_bind_int64(stmt, 2, id); 2702 break; 2703 case PKG_SET_VITAL: 2704 vital = (bool)va_arg(ap, int); 2705 sqlite3_bind_int64(stmt, 1, vital); 2706 sqlite3_bind_int64(stmt, 2, id); 2707 break; 2708 } 2709 2710 pkgdb_debug(4, stmt); 2711 if (sqlite3_step(stmt) != SQLITE_DONE) { 2712 ERROR_STMT_SQLITE(db->sqlite, stmt); 2713 sqlite3_finalize(stmt); 2714 return (EPKG_FATAL); 2715 } 2716 2717 sqlite3_finalize(stmt); 2718 } 2719 return (EPKG_OK); 2720 } 2721 2722 int 2723 pkgdb_set2(struct pkgdb *db, struct pkg *pkg, ...) 2724 { 2725 int ret = EPKG_OK; 2726 va_list ap; 2727 2728 assert(pkg != NULL); 2729 2730 va_start(ap, pkg); 2731 ret = pkgdb_vset(db, pkg->id, ap); 2732 va_end(ap); 2733 2734 return (ret); 2735 } 2736 2737 /* 2738 * return the number of row changed or -1 in case of sql failure, -2 in case of invalid field 2739 */ 2740 int 2741 pkgdb_replace(struct pkgdb *db, unsigned int field, const char *pattern, const char *replace) 2742 { 2743 sqlite3_stmt *stmt; 2744 char *globmatch = NULL; 2745 2746 const char *sql[PKG_SET_MAX] = { 2747 [PKG_SET_NAME] = "update packages set name = replace(name, ?1, ?2) where name glob ?3", 2748 [PKG_SET_ORIGIN] = "update packages set origin = replace(origin, ?1, ?2) where origin glob ?3", 2749 [PKG_SET_DEPNAME] = "update deps set name = replace(name, ?1, ?2) where name glob '?3'", 2750 [PKG_SET_DEPORIGIN] = "update deps set origin = replace(origin, ?1, ?2) where origin glob ?3", 2751 }; 2752 2753 if (pattern == NULL) 2754 return (-3); 2755 if (replace == NULL) 2756 return (-4); 2757 if (field != PKG_SET_NAME && field != PKG_SET_ORIGIN && 2758 field != PKG_SET_DEPNAME && field != PKG_SET_DEPORIGIN) { 2759 return (-2); 2760 } 2761 2762 stmt = prepare_sql(db->sqlite, sql[field]); 2763 if (stmt == NULL) 2764 return (EPKG_FATAL); 2765 sqlite3_bind_text(stmt, 1, pattern, -1, SQLITE_STATIC); 2766 sqlite3_bind_text(stmt, 2, replace, -1, SQLITE_STATIC); 2767 xasprintf(&globmatch, "*%s*", pattern); 2768 sqlite3_bind_text(stmt, 3, globmatch, -1, SQLITE_STATIC); 2769 pkgdb_debug(4, stmt); 2770 if (sqlite3_step(stmt) != SQLITE_DONE) { 2771 free(globmatch); 2772 ERROR_STMT_SQLITE(db->sqlite, stmt); 2773 sqlite3_finalize(stmt); 2774 return (-1); 2775 } 2776 free(globmatch); 2777 sqlite3_finalize(stmt); 2778 return (sqlite3_changes(db->sqlite)); 2779 } 2780 2781 int 2782 pkgdb_file_set_cksum(struct pkgdb *db, struct pkg_file *file, 2783 const char *sum) 2784 { 2785 sqlite3_stmt *stmt = NULL; 2786 const char sql_file_update[] = "" 2787 "UPDATE files SET sha256 = ?1 WHERE path = ?2"; 2788 2789 stmt = prepare_sql(db->sqlite, sql_file_update); 2790 if (stmt == NULL) 2791 return (EPKG_FATAL); 2792 sqlite3_bind_text(stmt, 1, sum, -1, SQLITE_STATIC); 2793 sqlite3_bind_text(stmt, 2, file->path, -1, SQLITE_STATIC); 2794 pkgdb_debug(4, stmt); 2795 2796 if (sqlite3_step(stmt) != SQLITE_DONE) { 2797 ERROR_STMT_SQLITE(db->sqlite, stmt); 2798 sqlite3_finalize(stmt); 2799 return (EPKG_FATAL); 2800 } 2801 sqlite3_finalize(stmt); 2802 file->sum = xstrdup(sum); 2803 2804 return (EPKG_OK); 2805 } 2806 2807 /* 2808 * create our custom functions in the sqlite3 connection. 2809 * Used both in the shell and pkgdb_open 2810 */ 2811 int 2812 pkgdb_sqlcmd_init(sqlite3 *db, __unused const char **err, 2813 __unused const void *noused) 2814 { 2815 sqlite3_create_function(db, "now", 0, SQLITE_ANY|SQLITE_DETERMINISTIC, NULL, 2816 pkgdb_now, NULL, NULL); 2817 sqlite3_create_function(db, "regexp", 2, SQLITE_ANY|SQLITE_DETERMINISTIC, NULL, 2818 pkgdb_regex, NULL, NULL); 2819 sqlite3_create_function(db, "vercmp", 3, SQLITE_ANY|SQLITE_DETERMINISTIC, NULL, 2820 pkgdb_vercmp, NULL, NULL); 2821 2822 return SQLITE_OK; 2823 } 2824 2825 void 2826 pkgdb_cmd(int argc, char **argv) 2827 { 2828 sqlite3_shell(argc, argv); 2829 } 2830 2831 void 2832 pkgdb_init_proc(void) 2833 { 2834 sqlite3_initialize(); 2835 sqlite3_auto_extension((void(*)(void))pkgdb_sqlcmd_init); 2836 } 2837 2838 2839 void 2840 pkgshell_opendb(const char **reponame) 2841 { 2842 char localpath[MAXPATHLEN]; 2843 2844 snprintf(localpath, sizeof(localpath), "%s/local.sqlite", ctx.dbdir); 2845 *reponame = xstrdup(localpath); 2846 } 2847 2848 static int 2849 pkgdb_write_lock_pid(struct pkgdb *db) 2850 { 2851 const char lock_pid_sql[] = "" 2852 "INSERT INTO pkg_lock_pid VALUES (?1);"; 2853 sqlite3_stmt *stmt = NULL; 2854 2855 stmt = prepare_sql(db->sqlite, lock_pid_sql); 2856 if (stmt == NULL) 2857 return (EPKG_FATAL); 2858 sqlite3_bind_int64(stmt, 1, (int64_t)getpid()); 2859 2860 if (sqlite3_step(stmt) != SQLITE_DONE) { 2861 ERROR_SQLITE(db->sqlite, lock_pid_sql); 2862 sqlite3_finalize(stmt); 2863 return (EPKG_FATAL); 2864 } 2865 sqlite3_finalize(stmt); 2866 2867 return (EPKG_OK); 2868 } 2869 2870 static int 2871 pkgdb_remove_lock_pid(struct pkgdb *db, int64_t pid) 2872 { 2873 const char lock_pid_sql[] = "" 2874 "DELETE FROM pkg_lock_pid WHERE pid = ?1;"; 2875 sqlite3_stmt *stmt = NULL; 2876 2877 stmt = prepare_sql(db->sqlite, lock_pid_sql); 2878 if (stmt == NULL) 2879 return (EPKG_FATAL); 2880 sqlite3_bind_int64(stmt, 1, pid); 2881 2882 if (sqlite3_step(stmt) != SQLITE_DONE) { 2883 ERROR_STMT_SQLITE(db->sqlite, stmt); 2884 sqlite3_finalize(stmt); 2885 return (EPKG_FATAL); 2886 } 2887 sqlite3_finalize(stmt); 2888 2889 return (EPKG_OK); 2890 } 2891 2892 static int 2893 pkgdb_check_lock_pid(struct pkgdb *db) 2894 { 2895 sqlite3_stmt *stmt = NULL; 2896 int found = 0; 2897 int64_t pid, lpid; 2898 const char query[] = "SELECT pid FROM pkg_lock_pid;"; 2899 2900 stmt = prepare_sql(db->sqlite, query); 2901 if (stmt == NULL) 2902 return (EPKG_FATAL); 2903 2904 lpid = getpid(); 2905 2906 while (sqlite3_step(stmt) != SQLITE_DONE) { 2907 pid = sqlite3_column_int64(stmt, 0); 2908 if (pid != lpid) { 2909 if (kill((pid_t)pid, 0) == -1) { 2910 dbg(1, "found stale pid %lld in lock database, my pid is: %lld", 2911 (long long)pid, (long long)lpid); 2912 if (pkgdb_remove_lock_pid(db, pid) != EPKG_OK){ 2913 sqlite3_finalize(stmt); 2914 return (EPKG_FATAL); 2915 } 2916 } 2917 else { 2918 pkg_emit_notice("process with pid %lld still holds the lock", 2919 (long long int)pid); 2920 found ++; 2921 } 2922 } 2923 } 2924 sqlite3_finalize(stmt); 2925 2926 if (found == 0) 2927 return (EPKG_END); 2928 2929 return (EPKG_OK); 2930 } 2931 2932 static int 2933 pkgdb_reset_lock(struct pkgdb *db) 2934 { 2935 const char init_sql[] = "" 2936 "UPDATE pkg_lock SET exclusive=0, advisory=0, read=0;"; 2937 int ret; 2938 2939 ret = sqlite3_exec(db->sqlite, init_sql, NULL, NULL, NULL); 2940 2941 if (ret == SQLITE_OK) 2942 return (EPKG_OK); 2943 2944 return (EPKG_FATAL); 2945 } 2946 2947 static int 2948 pkgdb_try_lock(struct pkgdb *db, const char *lock_sql, pkgdb_lock_t type, 2949 bool upgrade) 2950 { 2951 unsigned int tries = 0; 2952 struct timespec ts; 2953 int ret = EPKG_END; 2954 const pkg_object *timeout, *max_tries; 2955 double num_timeout = 1.0; 2956 int64_t num_maxtries = 1; 2957 const char reset_lock_sql[] = "" 2958 "DELETE FROM pkg_lock; INSERT INTO pkg_lock VALUES (0,0,0);"; 2959 2960 2961 timeout = pkg_config_get("LOCK_WAIT"); 2962 max_tries = pkg_config_get("LOCK_RETRIES"); 2963 2964 if (timeout) 2965 num_timeout = pkg_object_int(timeout); 2966 if (max_tries) 2967 num_maxtries = pkg_object_int(max_tries); 2968 2969 while (tries <= num_maxtries) { 2970 ret = sqlite3_exec(db->sqlite, lock_sql, NULL, NULL, NULL); 2971 if (ret != SQLITE_OK) { 2972 if (ret == SQLITE_READONLY && type == PKGDB_LOCK_READONLY) { 2973 dbg(1, "want read lock but cannot write to database, " 2974 "slightly ignore this error for now"); 2975 return (EPKG_OK); 2976 } 2977 return (EPKG_FATAL); 2978 } 2979 2980 ret = EPKG_END; 2981 if (sqlite3_changes(db->sqlite) == 0) { 2982 if (pkgdb_check_lock_pid(db) == EPKG_END) { 2983 /* No live processes found, so we can safely reset lock */ 2984 dbg(1, "no concurrent processes found, cleanup the lock"); 2985 pkgdb_reset_lock(db); 2986 2987 if (upgrade) { 2988 /* 2989 * In case of upgrade we should obtain a lock from the beginning, 2990 * hence switch upgrade to retain 2991 */ 2992 pkgdb_remove_lock_pid(db, (int64_t)getpid()); 2993 return pkgdb_obtain_lock(db, type); 2994 } 2995 else { 2996 /* 2997 * We might have inconsistent db, or some strange issue, so 2998 * just insert new record and go forward 2999 */ 3000 pkgdb_remove_lock_pid(db, (int64_t)getpid()); 3001 sqlite3_exec(db->sqlite, reset_lock_sql, NULL, NULL, NULL); 3002 return pkgdb_obtain_lock(db, type); 3003 } 3004 } 3005 else if (num_timeout > 0) { 3006 ts.tv_sec = (int)num_timeout; 3007 ts.tv_nsec = (num_timeout - (int)num_timeout) * 1000000000.; 3008 dbg(1, "waiting for database lock for %d times, " 3009 "next try in %.2f seconds", tries, num_timeout); 3010 (void)nanosleep(&ts, NULL); 3011 } 3012 else { 3013 break; 3014 } 3015 } 3016 else if (!upgrade) { 3017 ret = pkgdb_write_lock_pid(db); 3018 break; 3019 } 3020 else { 3021 ret = EPKG_OK; 3022 break; 3023 } 3024 tries ++; 3025 } 3026 3027 return (ret); 3028 } 3029 3030 int 3031 pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type) 3032 { 3033 int ret; 3034 3035 const char readonly_lock_sql[] = "" 3036 "UPDATE pkg_lock SET read=read+1 WHERE exclusive=0;"; 3037 const char advisory_lock_sql[] = "" 3038 "UPDATE pkg_lock SET advisory=1 WHERE exclusive=0 AND advisory=0;"; 3039 const char exclusive_lock_sql[] = "" 3040 "UPDATE pkg_lock SET exclusive=1 WHERE exclusive=0 AND advisory=0 AND read=0;"; 3041 const char *lock_sql = NULL; 3042 3043 assert(db != NULL); 3044 3045 switch (type) { 3046 case PKGDB_LOCK_READONLY: 3047 if (!ucl_object_toboolean(pkg_config_get("READ_LOCK"))) 3048 return (EPKG_OK); 3049 lock_sql = readonly_lock_sql; 3050 dbg(1, "want to get a read only lock on a database"); 3051 break; 3052 case PKGDB_LOCK_ADVISORY: 3053 lock_sql = advisory_lock_sql; 3054 dbg(1, "want to get an advisory lock on a database"); 3055 break; 3056 case PKGDB_LOCK_EXCLUSIVE: 3057 dbg(1, "want to get an exclusive lock on a database"); 3058 lock_sql = exclusive_lock_sql; 3059 break; 3060 } 3061 3062 ret = pkgdb_try_lock(db, lock_sql, type, false); 3063 3064 if (ret != EPKG_OK) 3065 dbg(1, "failed to obtain the lock: %s", 3066 sqlite3_errmsg(db->sqlite)); 3067 3068 return (ret); 3069 } 3070 3071 int 3072 pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_type) 3073 { 3074 const char advisory_exclusive_lock_sql[] = "" 3075 "UPDATE pkg_lock SET exclusive=1,advisory=1 WHERE exclusive=0 AND advisory=1 AND read=0;"; 3076 int ret = EPKG_FATAL; 3077 3078 assert(db != NULL); 3079 3080 if (old_type == PKGDB_LOCK_ADVISORY && new_type == PKGDB_LOCK_EXCLUSIVE) { 3081 dbg(1, "want to upgrade advisory to exclusive lock"); 3082 ret = pkgdb_try_lock(db, advisory_exclusive_lock_sql, 3083 new_type, true); 3084 } 3085 3086 return (ret); 3087 } 3088 3089 int 3090 pkgdb_downgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, 3091 pkgdb_lock_t new_type) 3092 { 3093 const char downgrade_exclusive_lock_sql[] = "" 3094 "UPDATE pkg_lock SET exclusive=0,advisory=1 WHERE exclusive=1 " 3095 "AND advisory=1 AND read=0;"; 3096 int ret = EPKG_FATAL; 3097 3098 assert(db != NULL); 3099 3100 if (old_type == PKGDB_LOCK_EXCLUSIVE && 3101 new_type == PKGDB_LOCK_ADVISORY) { 3102 dbg(1, "want to downgrade exclusive to advisory lock"); 3103 ret = pkgdb_try_lock(db, downgrade_exclusive_lock_sql, 3104 new_type, true); 3105 } 3106 3107 return (ret); 3108 } 3109 3110 int 3111 pkgdb_release_lock(struct pkgdb *db, pkgdb_lock_t type) 3112 { 3113 const char readonly_unlock_sql[] = "" 3114 "UPDATE pkg_lock SET read=read-1 WHERE read>0;"; 3115 const char advisory_unlock_sql[] = "" 3116 "UPDATE pkg_lock SET advisory=0 WHERE advisory=1;"; 3117 const char exclusive_unlock_sql[] = "" 3118 "UPDATE pkg_lock SET exclusive=0 WHERE exclusive=1;"; 3119 const char *unlock_sql = NULL; 3120 int ret = EPKG_FATAL; 3121 3122 if (db == NULL) 3123 return (EPKG_OK); 3124 3125 switch (type) { 3126 case PKGDB_LOCK_READONLY: 3127 if (!ucl_object_toboolean(pkg_config_get("READ_LOCK"))) 3128 return (EPKG_OK); 3129 3130 unlock_sql = readonly_unlock_sql; 3131 dbg(1, "release a read only lock on a database"); 3132 3133 break; 3134 case PKGDB_LOCK_ADVISORY: 3135 unlock_sql = advisory_unlock_sql; 3136 dbg(1, "release an advisory lock on a database"); 3137 break; 3138 case PKGDB_LOCK_EXCLUSIVE: 3139 dbg(1, "release an exclusive lock on a database"); 3140 unlock_sql = exclusive_unlock_sql; 3141 break; 3142 } 3143 3144 ret = sqlite3_exec(db->sqlite, unlock_sql, NULL, NULL, NULL); 3145 if (ret != SQLITE_OK) 3146 return (EPKG_FATAL); 3147 3148 if (sqlite3_changes(db->sqlite) == 0) 3149 return (EPKG_END); 3150 3151 return pkgdb_remove_lock_pid(db, (int64_t)getpid()); 3152 } 3153 3154 int64_t 3155 pkgdb_stats(struct pkgdb *db, pkg_stats_t type) 3156 { 3157 sqlite3_stmt *stmt = NULL; 3158 int64_t stats = 0; 3159 const char *sql = NULL; 3160 3161 assert(db != NULL); 3162 3163 switch(type) { 3164 case PKG_STATS_LOCAL_COUNT: 3165 sql = "SELECT COUNT(id) FROM main.packages;"; 3166 break; 3167 case PKG_STATS_LOCAL_SIZE: 3168 sql = "SELECT SUM(flatsize) FROM main.packages;"; 3169 break; 3170 case PKG_STATS_REMOTE_UNIQUE: 3171 case PKG_STATS_REMOTE_COUNT: 3172 case PKG_STATS_REMOTE_SIZE: 3173 vec_foreach(db->repos, i) { 3174 if (db->repos.d[i]->ops->stat != NULL) 3175 stats += db->repos.d[i]->ops->stat(db->repos.d[i], type); 3176 } 3177 return (stats); 3178 break; 3179 case PKG_STATS_REMOTE_REPOS: 3180 return (vec_len(&db->repos)); 3181 break; 3182 } 3183 3184 stmt = prepare_sql(db->sqlite, sql); 3185 if (stmt == NULL) 3186 return (-1); 3187 3188 while (sqlite3_step(stmt) != SQLITE_DONE) { 3189 stats = sqlite3_column_int64(stmt, 0); 3190 pkgdb_debug(4, stmt); 3191 } 3192 3193 sqlite3_finalize(stmt); 3194 3195 return (stats); 3196 } 3197 3198 3199 int 3200 pkgdb_begin_solver(struct pkgdb *db) 3201 { 3202 const char solver_sql[] = "" 3203 "BEGIN TRANSACTION;"; 3204 const char update_digests_sql[] = "" 3205 "DROP INDEX IF EXISTS pkg_digest_id;" 3206 "BEGIN TRANSACTION;"; 3207 const char end_update_sql[] = "" 3208 "END TRANSACTION;" 3209 "CREATE INDEX pkg_digest_id ON packages(name, manifestdigest);"; 3210 struct pkgdb_it *it; 3211 struct pkg *p = NULL; 3212 pkgs_t pkglist = vec_init(); 3213 int rc = EPKG_OK; 3214 int64_t cnt = 0, cur = 0; 3215 3216 it = pkgdb_query_cond(db, " WHERE manifestdigest IS NULL OR manifestdigest==''", 3217 NULL, MATCH_ALL); 3218 if (it != NULL) { 3219 while (pkgdb_it_next(it, &p, PKG_LOAD_BASIC|PKG_LOAD_OPTIONS) == EPKG_OK) { 3220 pkg_checksum_calculate(p, NULL, false, true, false); 3221 vec_push(&pkglist, p); 3222 p = NULL; 3223 cnt ++; 3224 } 3225 pkgdb_it_free(it); 3226 3227 if (vec_len(&pkglist) > 0) { 3228 rc = sql_exec(db->sqlite, update_digests_sql); 3229 if (rc != EPKG_OK) { 3230 ERROR_SQLITE(db->sqlite, update_digests_sql); 3231 } 3232 else { 3233 pkg_emit_progress_start("Updating database digests format"); 3234 vec_foreach(pkglist, i) { 3235 pkg_emit_progress_tick(cur++, cnt); 3236 if (pkgdb_set_pkg_digest(db, pkglist.d[i]) == EPKG_OK) 3237 rc = SQLITE_DONE; 3238 } 3239 3240 pkg_emit_progress_tick(cnt, cnt); 3241 if (rc == SQLITE_DONE) 3242 rc = sql_exec(db->sqlite, end_update_sql); 3243 3244 if (rc != SQLITE_OK) 3245 ERROR_SQLITE(db->sqlite, end_update_sql); 3246 } 3247 } 3248 3249 if (rc == EPKG_OK) 3250 rc = sql_exec(db->sqlite, solver_sql); 3251 3252 vec_free_and_free(&pkglist, pkg_free); 3253 } else { 3254 rc = sql_exec(db->sqlite, solver_sql); 3255 } 3256 3257 return (rc); 3258 } 3259 3260 int 3261 pkgdb_end_solver(struct pkgdb *db) 3262 { 3263 const char solver_sql[] = "" 3264 "END TRANSACTION;"; 3265 3266 return (sql_exec(db->sqlite, solver_sql)); 3267 } 3268 3269 int 3270 pkgdb_is_dir_used(struct pkgdb *db, struct pkg *p, const char *dir, int64_t *res) 3271 { 3272 sqlite3_stmt *stmt; 3273 int ret; 3274 3275 const char sql[] = "" 3276 "SELECT count(package_id) FROM pkg_directories, directories " 3277 "WHERE directory_id = directories.id AND directories.path = ?1 " 3278 "AND package_id != ?2;"; 3279 3280 stmt = prepare_sql(db->sqlite, sql); 3281 if (stmt == NULL) 3282 return (EPKG_FATAL); 3283 3284 sqlite3_bind_text(stmt, 1, dir, -1, SQLITE_TRANSIENT); 3285 sqlite3_bind_int64(stmt, 2, p->id); 3286 3287 ret = sqlite3_step(stmt); 3288 3289 if (ret == SQLITE_ROW) 3290 *res = sqlite3_column_int64(stmt, 0); 3291 3292 sqlite3_finalize(stmt); 3293 3294 if (ret != SQLITE_ROW) { 3295 ERROR_SQLITE(db->sqlite, sql); 3296 return (EPKG_FATAL); 3297 } 3298 3299 return (EPKG_OK); 3300 } 3301 3302 void 3303 pkgdb_debug(int level, sqlite3_stmt *stmt) 3304 { 3305 char *str; 3306 3307 if (ctx.debug_level < level) 3308 return; 3309 3310 str = sqlite3_expanded_sql(stmt); 3311 dbg(level, "running: '%s'", str); 3312 sqlite3_free(str); 3313 } 3314 3315 bool 3316 pkgdb_is_shlib_provided(struct pkgdb *db, const char *req) 3317 { 3318 sqlite3_stmt *stmt; 3319 int ret; 3320 bool found = false; 3321 3322 const char *sql = "" 3323 "select package_id from pkg_shlibs_provided INNER JOIN shlibs " 3324 "on pkg_shlibs_provided.shlib_id = shlibs.id " 3325 "where shlibs.name=?1" ; 3326 3327 stmt = prepare_sql(db->sqlite, sql); 3328 if (stmt == NULL) 3329 return (false); 3330 3331 sqlite3_bind_text(stmt, 1, req, -1, SQLITE_TRANSIENT); 3332 ret = sqlite3_step(stmt); 3333 if (ret == SQLITE_ROW) 3334 found = true; 3335 3336 sqlite3_finalize(stmt); 3337 return (found); 3338 } 3339 3340 bool 3341 pkgdb_is_provided(struct pkgdb *db, const char *req) 3342 { 3343 sqlite3_stmt *stmt; 3344 int ret; 3345 bool found = false; 3346 3347 const char *sql = "" 3348 "select package_id from pkg_provides INNER JOIN provides " 3349 "on pkg_provides.provide_id = provides.id " 3350 "where provides.provide = ?1" ; 3351 3352 stmt = prepare_sql(db->sqlite, sql); 3353 if (stmt == NULL) 3354 return (false); 3355 3356 sqlite3_bind_text(stmt, 1, req, -1, SQLITE_TRANSIENT); 3357 ret = sqlite3_step(stmt); 3358 if (ret == SQLITE_ROW) 3359 found = true; 3360 3361 sqlite3_finalize(stmt); 3362 return (found); 3363 }