1 /*-
2 * Copyright (c) 2011-2015 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-2014 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-2017 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 <assert.h>
40 #include <errno.h>
41 #include <regex.h>
42 #include <grp.h>
43 #ifdef HAVE_LIBUTIL_H
44 #include <libutil.h>
45 #endif
46 #include <stdlib.h>
47 #include <stdio.h>
48 #include <stdbool.h>
49 #include <string.h>
50 #include <unistd.h>
51 #include <signal.h>
52
53 #include <sqlite3.h>
54
55 #include <bsd_compat.h>
56
57 #include "pkg.h"
58 #include "private/event.h"
59 #include "private/pkg.h"
60 #include "private/pkgdb.h"
61 #include "private/utils.h"
62 #include "private/pkg_deps.h"
63
64 /*
65 * Keep entries sorted by name!
66 */
67 static struct column_mapping {
68 const char * const name;
69 pkg_attr type;
70 enum {
71 PKG_SQLITE_STRING,
72 PKG_SQLITE_INT64,
73 PKG_SQLITE_BOOL
74 } pkg_type;
75 } columns[] = {
76 { "arch", PKG_ABI, PKG_SQLITE_STRING },
77 { "automatic", PKG_AUTOMATIC, PKG_SQLITE_BOOL },
78 { "cksum", PKG_CKSUM, PKG_SQLITE_STRING },
79 { "comment", PKG_COMMENT, PKG_SQLITE_STRING },
80 { "dbname", PKG_REPONAME, PKG_SQLITE_STRING },
81 { "dep_formula", PKG_DEP_FORMULA, PKG_SQLITE_STRING },
82 { "desc", PKG_DESC, PKG_SQLITE_STRING },
83 { "flatsize", PKG_FLATSIZE, PKG_SQLITE_INT64 },
84 { "id", PKG_ROWID, PKG_SQLITE_INT64 },
85 { "licenselogic", PKG_LICENSE_LOGIC, PKG_SQLITE_INT64 },
86 { "locked", PKG_LOCKED, PKG_SQLITE_BOOL },
87 { "maintainer", PKG_MAINTAINER, PKG_SQLITE_STRING },
88 { "manifestdigest", PKG_DIGEST, PKG_SQLITE_STRING },
89 { "message", PKG_MESSAGE, PKG_SQLITE_STRING },
90 { "name", PKG_NAME, PKG_SQLITE_STRING },
91 { "oldflatsize", PKG_OLD_FLATSIZE, PKG_SQLITE_INT64 },
92 { "oldversion", PKG_OLD_VERSION, PKG_SQLITE_STRING },
93 { "origin", PKG_ORIGIN, PKG_SQLITE_STRING },
94 { "pkgsize", PKG_PKGSIZE, PKG_SQLITE_INT64 },
95 { "prefix", PKG_PREFIX, PKG_SQLITE_STRING },
96 { "repopath", PKG_REPOPATH, PKG_SQLITE_STRING },
97 { "repourl", PKG_REPOURL, PKG_SQLITE_STRING },
98 { "rowid", PKG_ROWID, PKG_SQLITE_INT64 },
99 { "time", PKG_TIME, PKG_SQLITE_INT64 },
100 { "uniqueid", PKG_UNIQUEID, PKG_SQLITE_STRING },
101 { "version", PKG_VERSION, PKG_SQLITE_STRING },
102 { "vital", PKG_VITAL, PKG_SQLITE_BOOL },
103 { "weight", -1, PKG_SQLITE_INT64 },
104 { "www", PKG_WWW, PKG_SQLITE_STRING },
105 { NULL, -1, PKG_SQLITE_STRING }
106 };
107
108 static int
pkg_addcategory(struct pkg * pkg,const char * data)109 pkg_addcategory(struct pkg *pkg, const char *data)
110 {
111 return (pkg_addstring(&pkg->categories, data, "category"));
112 }
113
114 static int
pkg_addlicense(struct pkg * pkg,const char * data)115 pkg_addlicense(struct pkg *pkg, const char *data)
116 {
117 return (pkg_addstring(&pkg->licenses, data, "license"));
118 }
119
120 static int
pkg_addannotation(struct pkg * pkg,const char * k,const char * v)121 pkg_addannotation(struct pkg *pkg, const char *k, const char *v)
122 {
123 return (pkg_kv_add(&pkg->annotations, k, v, "annotation"));
124 }
125
126 static int
load_val(sqlite3 * db,struct pkg * pkg,const char * sql,unsigned flags,int (* pkg_adddata)(struct pkg * pkg,const char * data),int list)127 load_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,
128 int (*pkg_adddata)(struct pkg *pkg, const char *data), int list)
129 {
130 sqlite3_stmt *stmt;
131 int ret;
132
133 assert(db != NULL && pkg != NULL);
134
135 if (pkg->flags & flags)
136 return (EPKG_OK);
137
138 if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
139 ERROR_SQLITE(db, sql);
140 return (EPKG_FATAL);
141 }
142
143 sqlite3_bind_int64(stmt, 1, pkg->id);
144 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
145
146 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
147 pkg_adddata(pkg, sqlite3_column_text(stmt, 0));
148 }
149
150 if (ret != SQLITE_DONE) {
151 if (list != -1)
152 pkg_list_free(pkg, list);
153 ERROR_STMT_SQLITE(db, stmt);
154 sqlite3_finalize(stmt);
155 return (EPKG_FATAL);
156 }
157 sqlite3_finalize(stmt);
158
159 pkg->flags |= flags;
160 return (EPKG_OK);
161 }
162
163 static int
load_tag_val(sqlite3 * db,struct pkg * pkg,const char * sql,unsigned flags,int (* pkg_addtagval)(struct pkg * pkg,const char * tag,const char * val),int list)164 load_tag_val(sqlite3 *db, struct pkg *pkg, const char *sql, unsigned flags,
165 int (*pkg_addtagval)(struct pkg *pkg, const char *tag, const char *val),
166 int list)
167 {
168 sqlite3_stmt *stmt;
169 int ret;
170
171 assert(db != NULL && pkg != NULL);
172
173 if (pkg->flags & flags)
174 return (EPKG_OK);
175
176 if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK) {
177 ERROR_SQLITE(db, sql);
178 return (EPKG_FATAL);
179 }
180
181 sqlite3_bind_int64(stmt, 1, pkg->id);
182 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
183
184 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
185 pkg_addtagval(pkg, sqlite3_column_text(stmt, 0),
186 sqlite3_column_text(stmt, 1));
187 }
188
189 if (ret != SQLITE_DONE) {
190 if (list != -1)
191 pkg_list_free(pkg, list);
192 ERROR_STMT_SQLITE(db, stmt);
193 sqlite3_finalize(stmt);
194 return (EPKG_FATAL);
195 }
196 sqlite3_finalize(stmt);
197
198 pkg->flags |= flags;
199 return (EPKG_OK);
200 }
201
202 static int
compare_column_func(const void * pkey,const void * pcolumn)203 compare_column_func(const void *pkey, const void *pcolumn)
204 {
205 const char *key = (const char*)pkey;
206 const struct column_mapping *column =
207 (const struct column_mapping*)pcolumn;
208
209 return strcmp(key, column->name);
210 }
211
212 static int
pkgdb_load_deps(sqlite3 * sqlite,struct pkg * pkg)213 pkgdb_load_deps(sqlite3 *sqlite, struct pkg *pkg)
214 {
215 sqlite3_stmt *stmt = NULL, *opt_stmt = NULL;
216 int ret = EPKG_OK;
217 struct pkg_dep *chain = NULL;
218 struct pkg_dep_formula *f;
219 struct pkg_dep_formula_item *fit;
220 struct pkg_dep_option_item *optit;
221 bool options_match;
222 char *formula_sql, *clause;
223 const char sql[] = ""
224 "SELECT DISTINCT d.name, d.origin, p.version, 0"
225 " FROM deps AS d"
226 " LEFT JOIN packages AS p ON"
227 " (p.origin = d.origin AND p.name = d.name)"
228 " WHERE d.package_id = ?1"
229 " ORDER BY d.origin DESC";
230 const char formula_preamble[] = ""
231 "SELECT id,name,origin,version,locked FROM packages WHERE ";
232 const char options_sql[] = ""
233 "SELECT option, value"
234 " FROM option"
235 " JOIN pkg_option USING(option_id)"
236 " WHERE package_id = ?1"
237 " ORDER BY option";
238
239 assert(pkg != NULL);
240
241 if (pkg->flags & PKG_LOAD_DEPS)
242 return (EPKG_OK);
243
244
245 ret = sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL);
246
247 if (ret != SQLITE_OK) {
248 ERROR_SQLITE(sqlite, sql);
249 return (EPKG_FATAL);
250 }
251
252 sqlite3_bind_int64(stmt, 1, pkg->id);
253 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
254
255 /* XXX: why we used locked here ? */
256 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
257 pkg_adddep(pkg, sqlite3_column_text(stmt, 0),
258 sqlite3_column_text(stmt, 1),
259 sqlite3_column_text(stmt, 2),
260 sqlite3_column_int64(stmt, 3));
261 }
262
263 if (ret != SQLITE_DONE) {
264 pkg_list_free(pkg, PKG_DEPS);
265 ERROR_STMT_SQLITE(sqlite, stmt);
266 sqlite3_finalize(stmt);
267 return (EPKG_FATAL);
268 }
269 sqlite3_finalize(stmt);
270
271 if (pkg->dep_formula) {
272 pkg_debug(4, "Pkgdb: reading package formula '%s'", pkg->dep_formula);
273
274 f = pkg_deps_parse_formula (pkg->dep_formula);
275
276 if (f != NULL) {
277 DL_FOREACH(f->items, fit) {
278 clause = pkg_deps_formula_tosql(fit);
279
280 if (clause) {
281 xasprintf(&formula_sql, "%s%s", formula_preamble, clause);
282 pkg_debug(4, "Pkgdb: running '%s'", sql);
283 ret = sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL);
284
285 if (ret != SQLITE_OK) {
286 ERROR_SQLITE(sqlite, sql);
287 free(clause);
288 free(formula_sql);
289 pkg_deps_formula_free(f);
290 return (EPKG_FATAL);
291 }
292
293 /* Fetch matching packages */
294 chain = NULL;
295
296 while (sqlite3_step(stmt) == SQLITE_ROW) {
297 /*
298 * Load options for a package and check
299 * if they are compatible
300 */
301 options_match = true;
302
303 if (fit->options) {
304 pkg_debug(4, "Pkgdb: running '%s'", options_sql);
305 if (sqlite3_prepare_v2(sqlite, options_sql, -1,
306 &opt_stmt, NULL) != SQLITE_OK) {
307 ERROR_SQLITE(sqlite, options_sql);
308 return (EPKG_FATAL);
309 }
310
311 sqlite3_bind_int64(opt_stmt, 1,
312 sqlite3_column_int64(stmt, 0));
313
314 while (sqlite3_step(opt_stmt) == SQLITE_ROW) {
315 DL_FOREACH(fit->options, optit) {
316 if(strcmp(optit->opt,
317 sqlite3_column_text(opt_stmt, 0))
318 == 0) {
319 if ((strcmp(
320 sqlite3_column_text(opt_stmt, 1),
321 "on") && !optit->on)
322 || (strcmp(
323 sqlite3_column_text(opt_stmt, 1),
324 "off") && optit->on)) {
325 pkg_debug(4, "incompatible option for"
326 "%s: %s",
327 sqlite3_column_text(opt_stmt, 1),
328 optit->opt);
329 options_match = false;
330 break;
331 }
332 }
333 }
334 }
335
336 sqlite3_finalize(opt_stmt);
337 }
338
339 if (options_match) {
340 chain = pkg_adddep_chain(chain, pkg,
341 sqlite3_column_text(stmt, 1),
342 sqlite3_column_text(stmt, 2),
343 sqlite3_column_text(stmt, 3),
344 sqlite3_column_int64(stmt, 4));
345 }
346 }
347
348 free(clause);
349 free(formula_sql);
350 sqlite3_finalize(stmt);
351 }
352
353 }
354
355 pkg_deps_formula_free(f);
356 }
357 }
358
359 pkg->flags |= PKG_LOAD_DEPS;
360 return (EPKG_OK);
361 }
362
363 static int
pkgdb_load_rdeps(sqlite3 * sqlite,struct pkg * pkg)364 pkgdb_load_rdeps(sqlite3 *sqlite, struct pkg *pkg)
365 {
366 sqlite3_stmt *stmt = NULL;
367 int ret;
368 const char sql[] = ""
369 "SELECT p.name, p.origin, p.version, 0"
370 " FROM packages AS p"
371 " INNER JOIN deps AS d ON (p.id = d.package_id)"
372 " WHERE d.name = ?1";
373
374 assert(pkg != NULL);
375
376 if (pkg->flags & PKG_LOAD_RDEPS)
377 return (EPKG_OK);
378
379
380 ret = sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL);
381
382 if (ret != SQLITE_OK) {
383 ERROR_SQLITE(sqlite, sql);
384 return (EPKG_FATAL);
385 }
386
387 sqlite3_bind_text(stmt, 1, pkg->uid, -1, SQLITE_STATIC);
388 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
389
390 /* XXX: why we used locked here ? */
391 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
392 pkg_addrdep(pkg, sqlite3_column_text(stmt, 0),
393 sqlite3_column_text(stmt, 1),
394 sqlite3_column_text(stmt, 2),
395 sqlite3_column_int64(stmt, 3));
396 }
397
398 if (ret != SQLITE_DONE) {
399 pkg_list_free(pkg, PKG_RDEPS);
400 ERROR_STMT_SQLITE(sqlite, stmt);
401 sqlite3_finalize(stmt);
402 return (EPKG_FATAL);
403 }
404 sqlite3_finalize(stmt);
405
406 pkg->flags |= PKG_LOAD_RDEPS;
407 return (EPKG_OK);
408 }
409
410 static int
pkgdb_load_files(sqlite3 * sqlite,struct pkg * pkg)411 pkgdb_load_files(sqlite3 *sqlite, struct pkg *pkg)
412 {
413 sqlite3_stmt *stmt = NULL;
414 int ret;
415 const char sql[] = ""
416 "SELECT path, sha256"
417 " FROM files"
418 " WHERE package_id = ?1"
419 " ORDER BY PATH ASC";
420 const char sql2[] = ""
421 "SELECT path, content"
422 " FROM config_files"
423 " WHERE package_id = ?1"
424 " ORDER BY PATH ASC";
425
426 assert( pkg != NULL);
427 assert(pkg->type == PKG_INSTALLED);
428
429 if (pkg->flags & PKG_LOAD_FILES)
430 return (EPKG_OK);
431
432 if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
433 ERROR_SQLITE(sqlite, sql);
434 return (EPKG_FATAL);
435 }
436
437 sqlite3_bind_int64(stmt, 1, pkg->id);
438 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
439
440 while (sqlite3_step(stmt) == SQLITE_ROW) {
441 pkg_addfile(pkg, sqlite3_column_text(stmt, 0),
442 sqlite3_column_text(stmt, 1), false);
443 }
444 sqlite3_finalize(stmt);
445
446 if (sqlite3_prepare_v2(sqlite, sql2, -1, &stmt, NULL) != SQLITE_OK) {
447 ERROR_SQLITE(sqlite, sql2);
448 return (EPKG_FATAL);
449 }
450
451 sqlite3_bind_int64(stmt, 1, pkg->id);
452 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
453
454 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
455 pkg_addconfig_file(pkg, sqlite3_column_text(stmt, 0),
456 sqlite3_column_text(stmt, 1));
457 }
458
459 if (ret != SQLITE_DONE) {
460 pkg_list_free(pkg, PKG_FILES);
461 ERROR_STMT_SQLITE(sqlite, stmt);
462 sqlite3_finalize(stmt);
463 return (EPKG_FATAL);
464 }
465 sqlite3_finalize(stmt);
466
467 pkg->flags |= PKG_LOAD_FILES;
468 return (EPKG_OK);
469 }
470
471 static int
pkgdb_load_dirs(sqlite3 * sqlite,struct pkg * pkg)472 pkgdb_load_dirs(sqlite3 *sqlite, struct pkg *pkg)
473 {
474 const char sql[] = ""
475 "SELECT path, try"
476 " FROM pkg_directories, directories"
477 " WHERE package_id = ?1"
478 " AND directory_id = directories.id"
479 " ORDER by path DESC";
480 sqlite3_stmt *stmt;
481 int ret;
482
483 assert(pkg != NULL);
484 assert(pkg->type == PKG_INSTALLED);
485
486 if (pkg->flags & PKG_LOAD_DIRS)
487 return (EPKG_OK);
488
489 if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
490 ERROR_SQLITE(sqlite, sql);
491 return (EPKG_FATAL);
492 }
493
494 sqlite3_bind_int64(stmt, 1, pkg->id);
495 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
496
497 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
498 pkg_adddir(pkg, sqlite3_column_text(stmt, 0), false);
499 }
500
501 if (ret != SQLITE_DONE) {
502 pkg_list_free(pkg, PKG_DIRS);
503 ERROR_STMT_SQLITE(sqlite, stmt);
504 sqlite3_finalize(stmt);
505 return (EPKG_FATAL);
506 }
507 sqlite3_finalize(stmt);
508
509 pkg->flags |= PKG_LOAD_DIRS;
510
511 return (EPKG_OK);
512 }
513
514 static int
pkgdb_load_license(sqlite3 * sqlite,struct pkg * pkg)515 pkgdb_load_license(sqlite3 *sqlite, struct pkg *pkg)
516 {
517 const char sql[] = ""
518 "SELECT ifnull(group_concat(name, ', '), '') AS name"
519 " FROM pkg_licenses, licenses AS l"
520 " WHERE package_id = ?1"
521 " AND license_id = l.id"
522 " ORDER by name DESC";
523
524 assert(pkg != NULL);
525
526 return (load_val(sqlite, pkg, sql, PKG_LOAD_LICENSES,
527 pkg_addlicense, PKG_LICENSES));
528 }
529
530 static int
pkgdb_load_category(sqlite3 * sqlite,struct pkg * pkg)531 pkgdb_load_category(sqlite3 *sqlite, struct pkg *pkg)
532 {
533 const char sql[] = ""
534 "SELECT name"
535 " FROM pkg_categories, categories AS c"
536 " WHERE package_id = ?1"
537 " AND category_id = c.id"
538 " ORDER by name DESC";
539
540 assert(pkg != NULL);
541
542 return (load_val(sqlite, pkg, sql, PKG_LOAD_CATEGORIES,
543 pkg_addcategory, PKG_CATEGORIES));
544 }
545
546 static int
pkgdb_load_user(sqlite3 * sqlite,struct pkg * pkg)547 pkgdb_load_user(sqlite3 *sqlite, struct pkg *pkg)
548 {
549 int ret;
550 const char sql[] = ""
551 "SELECT users.name"
552 " FROM pkg_users, users"
553 " WHERE package_id = ?1"
554 " AND user_id = users.id"
555 " ORDER by name DESC";
556
557 assert(pkg != NULL);
558 assert(pkg->type == PKG_INSTALLED);
559
560 ret = load_val(sqlite, pkg, sql, PKG_LOAD_USERS,
561 pkg_adduser, PKG_USERS);
562
563 return (ret);
564 }
565
566 static int
pkgdb_load_group(sqlite3 * sqlite,struct pkg * pkg)567 pkgdb_load_group(sqlite3 *sqlite, struct pkg *pkg)
568 {
569 int ret;
570 const char sql[] = ""
571 "SELECT groups.name"
572 " FROM pkg_groups, groups"
573 " WHERE package_id = ?1"
574 " AND group_id = groups.id"
575 " ORDER by name DESC";
576
577 assert(pkg != NULL);
578 assert(pkg->type == PKG_INSTALLED);
579
580 ret = load_val(sqlite, pkg, sql, PKG_LOAD_GROUPS,
581 pkg_addgroup, PKG_GROUPS);
582
583 return (ret);
584 }
585
586 static int
pkgdb_load_shlib_required(sqlite3 * sqlite,struct pkg * pkg)587 pkgdb_load_shlib_required(sqlite3 *sqlite, struct pkg *pkg)
588 {
589 const char sql[] = ""
590 "SELECT name"
591 " FROM pkg_shlibs_required, shlibs AS s"
592 " WHERE package_id = ?1"
593 " AND shlib_id = s.id"
594 " ORDER by name DESC";
595
596 assert(pkg != NULL);
597
598 return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_REQUIRED,
599 pkg_addshlib_required, PKG_SHLIBS_REQUIRED));
600 }
601
602
603 static int
pkgdb_load_shlib_provided(sqlite3 * sqlite,struct pkg * pkg)604 pkgdb_load_shlib_provided(sqlite3 *sqlite, struct pkg *pkg)
605 {
606 const char sql[] = ""
607 "SELECT name"
608 " FROM pkg_shlibs_provided, shlibs AS s"
609 " WHERE package_id = ?1"
610 " AND shlib_id = s.id"
611 " ORDER by name DESC";
612
613 assert(pkg != NULL);
614
615 return (load_val(sqlite, pkg, sql, PKG_LOAD_SHLIBS_PROVIDED,
616 pkg_addshlib_provided, PKG_SHLIBS_PROVIDED));
617 }
618
619 static int
pkgdb_load_annotations(sqlite3 * sqlite,struct pkg * pkg)620 pkgdb_load_annotations(sqlite3 *sqlite, struct pkg *pkg)
621 {
622 const char sql[] = ""
623 "SELECT k.annotation AS tag, v.annotation AS value"
624 " FROM pkg_annotation p"
625 " JOIN annotation k ON (p.tag_id = k.annotation_id)"
626 " JOIN annotation v ON (p.value_id = v.annotation_id)"
627 " WHERE p.package_id = ?1"
628 " ORDER BY tag, value";
629
630 return (load_tag_val(sqlite, pkg, sql, PKG_LOAD_ANNOTATIONS,
631 pkg_addannotation, PKG_ANNOTATIONS));
632 }
633
634 static int
pkgdb_load_lua_scripts(sqlite3 * sqlite,struct pkg * pkg)635 pkgdb_load_lua_scripts(sqlite3 *sqlite, struct pkg *pkg)
636 {
637 sqlite3_stmt *stmt = NULL;
638 int ret;
639 const char sql[] = ""
640 "SELECT lua_script, type"
641 " FROM lua_script"
642 " JOIN pkg_lua_script USING(lua_script_id)"
643 " WHERE package_id = ?1";
644
645 assert(pkg != NULL);
646 assert(pkg->type == PKG_INSTALLED);
647
648 if (pkg->flags & PKG_LOAD_LUA_SCRIPTS)
649 return (EPKG_OK);
650
651 if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
652 ERROR_SQLITE(sqlite, sql);
653 return (EPKG_FATAL);
654 }
655
656 sqlite3_bind_int64(stmt, 1, pkg->id);
657 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
658
659 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
660 pkg_add_lua_script(pkg, sqlite3_column_text(stmt, 0),
661 sqlite3_column_int64(stmt, 1));
662 }
663
664 if (ret != SQLITE_DONE) {
665 ERROR_STMT_SQLITE(sqlite, stmt);
666 sqlite3_finalize(stmt);
667 return (EPKG_FATAL);
668 }
669 sqlite3_finalize(stmt);
670
671 pkg->flags |= PKG_LOAD_LUA_SCRIPTS;
672 return (EPKG_OK);
673 }
674
675 static int
pkgdb_load_scripts(sqlite3 * sqlite,struct pkg * pkg)676 pkgdb_load_scripts(sqlite3 *sqlite, struct pkg *pkg)
677 {
678 sqlite3_stmt *stmt = NULL;
679 int ret;
680 const char sql[] = ""
681 "SELECT script, type"
682 " FROM pkg_script"
683 " JOIN script USING(script_id)"
684 " WHERE package_id = ?1";
685
686 assert(pkg != NULL);
687 assert(pkg->type == PKG_INSTALLED);
688
689 if (pkg->flags & PKG_LOAD_SCRIPTS)
690 return (EPKG_OK);
691
692 if (sqlite3_prepare_v2(sqlite, sql, -1, &stmt, NULL) != SQLITE_OK) {
693 ERROR_SQLITE(sqlite, sql);
694 return (EPKG_FATAL);
695 }
696
697 sqlite3_bind_int64(stmt, 1, pkg->id);
698 pkg_debug(4, "Pkgdb: running '%s'", sqlite3_expanded_sql(stmt));
699
700 while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
701 pkg_addscript(pkg, sqlite3_column_text(stmt, 0),
702 sqlite3_column_int64(stmt, 1));
703 }
704
705 if (ret != SQLITE_DONE) {
706 ERROR_STMT_SQLITE(sqlite, stmt);
707 sqlite3_finalize(stmt);
708 return (EPKG_FATAL);
709 }
710 sqlite3_finalize(stmt);
711
712 pkg->flags |= PKG_LOAD_SCRIPTS;
713 return (EPKG_OK);
714 }
715
716
717 static int
pkgdb_load_options(sqlite3 * sqlite,struct pkg * pkg)718 pkgdb_load_options(sqlite3 *sqlite, struct pkg *pkg)
719 {
720 unsigned int i;
721
722 struct optionsql {
723 const char *sql;
724 int (*pkg_addtagval)(struct pkg *pkg,
725 const char *tag,
726 const char *val);
727 } optionsql[] = {
728 {
729 "SELECT option, value"
730 " FROM option"
731 " JOIN pkg_option USING(option_id)"
732 " WHERE package_id = ?1"
733 " ORDER BY option",
734 pkg_addoption,
735 },
736 {
737 "SELECT option, default_value"
738 " FROM option"
739 " JOIN pkg_option_default USING(option_id)"
740 " WHERE package_id = ?1"
741 " ORDER BY option",
742 pkg_addoption_default,
743 },
744 {
745 "SELECT option, description"
746 " FROM option"
747 " JOIN pkg_option_desc USING(option_id)"
748 " JOIN option_desc USING(option_desc_id)"
749 " WHERE package_id = ?1"
750 " ORDER BY option",
751 pkg_addoption_description,
752 }
753 };
754 const char *opt_sql;
755 int (*pkg_addtagval)(struct pkg *pkg,
756 const char *tag,
757 const char *val);
758 int ret;
759
760 assert(pkg != NULL);
761
762 if (pkg->flags & PKG_LOAD_OPTIONS)
763 return (EPKG_OK);
764
765
766 for (i = 0; i < NELEM(optionsql); i++) {
767 opt_sql = optionsql[i].sql;
768 pkg_addtagval = optionsql[i].pkg_addtagval;
769
770 pkg_debug(4, "Pkgdb> adding option");
771 ret = load_tag_val(sqlite, pkg, opt_sql, PKG_LOAD_OPTIONS,
772 pkg_addtagval, PKG_OPTIONS);
773 if (ret != EPKG_OK)
774 break;
775 }
776 return (ret);
777 }
778
779 static int
pkgdb_load_conflicts(sqlite3 * sqlite,struct pkg * pkg)780 pkgdb_load_conflicts(sqlite3 *sqlite, struct pkg *pkg)
781 {
782 const char sql[] = ""
783 "SELECT packages.name"
784 " FROM pkg_conflicts"
785 " LEFT JOIN packages ON"
786 " (packages.id = pkg_conflicts.conflict_id)"
787 " WHERE package_id = ?1";
788
789 assert(pkg != NULL);
790
791 return (load_val(sqlite, pkg, sql, PKG_LOAD_CONFLICTS,
792 pkg_addconflict, PKG_CONFLICTS));
793 }
794
795 static int
pkgdb_load_provides(sqlite3 * sqlite,struct pkg * pkg)796 pkgdb_load_provides(sqlite3 *sqlite, struct pkg *pkg)
797 {
798 const char sql[] = ""
799 "SELECT provide"
800 " FROM pkg_provides, provides AS s"
801 " WHERE package_id = ?1"
802 " AND provide_id = s.id"
803 " ORDER by provide DESC";
804
805 assert(pkg != NULL);
806
807 return (load_val(sqlite, pkg, sql, PKG_LOAD_PROVIDES,
808 pkg_addprovide, PKG_PROVIDES));
809 }
810
811 static int
pkgdb_load_requires(sqlite3 * sqlite,struct pkg * pkg)812 pkgdb_load_requires(sqlite3 *sqlite, struct pkg *pkg)
813 {
814 const char sql[] = ""
815 "SELECT require"
816 " FROM pkg_requires, requires AS s"
817 " WHERE package_id = ?1"
818 " AND require_id = s.id"
819 " ORDER by require DESC";
820
821 assert(pkg != NULL);
822
823 return (load_val(sqlite, pkg, sql, PKG_LOAD_REQUIRES,
824 pkg_addrequire, PKG_REQUIRES));
825 }
826
827 static void
populate_pkg(sqlite3_stmt * stmt,struct pkg * pkg)828 populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {
829 int icol = 0;
830 const char *colname, *msg;
831 char legacyarch[BUFSIZ];
832
833 assert(stmt != NULL);
834
835 for (icol = 0; icol < sqlite3_column_count(stmt); icol++) {
836 colname = sqlite3_column_name(stmt, icol);
837 struct column_mapping *column;
838 switch (sqlite3_column_type(stmt, icol)) {
839 case SQLITE_TEXT:
840 column = bsearch(colname, columns, NELEM(columns) - 1,
841 sizeof(columns[0]), compare_column_func);
842 if (column == NULL) {
843 pkg_emit_error("unknown column %s", colname);
844 continue;
845 }
846
847 switch (column->type) {
848 case PKG_ABI:
849 pkg->abi = xstrdup(sqlite3_column_text(stmt, icol));
850 break;
851 case PKG_CKSUM:
852 pkg->sum = xstrdup(sqlite3_column_text(stmt, icol));
853 break;
854 case PKG_COMMENT:
855 pkg->comment = xstrdup(sqlite3_column_text(stmt, icol));
856 break;
857 case PKG_REPONAME:
858 pkg->reponame = xstrdup(sqlite3_column_text(stmt, icol));
859 break;
860 case PKG_DESC:
861 pkg->desc = xstrdup(sqlite3_column_text(stmt, icol));
862 break;
863 case PKG_MAINTAINER:
864 pkg->maintainer = xstrdup(sqlite3_column_text(stmt, icol));
865 break;
866 case PKG_DIGEST:
867 pkg->digest = xstrdup(sqlite3_column_text(stmt, icol));
868 break;
869 case PKG_MESSAGE:
870 msg = sqlite3_column_text(stmt, icol);
871 if (msg) {
872 /* A stupid logic to detect legacy pkg message */
873 if (msg[0] == '[') {
874 pkg_message_from_str(pkg, msg, 0);
875 }
876 else {
877 struct pkg_message *message;
878 message = xcalloc(1, sizeof(*pkg->message));
879 message->str = xstrdup(msg);
880 DL_APPEND(pkg->message, message);
881 }
882 }
883 else {
884 pkg->message = NULL;
885 }
886 break;
887 case PKG_NAME:
888 pkg->name = xstrdup(sqlite3_column_text(stmt, icol));
889 break;
890 case PKG_OLD_VERSION:
891 pkg->old_version = xstrdup(sqlite3_column_text(stmt, icol));
892 break;
893 case PKG_ORIGIN:
894 pkg->origin = xstrdup(sqlite3_column_text(stmt, icol));
895 break;
896 case PKG_PREFIX:
897 pkg->prefix = xstrdup(sqlite3_column_text(stmt, icol));
898 break;
899 case PKG_REPOPATH:
900 pkg->repopath = xstrdup(sqlite3_column_text(stmt, icol));
901 break;
902 case PKG_REPOURL:
903 pkg->repourl = xstrdup(sqlite3_column_text(stmt, icol));
904 break;
905 case PKG_UNIQUEID:
906 pkg->uid = xstrdup(sqlite3_column_text(stmt, icol));
907 break;
908 case PKG_VERSION:
909 pkg->version = xstrdup(sqlite3_column_text(stmt, icol));
910 break;
911 case PKG_WWW:
912 pkg->www = xstrdup(sqlite3_column_text(stmt, icol));
913 break;
914 case PKG_DEP_FORMULA:
915 pkg->dep_formula = xstrdup(sqlite3_column_text(stmt, icol));
916 break;
917 default:
918 pkg_emit_error("Unexpected text value for %s", colname);
919 break;
920 }
921 break;
922 case SQLITE_INTEGER:
923 column = bsearch(colname, columns, NELEM(columns) - 1,
924 sizeof(columns[0]), compare_column_func);
925 if (column == NULL) {
926 pkg_emit_error("Unknown column %s", colname);
927 continue;
928 }
929
930 switch (column->type) {
931 case PKG_AUTOMATIC:
932 pkg->automatic = (bool)sqlite3_column_int64(stmt, icol);
933 break;
934 case PKG_LOCKED:
935 pkg->locked = (bool)sqlite3_column_int64(stmt, icol);
936 break;
937 case PKG_FLATSIZE:
938 pkg->flatsize = sqlite3_column_int64(stmt, icol);
939 break;
940 case PKG_ROWID:
941 pkg->id = sqlite3_column_int64(stmt, icol);
942 break;
943 case PKG_LICENSE_LOGIC:
944 pkg->licenselogic = (lic_t)sqlite3_column_int64(stmt, icol);
945 break;
946 case PKG_OLD_FLATSIZE:
947 pkg->old_flatsize = sqlite3_column_int64(stmt, icol);
948 break;
949 case PKG_PKGSIZE:
950 pkg->pkgsize = sqlite3_column_int64(stmt, icol);
951 break;
952 case PKG_VITAL:
953 pkg->vital = (bool)sqlite3_column_int64(stmt, icol);
954 break;
955 case PKG_TIME:
956 pkg->timestamp = sqlite3_column_int64(stmt, icol);
957 break;
958 default:
959 pkg_emit_error("Unexpected integer value for %s", colname);
960 break;
961 }
962 break;
963 case SQLITE_BLOB:
964 case SQLITE_FLOAT:
965 pkg_emit_error("wrong type for column: %s",
966 colname);
967 /* just ignore currently */
968 break;
969 case SQLITE_NULL:
970 break;
971 }
972 }
973
974 pkg_arch_to_legacy(pkg->abi, legacyarch, BUFSIZ);
975 pkg->arch = xstrdup(legacyarch);
976 }
977
978 static struct load_on_flag {
979 int flag;
980 int (*load)(sqlite3 *sqlite, struct pkg *p);
981 } load_on_flag[] = {
982 { PKG_LOAD_DEPS, pkgdb_load_deps },
983 { PKG_LOAD_RDEPS, pkgdb_load_rdeps },
984 { PKG_LOAD_FILES, pkgdb_load_files },
985 { PKG_LOAD_DIRS, pkgdb_load_dirs },
986 { PKG_LOAD_SCRIPTS, pkgdb_load_scripts },
987 { PKG_LOAD_OPTIONS, pkgdb_load_options },
988 { PKG_LOAD_CATEGORIES, pkgdb_load_category },
989 { PKG_LOAD_LICENSES, pkgdb_load_license },
990 { PKG_LOAD_USERS, pkgdb_load_user },
991 { PKG_LOAD_GROUPS, pkgdb_load_group },
992 { PKG_LOAD_SHLIBS_REQUIRED, pkgdb_load_shlib_required },
993 { PKG_LOAD_SHLIBS_PROVIDED, pkgdb_load_shlib_provided },
994 { PKG_LOAD_ANNOTATIONS, pkgdb_load_annotations },
995 { PKG_LOAD_CONFLICTS, pkgdb_load_conflicts },
996 { PKG_LOAD_PROVIDES, pkgdb_load_provides },
997 { PKG_LOAD_REQUIRES, pkgdb_load_requires },
998 { PKG_LOAD_LUA_SCRIPTS, pkgdb_load_lua_scripts },
999 { -1, NULL }
1000 };
1001
1002 static void
pkgdb_sqlite_it_reset(struct pkgdb_sqlite_it * it)1003 pkgdb_sqlite_it_reset(struct pkgdb_sqlite_it *it)
1004 {
1005 if (it == NULL)
1006 return;
1007
1008 it->finished = 0;
1009 sqlite3_reset(it->stmt);
1010 }
1011
1012 static void
pkgdb_sqlite_it_free(struct pkgdb_sqlite_it * it)1013 pkgdb_sqlite_it_free(struct pkgdb_sqlite_it *it)
1014 {
1015 if (it == NULL)
1016 return;
1017
1018 sqlite3_finalize(it->stmt);
1019 }
1020
1021 static int
pkgdb_sqlite_it_next(struct pkgdb_sqlite_it * it,struct pkg ** pkg_p,unsigned flags)1022 pkgdb_sqlite_it_next(struct pkgdb_sqlite_it *it,
1023 struct pkg **pkg_p, unsigned flags)
1024 {
1025 struct pkg *pkg;
1026 int i;
1027 int ret;
1028
1029 assert(it != NULL);
1030
1031 /*
1032 * XXX:
1033 * Currently, we have a lot of issues related to pkg digests.
1034 * So we want to ensure that we always have a valid package digest
1035 * even if we work with pkg 1.2 repo. Therefore, we explicitly check
1036 * manifest digests and set it to NULL if it is invalid.
1037 *
1038 */
1039
1040 if (it->finished && (it->flags & PKGDB_IT_FLAG_ONCE))
1041 return (EPKG_END);
1042
1043 switch (sqlite3_step(it->stmt)) {
1044 case SQLITE_ROW:
1045 pkg_free(*pkg_p);
1046 ret = pkg_new(pkg_p, it->pkg_type);
1047 if (ret != EPKG_OK)
1048 return (ret);
1049 pkg = *pkg_p;
1050
1051 populate_pkg(it->stmt, pkg);
1052
1053 if (pkg->digest != NULL && !pkg_checksum_is_valid(pkg->digest, strlen(pkg->digest))) {
1054 free(pkg->digest);
1055 pkg->digest = NULL;
1056 }
1057
1058 for (i = 0; load_on_flag[i].load != NULL; i++) {
1059 if (flags & load_on_flag[i].flag) {
1060 if (it->sqlite != NULL) {
1061 ret = load_on_flag[i].load(it->sqlite, pkg);
1062 if (ret != EPKG_OK)
1063 return (ret);
1064 }
1065 else {
1066 pkg_emit_error("invalid iterator passed to pkgdb_it_next");
1067 return (EPKG_FATAL);
1068 }
1069 }
1070 }
1071
1072 return (EPKG_OK);
1073 case SQLITE_DONE:
1074 it->finished ++;
1075 if (it->flags & PKGDB_IT_FLAG_CYCLED) {
1076 sqlite3_reset(it->stmt);
1077 return (EPKG_OK);
1078 }
1079 else {
1080 if (it->flags & PKGDB_IT_FLAG_AUTO)
1081 pkgdb_sqlite_it_free(it);
1082 return (EPKG_END);
1083 }
1084 break;
1085 default:
1086 ERROR_SQLITE(it->sqlite, "iterator");
1087 return (EPKG_FATAL);
1088 }
1089 }
1090
1091 int
pkgdb_it_next(struct pkgdb_it * it,struct pkg ** pkg_p,unsigned flags)1092 pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, unsigned flags)
1093 {
1094 struct pkg_repo_it *rit;
1095 int ret;
1096
1097 assert(it != NULL);
1098
1099 switch (it->type) {
1100 case PKGDB_IT_LOCAL:
1101 return (pkgdb_sqlite_it_next(&it->un.local, pkg_p, flags));
1102 break;
1103 case PKGDB_IT_REPO:
1104 if (it->un.remote != NULL) {
1105 rit = it->un.remote->it;
1106 ret = rit->ops->next(rit, pkg_p, flags);
1107 if (ret != EPKG_OK) {
1108 /*
1109 * Detach this iterator from list and switch to another
1110 */
1111 struct _pkg_repo_it_set *tmp;
1112
1113 rit->ops->free(rit);
1114 tmp = it->un.remote;
1115 it->un.remote = tmp->next;
1116 free(tmp);
1117
1118 return (pkgdb_it_next(it, pkg_p, flags));
1119 }
1120
1121 if (*pkg_p != NULL)
1122 (*pkg_p)->repo = rit->repo;
1123
1124 return (EPKG_OK);
1125 }
1126 /*
1127 * All done
1128 */
1129 return (EPKG_END);
1130 break;
1131 }
1132
1133 return (EPKG_FATAL);
1134 }
1135
1136 int
pkgdb_it_count(struct pkgdb_it * it)1137 pkgdb_it_count(struct pkgdb_it *it)
1138 {
1139 int i;
1140 int ret;
1141 struct pkgdb_sqlite_it *sit;
1142
1143 assert(it != NULL);
1144
1145 i = 0;
1146 sit = &it->un.local;
1147
1148 if (sit == NULL)
1149 return (0);
1150
1151 while ((ret = sqlite3_step(sit->stmt))) {
1152 switch (ret) {
1153 case SQLITE_ROW:
1154 ++i;
1155 break;
1156 case SQLITE_DONE:
1157 goto done;
1158 default:
1159 ERROR_SQLITE(sit->sqlite, "iterator");
1160 return (-1);
1161 }
1162 }
1163
1164 done:
1165 pkgdb_it_reset(it);
1166 return (i);
1167 }
1168
1169 void
pkgdb_it_reset(struct pkgdb_it * it)1170 pkgdb_it_reset(struct pkgdb_it *it)
1171 {
1172 struct _pkg_repo_it_set *cur;
1173
1174 assert(it != NULL);
1175
1176 switch (it->type) {
1177 case PKGDB_IT_LOCAL:
1178 pkgdb_sqlite_it_reset(&it->un.local);
1179 break;
1180 case PKGDB_IT_REPO:
1181 LL_FOREACH(it->un.remote, cur) {
1182 cur->it->ops->reset(cur->it);
1183 }
1184 break;
1185 }
1186 }
1187
1188 void
pkgdb_it_free(struct pkgdb_it * it)1189 pkgdb_it_free(struct pkgdb_it *it)
1190 {
1191 struct _pkg_repo_it_set *cur, *tmp;
1192
1193 if (it == NULL)
1194 return;
1195
1196 switch (it->type) {
1197 case PKGDB_IT_LOCAL:
1198 pkgdb_sqlite_it_free(&it->un.local);
1199 break;
1200 case PKGDB_IT_REPO:
1201 LL_FOREACH_SAFE(it->un.remote, cur, tmp) {
1202 cur->it->ops->free(cur->it);
1203 free(cur);
1204 }
1205 break;
1206 }
1207
1208 free(it);
1209 }
1210
1211 struct pkgdb_it *
pkgdb_it_new_sqlite(struct pkgdb * db,sqlite3_stmt * s,int type,short flags)1212 pkgdb_it_new_sqlite(struct pkgdb *db, sqlite3_stmt *s, int type, short flags)
1213 {
1214 struct pkgdb_it *it;
1215
1216 assert(db != NULL && s != NULL);
1217 assert(!(flags & (PKGDB_IT_FLAG_CYCLED & PKGDB_IT_FLAG_ONCE)));
1218 assert(!(flags & (PKGDB_IT_FLAG_AUTO & (PKGDB_IT_FLAG_CYCLED | PKGDB_IT_FLAG_ONCE))));
1219
1220 it = xmalloc(sizeof(struct pkgdb_it));
1221
1222 it->type = PKGDB_IT_LOCAL;
1223
1224 it->db = db;
1225 it->un.local.sqlite = db->sqlite;
1226 it->un.local.stmt = s;
1227 it->un.local.pkg_type = type;
1228
1229 it->un.local.flags = flags;
1230 it->un.local.finished = 0;
1231
1232 return (it);
1233 }
1234
1235 struct pkgdb_it *
pkgdb_it_new_repo(struct pkgdb * db)1236 pkgdb_it_new_repo(struct pkgdb *db)
1237 {
1238 struct pkgdb_it *it;
1239
1240 it = xmalloc(sizeof(struct pkgdb_it));
1241
1242 it->type = PKGDB_IT_REPO;
1243
1244 it->db = db;
1245
1246 it->un.remote = NULL;
1247
1248 return (it);
1249 }
1250
1251 void
pkgdb_it_repo_attach(struct pkgdb_it * it,struct pkg_repo_it * rit)1252 pkgdb_it_repo_attach(struct pkgdb_it *it, struct pkg_repo_it *rit)
1253 {
1254 struct _pkg_repo_it_set *item;
1255
1256 item = xmalloc(sizeof(struct _pkg_repo_it_set));
1257 item->it = rit;
1258 LL_PREPEND(it->un.remote, item);
1259 }
1260
1261 int
pkgdb_ensure_loaded_sqlite(sqlite3 * sqlite,struct pkg * pkg,unsigned flags)1262 pkgdb_ensure_loaded_sqlite(sqlite3 *sqlite, struct pkg *pkg, unsigned flags)
1263 {
1264 int i, ret;
1265
1266 for (i = 0; load_on_flag[i].load != NULL; i++) {
1267 if (~pkg->flags & flags & load_on_flag[i].flag) {
1268 ret = load_on_flag[i].load(sqlite, pkg);
1269 if (ret != EPKG_OK)
1270 return (ret);
1271 pkg->flags |= load_on_flag[i].flag;
1272 }
1273 }
1274
1275 return (EPKG_OK);
1276 }
1277
1278 int
pkgdb_ensure_loaded(struct pkgdb * db,struct pkg * pkg,unsigned flags)1279 pkgdb_ensure_loaded(struct pkgdb *db, struct pkg *pkg, unsigned flags)
1280 {
1281 int ret;
1282 struct _pkg_repo_list_item *cur;
1283
1284 if (pkg->type == PKG_INSTALLED) {
1285 return (pkgdb_ensure_loaded_sqlite(db->sqlite, pkg, flags));
1286 }
1287 else {
1288 /* Call repo functions */
1289 LL_FOREACH(db->repos, cur) {
1290 if (cur->repo == pkg->repo) {
1291 if (cur->repo->ops->ensure_loaded) {
1292 ret = cur->repo->ops->ensure_loaded(cur->repo, pkg, flags);
1293 return (ret);
1294 }
1295 }
1296 }
1297 }
1298
1299 return (EPKG_FATAL);
1300 }
1301