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