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