Branch data Line data Source code
1 : : /*-
2 : : * Copyright (c) 2011-2024 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) 2013-2014 Matthew Seaman <matthew@FreeBSD.org>
8 : : * Copyright (c) 2014-2016 Vsevolod Stakhov <vsevolod@FreeBSD.org>
9 : : * Copyright (c) 2023-2024 Serenity Cyber Security, LLC <license@futurecrew.ru>
10 : : * Author: Gleb Popov <arrowd@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 : : #ifndef _PKG_H
36 : : #define _PKG_H
37 : :
38 : : #ifdef __cplusplus
39 : : extern "C" {
40 : : #define restrict
41 : : #endif
42 : :
43 : : #include <sys/types.h>
44 : : #include <sys/param.h>
45 : : #include <stdarg.h>
46 : : #include <stdbool.h>
47 : : #include <stdio.h>
48 : : #include <stdlib.h>
49 : : #include <pkgvec.h>
50 : :
51 : : /* The expected name of the pkg(8) binary executable. */
52 : : #ifndef PKG_EXEC_NAME
53 : : #define PKG_EXEC_NAME "pkg"
54 : : #endif
55 : :
56 : : /* The expected name of the pkg-static(8) binary */
57 : : #ifndef PKG_STATIC_NAME
58 : : #define PKG_STATIC_NAME "pkg-static"
59 : : #endif
60 : :
61 : : #define PKGVERSION "1.21.990.3"
62 : :
63 : : /* PORTVERSION equivalent for proper pkg-static->ports-mgmt/pkg
64 : : * version comparison in pkgdb_query_newpkgversion() */
65 : :
66 : : #define PKG_PORTVERSION "1.21.990.3"
67 : :
68 : : /* The OS major version at the time of compilation */
69 : : #ifdef __FreeBSD__
70 : : #define OSMAJOR __FreeBSD__
71 : : #endif
72 : :
73 : : /* Not supported under DragonFly */
74 : : #ifdef __DragonFly__
75 : : #undef OSMAJOR
76 : : #endif
77 : :
78 : : #ifdef __NetBSD_Version__
79 : : #define OSMAJOR ((__NetBSD_Version__ + 1000000) / 100000000)
80 : : #endif
81 : :
82 : : #ifndef __DECONST
83 : : #define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var))
84 : : #endif
85 : :
86 : : #ifndef NELEM
87 : : #define NELEM(array) (sizeof(array) / sizeof((array)[0]))
88 : : #endif
89 : :
90 : : #ifndef STREQ
91 : : #define STREQ(s1, s2) (strcmp(s1, s2) == 0)
92 : : #endif
93 : :
94 : : #ifndef STRIEQ
95 : : #define STRIEQ(s1, s2) (strcasecmp(s1, s2) == 0)
96 : : #endif
97 : :
98 : : /* Special exit status for worker processes indicating that a restart
99 : : * is desired -- eg. after a child has updated pkg(8) itself.
100 : : */
101 : :
102 : : #define EX_NEEDRESTART 4
103 : :
104 : : struct iovec;
105 : :
106 : : struct pkg;
107 : : struct pkg_dep;
108 : : struct pkg_conflict;
109 : : struct pkg_file;
110 : : struct pkg_dir;
111 : : struct pkg_option;
112 : : struct pkg_license;
113 : : struct pkg_config_file;
114 : : struct pkg_create;
115 : : struct pkg_repo_create;
116 : :
117 : : struct pkgdb;
118 : : struct pkgdb_it;
119 : :
120 : : struct pkg_jobs;
121 : : struct pkg_solve_problem;
122 : :
123 : : struct pkg_key;
124 : :
125 : : struct pkg_repo;
126 : :
127 : : struct pkg_plugin;
128 : :
129 : : struct pkg_manifest_parser;
130 : :
131 : : typedef struct ucl_object_s pkg_object;
132 : : typedef void * pkg_iter;
133 : :
134 : : struct pkg_kv {
135 : : char *key;
136 : : char *value;
137 : : };
138 : :
139 : : typedef pkgvec_t(struct pkg_kv *) pkg_kvl_t;
140 : :
141 : : /**
142 : : * The system-wide pkg(8) status: ie. is it a) installed or otherwise
143 : : * available on the sysem, b) database (local.sqlite) initialised and
144 : : * c) has at least one package installed (which should be pkg
145 : : * itself). PKG_STATUS_UNINSTALLED logically cannot be returned by
146 : : * pkg(8) itself, but it can be useful for the pkg bootstrapper
147 : : * /usr/bin/pkg or for applications that link against libpkg.so
148 : : */
149 : :
150 : : typedef enum {
151 : : PKG_STATUS_ACTIVE = 0, /* pkg in use */
152 : : PKG_STATUS_NOPACKAGES, /* local.sqlite empty */
153 : : PKG_STATUS_NODB, /* local.sqlite not found, unreadable or not initialised */
154 : : PKG_STATUS_UNINSTALLED, /* pkg not argv[0] or not on $PATH */
155 : : } pkg_status_t;
156 : :
157 : : typedef enum {
158 : : /**
159 : : * The license logic is OR (dual in the ports)
160 : : */
161 : : LICENSE_OR = '|',
162 : : /**
163 : : * The license logic is AND (multi in the ports)
164 : : */
165 : : LICENSE_AND = '&',
166 : : /**
167 : : * The license logic un single (default in the ports)
168 : : */
169 : : LICENSE_SINGLE = 1U
170 : : } lic_t;
171 : :
172 : : typedef enum {
173 : : PKGDB_DEFAULT = 0,
174 : : PKGDB_REMOTE,
175 : : PKGDB_MAYBE_REMOTE
176 : : } pkgdb_t;
177 : :
178 : : typedef enum {
179 : : PKG_INIT_FLAG_USE_IPV4 = (1U << 0),
180 : : PKG_INIT_FLAG_USE_IPV6 = (1U << 1)
181 : : } pkg_init_flags;
182 : :
183 : : /**
184 : : * Specify how an argument should be used by query functions.
185 : : */
186 : : typedef enum {
187 : : /**
188 : : * The argument does not matter, all items will be matched.
189 : : */
190 : : MATCH_ALL,
191 : : /**
192 : : * The argument is the exact pattern. Match will be case
193 : : * sensitive or case insensitive according to
194 : : * pkgdb_case_sensitive()
195 : : */
196 : : MATCH_EXACT,
197 : : /**
198 : : * The argument is an exact pattern except that matches will
199 : : * be made case insensitively. Match is always case sensitive
200 : : */
201 : : MATCH_GLOB,
202 : : /**
203 : : * The argument is a regular expression ('modern' style
204 : : * according to re_format(7). Match will be case sensitive or
205 : : * case insensitive according to pkgdb_case_sensitive()
206 : : */
207 : : MATCH_REGEX,
208 : : MATCH_INTERNAL
209 : : } match_t;
210 : :
211 : : /**
212 : : * Specify on which field the pattern will be matched uppon.
213 : : */
214 : :
215 : : typedef enum {
216 : : FIELD_NONE,
217 : : FIELD_ORIGIN,
218 : : FIELD_NAME,
219 : : FIELD_NAMEVER,
220 : : FIELD_COMMENT,
221 : : FIELD_DESC,
222 : : FIELD_FLAVOR,
223 : : } pkgdb_field;
224 : :
225 : : /**
226 : : * The type of package.
227 : : */
228 : : typedef enum {
229 : : /**
230 : : * The pkg type can not be determined.
231 : : */
232 : : PKG_NONE = 0,
233 : :
234 : : /**
235 : : * The pkg refers to a local file archive.
236 : : */
237 : : PKG_FILE = (1U << 0),
238 : : /**
239 : : * The pkg refers to data read from a non-regular file
240 : : * (device, pipeline, unix dmain socket etc.)
241 : : */
242 : : PKG_STREAM = (1U << 1),
243 : : /**
244 : : * The pkg refers to a package available on the remote repository.
245 : : * @todo Document which attributes are available.
246 : : */
247 : : PKG_REMOTE = (1U << 2),
248 : : /**
249 : : * The pkg refers to a localy installed package.
250 : : */
251 : : PKG_INSTALLED = (1U << 3),
252 : : /**
253 : : * The pkg refers to a local file old archive.
254 : : */
255 : : PKG_OLD_FILE = (1U << 4),
256 : : /**
257 : : * The pkg is group available in a remove repository
258 : : */
259 : : PKG_GROUP_REMOTE = (1U << 5),
260 : : /**
261 : : * The pkg refers to an installed group
262 : : */
263 : : PKG_GROUP_INSTALLED = (1U << 6),
264 : : } pkg_t;
265 : :
266 : : /**
267 : : * Contains keys to refer to a string attribute.
268 : : * Used by pkg_get() and pkg_set()
269 : : */
270 : : typedef enum {
271 : : PKG_ATTR_ORIGIN = 1U,
272 : : PKG_ATTR_NAME,
273 : : PKG_ATTR_VERSION,
274 : : PKG_ATTR_COMMENT,
275 : : PKG_ATTR_DESC,
276 : : PKG_ATTR_MTREE,
277 : : PKG_ATTR_MESSAGE,
278 : : PKG_ATTR_ARCH,
279 : : PKG_ATTR_ABI,
280 : : PKG_ATTR_MAINTAINER,
281 : : PKG_ATTR_WWW,
282 : : PKG_ATTR_PREFIX,
283 : : PKG_ATTR_REPOPATH,
284 : : PKG_ATTR_CKSUM,
285 : : PKG_ATTR_OLD_VERSION,
286 : : PKG_ATTR_REPONAME,
287 : : PKG_ATTR_REPOURL,
288 : : PKG_ATTR_DIGEST,
289 : : PKG_ATTR_REASON,
290 : : PKG_ATTR_FLATSIZE,
291 : : PKG_ATTR_OLD_FLATSIZE,
292 : : PKG_ATTR_PKGSIZE,
293 : : PKG_ATTR_LICENSE_LOGIC,
294 : : PKG_ATTR_AUTOMATIC,
295 : : PKG_ATTR_LOCKED,
296 : : PKG_ATTR_ROWID,
297 : : PKG_ATTR_TIME,
298 : : PKG_ATTR_ANNOTATIONS,
299 : : PKG_ATTR_UNIQUEID,
300 : : PKG_ATTR_OLD_DIGEST,
301 : : PKG_ATTR_DEP_FORMULA,
302 : : PKG_ATTR_VITAL,
303 : : PKG_ATTR_CATEGORIES,
304 : : PKG_ATTR_LICENSES,
305 : : PKG_ATTR_GROUPS,
306 : : PKG_ATTR_USERS,
307 : : PKG_ATTR_SHLIBS_REQUIRED,
308 : : PKG_ATTR_SHLIBS_PROVIDED,
309 : : PKG_ATTR_PROVIDES,
310 : : PKG_ATTR_REQUIRES,
311 : : PKG_ATTR_CONFLICTS,
312 : : PKG_ATTR_NUM_FIELDS, /* end of fields */
313 : : } pkg_attr;
314 : :
315 : : typedef enum {
316 : : PKG_SET_FLATSIZE = 1U,
317 : : PKG_SET_AUTOMATIC,
318 : : PKG_SET_LOCKED,
319 : : PKG_SET_DEPORIGIN,
320 : : PKG_SET_ORIGIN,
321 : : PKG_SET_DEPNAME,
322 : : PKG_SET_NAME,
323 : : PKG_SET_VITAL,
324 : : PKG_SET_MAX
325 : : } pkg_set_attr;
326 : :
327 : : /**
328 : : * contains keys to refer to a string attribute
329 : : * Used by pkg_dep_get()
330 : : */
331 : : typedef enum {
332 : : PKG_DEP_NAME = 0,
333 : : PKG_DEP_ORIGIN,
334 : : PKG_DEP_VERSION
335 : : } pkg_dep_attr;
336 : :
337 : : typedef enum {
338 : : PKG_DEPS = 0,
339 : : PKG_RDEPS,
340 : : PKG_OPTIONS,
341 : : PKG_FILES,
342 : : PKG_DIRS,
343 : : PKG_USERS,
344 : : PKG_GROUPS,
345 : : PKG_SHLIBS_REQUIRED,
346 : : PKG_SHLIBS_PROVIDED,
347 : : PKG_CONFLICTS,
348 : : PKG_PROVIDES,
349 : : PKG_CONFIG_FILES,
350 : : PKG_REQUIRES,
351 : : } pkg_list;
352 : :
353 : : typedef enum {
354 : : SRV,
355 : : HTTP,
356 : : NOMIRROR,
357 : : } mirror_t;
358 : :
359 : : typedef enum {
360 : : SIG_NONE = 0,
361 : : SIG_PUBKEY,
362 : : SIG_FINGERPRINT
363 : : } signature_t;
364 : :
365 : : /**
366 : : * Determine the type of a pkg_script.
367 : : */
368 : : typedef enum {
369 : : PKG_SCRIPT_PRE_INSTALL = 0,
370 : : PKG_SCRIPT_POST_INSTALL,
371 : : PKG_SCRIPT_PRE_DEINSTALL,
372 : : PKG_SCRIPT_POST_DEINSTALL,
373 : : __DO_NOT_USE_ME1,
374 : : __DO_NOT_USE_ME2,
375 : : PKG_SCRIPT_INSTALL,
376 : : PKG_SCRIPT_DEINSTALL,
377 : : __DO_NOT_USE_ME3,
378 : : PKG_SCRIPT_UNKNOWN
379 : : } pkg_script;
380 : :
381 : : /**
382 : : * Determine the type of a pkg_lua_script.
383 : : */
384 : : typedef enum {
385 : : PKG_LUA_PRE_INSTALL = 0,
386 : : PKG_LUA_POST_INSTALL,
387 : : PKG_LUA_PRE_DEINSTALL,
388 : : PKG_LUA_POST_DEINSTALL,
389 : : PKG_LUA_UNKNOWN
390 : : } pkg_lua_script;
391 : :
392 : : typedef enum _pkg_jobs_t {
393 : : PKG_JOBS_INSTALL,
394 : : PKG_JOBS_DEINSTALL,
395 : : PKG_JOBS_FETCH,
396 : : PKG_JOBS_AUTOREMOVE,
397 : : PKG_JOBS_UPGRADE,
398 : : } pkg_jobs_t;
399 : :
400 : : typedef enum _pkg_flags {
401 : : PKG_FLAG_NONE = 0,
402 : : PKG_FLAG_DRY_RUN = (1U << 0),
403 : : PKG_FLAG_FORCE = (1U << 1),
404 : : PKG_FLAG_RECURSIVE = (1U << 2),
405 : : PKG_FLAG_AUTOMATIC = (1U << 3),
406 : : PKG_FLAG_WITH_DEPS = (1U << 4),
407 : : PKG_FLAG_NOSCRIPT = (1U << 5),
408 : : PKG_FLAG_PKG_VERSION_TEST = (1U << 6),
409 : : PKG_FLAG_UPGRADES_FOR_INSTALLED = (1U << 7),
410 : : PKG_FLAG_SKIP_INSTALL = (1U << 8),
411 : : PKG_FLAG_FORCE_MISSING = (1U << 9),
412 : : PKG_FLAG_FETCH_MIRROR = (1U << 10),
413 : : PKG_FLAG_USE_IPV4 = (1U << 11),
414 : : PKG_FLAG_USE_IPV6 = (1U << 12),
415 : : PKG_FLAG_UPGRADE_VULNERABLE = (1U << 13)
416 : : } pkg_flags;
417 : :
418 : : typedef enum _pkg_stats_t {
419 : : PKG_STATS_LOCAL_COUNT = 0,
420 : : PKG_STATS_LOCAL_SIZE,
421 : : PKG_STATS_REMOTE_COUNT,
422 : : PKG_STATS_REMOTE_UNIQUE,
423 : : PKG_STATS_REMOTE_SIZE,
424 : : PKG_STATS_REMOTE_REPOS,
425 : : } pkg_stats_t;
426 : :
427 : : typedef enum {
428 : : PKG_STRING = 0,
429 : : PKG_BOOL,
430 : : PKG_INT,
431 : : PKG_ARRAY,
432 : : PKG_OBJECT,
433 : : PKG_NULL
434 : : } pkg_object_t;
435 : :
436 : : /**
437 : : * Keys for accessing pkg plugin data
438 : : */
439 : : typedef enum _pkg_plugin_key {
440 : : PKG_PLUGIN_NAME = 0,
441 : : PKG_PLUGIN_DESC,
442 : : PKG_PLUGIN_VERSION,
443 : : PKG_PLUGIN_PLUGINFILE
444 : : } pkg_plugin_key;
445 : :
446 : : /**
447 : : * Keys for hooking into the library
448 : : */
449 : : typedef enum _pkg_plugin_hook_t {
450 : : PKG_PLUGIN_HOOK_PRE_INSTALL = 1,
451 : : PKG_PLUGIN_HOOK_POST_INSTALL,
452 : : PKG_PLUGIN_HOOK_PRE_DEINSTALL,
453 : : PKG_PLUGIN_HOOK_POST_DEINSTALL,
454 : : PKG_PLUGIN_HOOK_PRE_FETCH,
455 : : PKG_PLUGIN_HOOK_POST_FETCH,
456 : : PKG_PLUGIN_HOOK_EVENT,
457 : : PKG_PLUGIN_HOOK_PRE_UPGRADE,
458 : : PKG_PLUGIN_HOOK_POST_UPGRADE,
459 : : PKG_PLUGIN_HOOK_PRE_AUTOREMOVE,
460 : : PKG_PLUGIN_HOOK_POST_AUTOREMOVE,
461 : : PKG_PLUGIN_HOOK_PKGDB_CLOSE_RW,
462 : : PKG_PLUGIN_HOOK_REPO_UPDATE_SUCCESS,
463 : : PKG_PLUGIN_HOOK_LAST
464 : : } pkg_plugin_hook_t;
465 : :
466 : : /**
467 : : * Error type used everywhere by libpkg.
468 : : */
469 : : typedef enum {
470 : : EPKG_OK = 0,
471 : : /**
472 : : * No more items available (end of the loop).
473 : : */
474 : : EPKG_END,
475 : : EPKG_WARN,
476 : : /**
477 : : * The function encountered a fatal error.
478 : : */
479 : : EPKG_FATAL,
480 : : /**
481 : : * Can not delete the package because it is required by
482 : : * another package.
483 : : */
484 : : EPKG_REQUIRED,
485 : : /**
486 : : * Can not install the package because it is already installed.
487 : : */
488 : : EPKG_INSTALLED,
489 : : /**
490 : : * Can not install the package because some dependencies are
491 : : * unresolved.
492 : : */
493 : : EPKG_DEPENDENCY,
494 : : /**
495 : : * Can not operate on package because it is locked
496 : : */
497 : : EPKG_LOCKED,
498 : : /**
499 : : * Can not create local database or database non-existent
500 : : */
501 : : EPKG_ENODB,
502 : : /**
503 : : * local file newer than remote
504 : : */
505 : : EPKG_UPTODATE,
506 : : /**
507 : : * unkown keyword
508 : : */
509 : : EPKG_UNKNOWN,
510 : : /**
511 : : * repo DB schema incompatible version
512 : : */
513 : : EPKG_REPOSCHEMA,
514 : : /**
515 : : * Insufficient privilege for action
516 : : */
517 : : EPKG_ENOACCESS,
518 : : /**
519 : : * Insecure permissions on any component of
520 : : * $PKGDB_DIR/local.sqlite or any of the repo database bits
521 : : */
522 : : EPKG_INSECURE,
523 : : /**
524 : : * A conflict between packages found
525 : : */
526 : : EPKG_CONFLICT,
527 : : /**
528 : : * Need to repeat operation
529 : : */
530 : : EPKG_AGAIN,
531 : : /**
532 : : * Not installed
533 : : */
534 : : EPKG_NOTINSTALLED,
535 : : /**
536 : : * Can not delete the package because it is vital, i.e. a kernel
537 : : */
538 : : EPKG_VITAL,
539 : : /**
540 : : * the package already exist
541 : : */
542 : : EPKG_EXIST,
543 : : /**
544 : : * the operation was cancelled
545 : : */
546 : : EPKG_CANCEL,
547 : : /**
548 : : * the operation has failed due to network down
549 : : */
550 : : EPKG_NONETWORK,
551 : : EPKG_ENOENT,
552 : : /**
553 : : * The requested operation is not supported.
554 : : */
555 : : EPKG_OPNOTSUPP,
556 : : } pkg_error_t;
557 : :
558 : : /**
559 : : * Upgrade, downgrade or reinstall?
560 : : */
561 : :
562 : : typedef enum {
563 : : PKG_DOWNGRADE = 0,
564 : : PKG_REINSTALL,
565 : : PKG_UPGRADE,
566 : : } pkg_change_t;
567 : :
568 : : /**
569 : : * Locking types for database:
570 : : * `PKGDB_LOCK_READONLY`: lock for read only queries (can be nested)
571 : : * `PKGDB_LOCK_ADVISORY`: write to DB inside a transaction (allows `PKGDB_LOCK_READONLY`)
572 : : * `PKGDB_LOCK_EXCLUSIVE`: possibly destructive operations (does not allow other locks)
573 : : */
574 : : typedef enum {
575 : : PKGDB_LOCK_READONLY,
576 : : PKGDB_LOCK_ADVISORY,
577 : : PKGDB_LOCK_EXCLUSIVE
578 : : } pkgdb_lock_t;
579 : :
580 : : typedef enum {
581 : : PKG_SOLVED_INSTALL,
582 : : PKG_SOLVED_DELETE,
583 : : PKG_SOLVED_UPGRADE,
584 : : PKG_SOLVED_UPGRADE_REMOVE,
585 : : PKG_SOLVED_FETCH,
586 : : PKG_SOLVED_UPGRADE_INSTALL
587 : : } pkg_solved_t;
588 : :
589 : : struct pkg_kvlist;
590 : : struct pkg_stringlist;
591 : :
592 : : typedef enum {
593 : : PKG_KVLIST = 1U,
594 : : PKG_STRINGLIST,
595 : : PKG_STR,
596 : : PKG_INTEGER,
597 : : PKG_BOOLEAN,
598 : : } pkg_el_t;
599 : :
600 : : struct pkg_el {
601 : : union {
602 : : struct pkg_kvlist *kvlist;
603 : : struct pkg_stringlist *stringlist;
604 : : const char *string;
605 : : int64_t integer;
606 : : bool boolean;
607 : : };
608 : : pkg_el_t type;
609 : : };
610 : :
611 : : #define PKG_OPEN_MANIFEST_ONLY 0x1
612 : : #define PKG_OPEN_MANIFEST_COMPACT (0x1 << 1)
613 : : #define PKG_OPEN_TRY (0x1 << 2)
614 : :
615 : : /**
616 : : * test if pkg is installed and activated.
617 : : * @param count If all the tests pass, and count is non-NULL,
618 : : * write the number of installed packages into *count
619 : : */
620 : : pkg_status_t pkg_status(int *count);
621 : :
622 : : /**
623 : : * Allocate a new pkg.
624 : : * Allocated pkg must be deallocated by pkg_free().
625 : : */
626 : : int pkg_new(struct pkg **, pkg_t type);
627 : :
628 : : /**
629 : : * Deallocate a pkg
630 : : */
631 : : void pkg_free(struct pkg *);
632 : :
633 : : /**
634 : : * Check if a package is valid according to its type.
635 : : */
636 : : int pkg_is_valid(const struct pkg * restrict);
637 : :
638 : : /**
639 : : * Open a package file archive and retrive informations.
640 : : * @param p A pointer to pkg allocated by pkg_new(), or if it points to a
641 : : * NULL pointer, the function allocate a new pkg using pkg_new().
642 : : * @param path The path to the local package archive.
643 : : * @param keys manifest keys that should be initialised
644 : : * @param flags open flags
645 : : */
646 : : int pkg_open(struct pkg **p, const char *path, int flags);
647 : : int pkg_open_fd(struct pkg **p, int fd, int flags);
648 : :
649 : : /**
650 : : * @return the type of the package.
651 : : * @warning returns PKG_NONE on error.
652 : : */
653 : : pkg_t pkg_type(const struct pkg * restrict);
654 : :
655 : : int pkg_list_count(const struct pkg *, pkg_list);
656 : :
657 : : /**
658 : : * Iterates over the dependencies of the package.
659 : : * @param dep Must be set to NULL for the first call.
660 : : * @return An error code.
661 : : */
662 : : int pkg_deps(const struct pkg *, struct pkg_dep **dep);
663 : :
664 : : /**
665 : : * Iterates over the reverse dependencies of the package.
666 : : * That is, the packages which require this package.
667 : : * @param dep Must be set to NULL for the first call.
668 : : * @return An error code.
669 : : */
670 : : int pkg_rdeps(const struct pkg *, struct pkg_dep **dep);
671 : :
672 : : /**
673 : : * Iterates over the files of the package.
674 : : * @param file Must be set to NULL for the first call.
675 : : * @return An error code.
676 : : */
677 : : int pkg_files(const struct pkg *, struct pkg_file **file);
678 : :
679 : : /**
680 : : * Iterates over the directories of the package.
681 : : * @param Must be set to NULL for the first call.
682 : : * @return An error code.
683 : : */
684 : : int pkg_dirs(const struct pkg *pkg, struct pkg_dir **dir);
685 : :
686 : : /**
687 : : * Iterates over the options of the package.
688 : : * @param option Must be set to NULL for the first call.
689 : : * @return An error code.
690 : : */
691 : : int pkg_options(const struct pkg *, struct pkg_option **option);
692 : :
693 : : /**
694 : : * Iterates over the conflicts registered in the package.
695 : : * @param conflict must be set to NULL for the first call.
696 : : * @return An error code
697 : : */
698 : : int pkg_conflicts(const struct pkg *pkg, struct pkg_conflict **conflict);
699 : :
700 : : int pkg_licenses(const struct pkg *pkg, char **licenses);
701 : :
702 : : /**
703 : : * Iterates over the config files registered in the package.
704 : : * @param provide must be set to NULL for the first call.
705 : : * @return An error code
706 : : */
707 : : int pkg_config_files(const struct pkg *pkg, struct pkg_config_file **cf);
708 : :
709 : : /**
710 : : * Iterate over all of the files within the package pkg, ensuring the
711 : : * dependency list contains all applicable packages providing the
712 : : * shared objects used by pkg.
713 : : * Also add all the shared object into the shlibs.
714 : : * It respects the SHLIBS options from configuration
715 : : * @return An error code
716 : : */
717 : :
718 : : /* Don't conflict with PKG_LOAD_* q.v. */
719 : : #define PKG_CONTAINS_ELF_OBJECTS (1U << 24)
720 : : #define PKG_CONTAINS_STATIC_LIBS (1U << 25)
721 : : #define PKG_CONTAINS_LA (1U << 26)
722 : :
723 : : int pkg_analyse_files(struct pkgdb *, struct pkg *, const char *);
724 : :
725 : : int pkgdb_set2(struct pkgdb *db, struct pkg *pkg, ...);
726 : : #define pkgdb_set(db, pkg, ...) pkgdb_set2(db, pkg, __VA_ARGS__, -1)
727 : :
728 : : /**
729 : : * Set a new debug level used inside of pkg.
730 : : * @param debug_level Debug level between 0 (no debugging) and 4 (max debugging).
731 : : * @return Previous debug level.
732 : : */
733 : : int64_t pkg_set_debug_level(int64_t debug_level);
734 : : int pkg_set_rootdir(const char *rootdir);
735 : : int pkg_set_ischrooted(bool ischrooted);
736 : :
737 : : int pkg_open_devnull(void);
738 : : void pkg_close_devnull(void);
739 : :
740 : : /**
741 : : * Allocate a new struct pkg and add it to the deps of pkg.
742 : : * @return An error code.
743 : : */
744 : : int pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const
745 : : char *version, bool locked);
746 : : int pkg_addrdep(struct pkg *pkg, const char *name, const char *origin, const
747 : : char *version, bool locked);
748 : :
749 : :
750 : : /**
751 : : * Helper which call pkg_addscript() with the content of the file and
752 : : * with the correct type.
753 : : */
754 : : int pkg_addscript_fileat(int fd, struct pkg *pkg, const char *path);
755 : : int pkg_addluascript_fileat(int fd, struct pkg *pkg, const char *path);
756 : :
757 : : /**
758 : : * Parse a manifest and set the attributes of pkg accordingly.
759 : : * @param buf An NULL-terminated buffer containing the manifest data.
760 : : * @return An error code.
761 : : */
762 : : int pkg_parse_manifest(struct pkg *pkg, const char *buf, size_t len);
763 : : int pkg_parse_manifest_file(struct pkg *pkg, const char *);
764 : : int pkg_parse_manifest_fileat(int fd, struct pkg *pkg, const char *);
765 : :
766 : : #define PKG_MANIFEST_EMIT_COMPACT 0x1
767 : : #define PKG_MANIFEST_EMIT_NOFILES (0x1 << 1)
768 : : #define PKG_MANIFEST_EMIT_PRETTY (0x1 << 2)
769 : : #define PKG_MANIFEST_EMIT_JSON (0x1 << 3)
770 : : #define PKG_MANIFEST_EMIT_UCL (0x1 << 4)
771 : : #define PKG_MANIFEST_EMIT_LOCAL_METADATA (0x1 << 5)
772 : :
773 : : /**
774 : : * Emit a manifest according to the attributes of pkg.
775 : : * @param buf A pointer which will hold the allocated buffer containing the
776 : : * manifest. To be free'ed.
777 : : * @param flags Flags for manifest emitting.
778 : : * if NULL. To be free'ed if not NULL.
779 : : * @return An error code.
780 : : */
781 : : int pkg_emit_manifest_file(struct pkg*, FILE *, short);
782 : :
783 : : /* pkg_dep */
784 : : const char *pkg_dep_get(struct pkg_dep const * const , const pkg_dep_attr);
785 : : #define pkg_dep_name(d) pkg_dep_get(d, PKG_DEP_NAME)
786 : : #define pkg_dep_origin(d) pkg_dep_get(d, PKG_DEP_ORIGIN)
787 : : #define pkg_dep_version(d) pkg_dep_get(d, PKG_DEP_VERSION)
788 : : bool pkg_dep_is_locked(struct pkg_dep const * const);
789 : :
790 : : bool pkg_has_dir(struct pkg *, const char *);
791 : : bool pkg_has_file(struct pkg *, const char *);
792 : :
793 : : struct pkg_file *pkg_get_file(struct pkg *p, const char *path);
794 : : struct pkg_dir *pkg_get_dir(struct pkg *p, const char *path);
795 : :
796 : : /* pkg_license */
797 : : const char *pkg_license_name(struct pkg_license const * const);
798 : :
799 : : /* pkg_script */
800 : : const char *pkg_script_get(struct pkg const * const, pkg_script);
801 : :
802 : : /**
803 : : * @param db A pointer to a struct pkgdb object
804 : : * @param origin Package origin
805 : : * @param pkg An allocated struct pkg or a pointer to a NULL pointer. In the
806 : : * last case, the function take care of the allocation.
807 : : * @param flags OR'ed PKG_LOAD_*
808 : : * @return EPKG_OK if the package is installed,
809 : : * and != EPKG_OK if the package is not installed or an error occurred
810 : : * Match will be case sensitive or insensitive depending on
811 : : * pkgdb_case_sensitive()
812 : : */
813 : : int pkg_try_installed(struct pkgdb *db, const char *origin,
814 : : struct pkg **pkg, unsigned flags);
815 : :
816 : : /**
817 : : * @param db A pointer to a struct pkgdb object
818 : : * @param origin Package origin
819 : : * @return EPKG_OK if the package is installed,
820 : : * and != EPKG_OK if the package is not installed or an error occurred
821 : : * Match will be case sensitive or insensitive depending on
822 : : * pkgdb_case_sensitive()
823 : : */
824 : : int pkg_is_installed(struct pkgdb *db, const char *name);
825 : :
826 : : /**
827 : : * Create a repository database.
828 : : * @param path The path where the repository live.
829 : : * @param output_dir The path where the package repository should be created.
830 : : * @param force If true, rebuild the repository catalogue from scratch
831 : : * @param filesite If true, create a list of all files in repo
832 : : * @param metafile Open meta from the specified file
833 : : */
834 : : typedef int(pkg_password_cb)(char *, int, int, void*);
835 : : int pkg_create_repo(char *path, const char *output_dir, bool filelist,
836 : : const char *metafile, bool hash, bool hash_symlink);
837 : : int pkg_finish_repo(const char *output_dir, pkg_password_cb *cb, char **argv,
838 : : int argc, bool filelist);
839 : :
840 : : struct pkg_repo_create *pkg_repo_create_new(void);
841 : : void pkg_repo_create_free(struct pkg_repo_create *);
842 : : void pkg_repo_create_set_create_filelist(struct pkg_repo_create *prc, bool);
843 : : void pkg_repo_create_set_hash(struct pkg_repo_create *prc, bool);
844 : : void pkg_repo_create_set_hash_symlink(struct pkg_repo_create *prc, bool);
845 : : void pkg_repo_create_set_output_dir(struct pkg_repo_create *prc, const char *);
846 : : void pkg_repo_create_set_metafile(struct pkg_repo_create *prc, const char *);
847 : : void pkg_repo_create_set_sign(struct pkg_repo_create *prc, char **argv, int argc, pkg_password_cb *cb);
848 : : void pkg_repo_create_set_groups(struct pkg_repo_create *prc, const char *);
849 : : void pkg_repo_create_set_expired_packages(struct pkg_repo_create *prc, const char *);
850 : : int pkg_repo_create(struct pkg_repo_create *, char *path);
851 : :
852 : : /**
853 : : * Flags for accessing pkg database
854 : : */
855 : : #define PKGDB_MODE_READ (0x1<<0)
856 : : #define PKGDB_MODE_WRITE (0x1<<1)
857 : : #define PKGDB_MODE_CREATE (0x1<<2)
858 : :
859 : : /**
860 : : * What repos should we open: local or remote
861 : : */
862 : : #define PKGDB_DB_LOCAL (0x1<<0)
863 : : #define PKGDB_DB_REPO (0x1<<1)
864 : : /**
865 : : * Test if the EUID has sufficient privilege to carry out some
866 : : * operation (mode is a bitmap indicating READ, WRITE, CREATE) on the
867 : : * databases indicated in the database bitmap.
868 : : *
869 : : * It also accepts a number of arguments representing pkg repositories requested
870 : : * to be opened. This list *MUST* be terminated with `NULL` repo.
871 : : * If no repositories are specified (e.g. when NULL is the first argument,
872 : : * then all repositories are tried to be accessed).
873 : : */
874 : : int pkgdb_access(unsigned mode, unsigned database);
875 : : int pkgdb_access2(unsigned mode, unsigned database, c_charv_t *databases);
876 : :
877 : : /**
878 : : * Open the local package database.
879 : : * The db must be free'ed with pkgdb_close().
880 : : * @return An error code.
881 : : */
882 : : int pkgdb_open(struct pkgdb **db, pkgdb_t type);
883 : :
884 : : /**
885 : : * Open the local package database and repositories, possibly
886 : : * overriding configured repositories and replacing with the given
887 : : * reponame if not NULL
888 : : * @return An error code
889 : : */
890 : : int pkgdb_open_all(struct pkgdb **db, pkgdb_t type, const char *reponame);
891 : : int pkgdb_open_all2(struct pkgdb **db, pkgdb_t type, c_charv_t *reponames);
892 : :
893 : : /**
894 : : * Locking functions
895 : : */
896 : : int pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type);
897 : : int pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_type);
898 : : int pkgdb_downgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type,
899 : : pkgdb_lock_t new_type);
900 : : int pkgdb_release_lock(struct pkgdb *db, pkgdb_lock_t type);
901 : :
902 : : /**
903 : : * Transaction/savepoint handling.
904 : : * @param savepoint -- if NULL or an empty string, use BEGIN, ROLLBACK, COMMIT
905 : : * otherwise use SAVEPOINT, ROLLBACK TO, RELEASE.
906 : : * @return an error code.
907 : : */
908 : : int pkgdb_transaction_begin(struct pkgdb *db, const char *savepoint);
909 : : int pkgdb_transaction_commit(struct pkgdb *db, const char *savepoint);
910 : : int pkgdb_transaction_rollback(struct pkgdb *db, const char *savepoint);
911 : :
912 : : /**
913 : : * Close and free the struct pkgdb.
914 : : */
915 : : void pkgdb_close(struct pkgdb *db);
916 : :
917 : : /**
918 : : * Set the case sensitivity flag on or off. Defaults to
919 : : * true (case_sensitive)
920 : : */
921 : : void pkgdb_set_case_sensitivity(bool);
922 : :
923 : : /**
924 : : * Query the state of the case sensitity setting.
925 : : */
926 : : bool pkgdb_case_sensitive(void);
927 : :
928 : : /**
929 : : * Query the local package database.
930 : : * @param type Describe how pattern should be used.
931 : : * @warning Returns NULL on failure.
932 : : */
933 : : struct pkgdb_it * pkgdb_query(struct pkgdb *db, const char *pattern,
934 : : match_t type);
935 : : struct pkgdb_it * pkgdb_query_cond(struct pkgdb *db, const char *cond,
936 : : const char *pattern, match_t type);
937 : : struct pkgdb_it * pkgdb_repo_query(struct pkgdb *db, const char *pattern,
938 : : match_t type, const char *reponame);
939 : : struct pkgdb_it * pkgdb_repo_query2(struct pkgdb *db, const char *pattern,
940 : : match_t type, c_charv_t *reponames);
941 : : struct pkgdb_it *pkgdb_repo_query_cond(struct pkgdb *db, const char *cond,
942 : : const char *pattern, match_t type, const char *reponame);
943 : : struct pkgdb_it *pkgdb_repo_query_cond2(struct pkgdb *db, const char *cond,
944 : : const char *pattern, match_t type, c_charv_t *reponames);
945 : : struct pkgdb_it * pkgdb_repo_search(struct pkgdb *db, const char *pattern,
946 : : match_t type, pkgdb_field field, pkgdb_field sort, const char *reponame);
947 : : struct pkgdb_it * pkgdb_repo_search2(struct pkgdb *db, const char *pattern,
948 : : match_t type, pkgdb_field field, pkgdb_field sort, c_charv_t *reponames);
949 : : struct pkgdb_it * pkgdb_all_search(struct pkgdb *db, const char *pattern,
950 : : match_t type, pkgdb_field field, pkgdb_field sort, const char *reponame);
951 : : struct pkgdb_it * pkgdb_all_search2(struct pkgdb *db, const char *pattern,
952 : : match_t type, pkgdb_field field, pkgdb_field sort, c_charv_t *reponames);
953 : :
954 : : /**
955 : : * @todo Return directly the struct pkg?
956 : : */
957 : : struct pkgdb_it * pkgdb_query_which(struct pkgdb *db, const char *path, bool glob);
958 : :
959 : : struct pkgdb_it * pkgdb_query_shlib_require(struct pkgdb *db, const char *shlib);
960 : : struct pkgdb_it * pkgdb_query_shlib_provide(struct pkgdb *db, const char *shlib);
961 : : struct pkgdb_it * pkgdb_query_require(struct pkgdb *db, const char *req);
962 : : struct pkgdb_it * pkgdb_query_provide(struct pkgdb *db, const char *req);
963 : :
964 : : /**
965 : : * Add/Modify/Delete an annotation for a package
966 : : * @param tag -- tag for the annotation
967 : : * @param value -- text of the annotation
968 : : * @return An error code
969 : : */
970 : : int pkgdb_add_annotation(struct pkgdb *db, struct pkg *pkg,
971 : : const char *tag, const char *value);
972 : : int pkgdb_modify_annotation(struct pkgdb *db, struct pkg *pkg,
973 : : const char *tag, const char *value);
974 : : int pkgdb_delete_annotation(struct pkgdb *db, struct pkg *pkg,
975 : : const char *tag);
976 : :
977 : : #define PKG_LOAD_BASIC 0
978 : : #define PKG_LOAD_DEPS (1U << 0)
979 : : #define PKG_LOAD_RDEPS (1U << 1)
980 : : #define PKG_LOAD_FILES (1U << 2)
981 : : #define PKG_LOAD_SCRIPTS (1U << 3)
982 : : #define PKG_LOAD_OPTIONS (1U << 4)
983 : : #define PKG_LOAD_DIRS (1U << 5)
984 : : #define PKG_LOAD_CATEGORIES (1U << 6)
985 : : #define PKG_LOAD_LICENSES (1U << 7)
986 : : #define PKG_LOAD_USERS (1U << 8)
987 : : #define PKG_LOAD_GROUPS (1U << 9)
988 : : #define PKG_LOAD_SHLIBS_REQUIRED (1U << 10)
989 : : #define PKG_LOAD_SHLIBS_PROVIDED (1U << 11)
990 : : #define PKG_LOAD_ANNOTATIONS (1U << 12)
991 : : #define PKG_LOAD_CONFLICTS (1U << 13)
992 : : #define PKG_LOAD_PROVIDES (1U << 14)
993 : : #define PKG_LOAD_REQUIRES (1U << 15)
994 : : #define PKG_LOAD_LUA_SCRIPTS (1u << 16)
995 : : /* Make sure new PKG_LOAD don't conflict with PKG_CONTAINS_* */
996 : :
997 : : /**
998 : : * Get the next pkg.
999 : : * @param pkg An allocated struct pkg or a pointer to a NULL pointer. In the
1000 : : * last case, the function take care of the allocation.
1001 : : * @param flags OR'ed PKG_LOAD_*
1002 : : * @return An error code.
1003 : : */
1004 : : int pkgdb_it_next(struct pkgdb_it *, struct pkg **pkg, unsigned flags);
1005 : :
1006 : : /**
1007 : : * Reset the pkgdb_it iterator, allowing for re-iterating over it
1008 : : */
1009 : : void pkgdb_it_reset(struct pkgdb_it *);
1010 : :
1011 : : /**
1012 : : * Return the number of rows found.
1013 : : * @return -1 on error
1014 : : */
1015 : : int pkgdb_it_count(struct pkgdb_it *);
1016 : :
1017 : : /**
1018 : : * Free a struct pkgdb_it.
1019 : : */
1020 : : void pkgdb_it_free(struct pkgdb_it *);
1021 : :
1022 : : /**
1023 : : * Compact the database to save space.
1024 : : * Note that the function will really compact the database only if some
1025 : : * internal criterias are met.
1026 : : * @return An error code.
1027 : : */
1028 : : int pkgdb_compact(struct pkgdb *db);
1029 : :
1030 : : /**
1031 : : * Install and register a new package.
1032 : : * @param db An opened pkgdb
1033 : : * @param path The path to the package archive file on the local disk
1034 : : * @return An error code.
1035 : : */
1036 : : int pkg_add(struct pkgdb *db, const char *path, unsigned flags,
1037 : : const char *location);
1038 : :
1039 : : #define PKG_ADD_UPGRADE (1U << 0)
1040 : : /* (1U << 1) removed intentionally */
1041 : : #define PKG_ADD_AUTOMATIC (1U << 2)
1042 : : #define PKG_ADD_FORCE (1U << 3)
1043 : : #define PKG_ADD_NOSCRIPT (1U << 4)
1044 : : #define PKG_ADD_FORCE_MISSING (1U << 5)
1045 : : #define PKG_ADD_SPLITTED_UPGRADE (1U << 6)
1046 : :
1047 : : /**
1048 : : * Allocate a new pkg_jobs.
1049 : : * @param db A pkgdb open with PKGDB_REMOTE.
1050 : : * @return An error code.
1051 : : */
1052 : : int pkg_jobs_new(struct pkg_jobs **jobs, pkg_jobs_t type, struct pkgdb *db);
1053 : :
1054 : : /**
1055 : : * Free a pkg_jobs
1056 : : */
1057 : : void pkg_jobs_free(struct pkg_jobs *jobs);
1058 : :
1059 : : /**
1060 : : * Add a pkg to the jobs queue.
1061 : : * @return An error code.
1062 : : */
1063 : : int pkg_jobs_add(struct pkg_jobs *j, match_t match, char **argv, int argc);
1064 : : int pkg_jobs_solve(struct pkg_jobs *j);
1065 : : int pkg_jobs_set_repository(struct pkg_jobs *j, const char *name);
1066 : : int pkg_jobs_set_repositories(struct pkg_jobs *j, c_charv_t *names);
1067 : : const char* pkg_jobs_destdir(struct pkg_jobs *j);
1068 : : int pkg_jobs_set_destdir(struct pkg_jobs *j, const char *name);
1069 : : void pkg_jobs_set_flags(struct pkg_jobs *j, pkg_flags f);
1070 : : pkg_jobs_t pkg_jobs_type(struct pkg_jobs *j);
1071 : :
1072 : : /**
1073 : : * Returns the number of elements in the job queue
1074 : : */
1075 : : int pkg_jobs_count(struct pkg_jobs *jobs);
1076 : :
1077 : : /**
1078 : : * Returns the number of total elements in pkg universe
1079 : : */
1080 : : int pkg_jobs_total(struct pkg_jobs *jobs);
1081 : :
1082 : : /**
1083 : : * Iterates over the packages in the jobs queue.
1084 : : * @param iter Must be set to NULL for the first call.
1085 : : * @return A next pkg or NULL.
1086 : : */
1087 : : bool pkg_jobs_iter(struct pkg_jobs *jobs, void **iter, struct pkg **n,
1088 : : struct pkg **o, int *type);
1089 : :
1090 : : /**
1091 : : * Apply the jobs in the queue (fetch and install).
1092 : : * @return An error code.
1093 : : */
1094 : : int pkg_jobs_apply(struct pkg_jobs *jobs);
1095 : :
1096 : : /**
1097 : : * Emit CUDF spec to a file for a specified jobs request
1098 : : * @return error code
1099 : : */
1100 : : int pkg_jobs_cudf_emit_file(struct pkg_jobs *, pkg_jobs_t , FILE *);
1101 : :
1102 : : /**
1103 : : * Parse the output of an external CUDF solver
1104 : : * @return error code
1105 : : */
1106 : : int pkg_jobs_cudf_parse_output(struct pkg_jobs *j, FILE *f);
1107 : :
1108 : : /**
1109 : : * Check if there are locked packages
1110 : : * @return true if locked packages exist, false if not
1111 : : */
1112 : : bool pkg_jobs_has_lockedpkgs(struct pkg_jobs *j);
1113 : :
1114 : : /**
1115 : : * Iterate through the locked packages, calling the passed in function pointer
1116 : : * on each.
1117 : : */
1118 : : typedef int(*locked_pkgs_cb)(struct pkg *, void *);
1119 : : void pkg_jobs_iter_lockedpkgs(struct pkg_jobs *j, locked_pkgs_cb, void *);
1120 : :
1121 : : /**
1122 : : * Solve a SAT problem
1123 : : * @return true if a problem is solvable
1124 : : */
1125 : : int pkg_solve_sat_problem(struct pkg_solve_problem *problem);
1126 : :
1127 : : /**
1128 : : * Export SAT problem to a dot graph description
1129 : : */
1130 : : void pkg_solve_dot_export(struct pkg_solve_problem *problem, FILE *file);
1131 : :
1132 : : /**
1133 : : * Convert package jobs to a SAT problem
1134 : : * @return SAT problem or NULL if failed
1135 : : */
1136 : : struct pkg_solve_problem * pkg_solve_jobs_to_sat(struct pkg_jobs *j);
1137 : :
1138 : : /**
1139 : : * Export sat problem to the DIMACS format
1140 : : * @return error code
1141 : : */
1142 : : int pkg_solve_dimacs_export(struct pkg_solve_problem *problem, FILE *f);
1143 : :
1144 : : /**
1145 : : * Move solved problem to the jobs structure
1146 : : * @return error code
1147 : : */
1148 : : int pkg_solve_sat_to_jobs(struct pkg_solve_problem *problem);
1149 : :
1150 : : /**
1151 : : * Parse SAT solver output and convert it to jobs
1152 : : * @return error code
1153 : : */
1154 : : int pkg_solve_parse_sat_output(FILE *f, struct pkg_solve_problem *problem);
1155 : :
1156 : : /**
1157 : : * Free a SAT problem structure
1158 : : */
1159 : : void pkg_solve_problem_free(struct pkg_solve_problem *problem);
1160 : :
1161 : : /**
1162 : : * Archive formats options.
1163 : : */
1164 : : typedef enum pkg_formats { TAR, TGZ, TBZ, TXZ, TZS } pkg_formats;
1165 : :
1166 : :
1167 : : int pkg_load_metadata(struct pkg *, const char *, const char *, const char *, const char *, bool);
1168 : :
1169 : : /**
1170 : : * Download the latest repo db file and checks its signature if any
1171 : : * @param force Always download the repo catalogue
1172 : : */
1173 : : int pkg_update(struct pkg_repo *repo, bool force);
1174 : :
1175 : : /**
1176 : : * Get statistics information from the package database(s)
1177 : : * @param db A valid database object as returned by pkgdb_open()
1178 : : * @param type Type of statistics to be returned
1179 : : * @return The statistic information requested
1180 : : */
1181 : : int64_t pkgdb_stats(struct pkgdb *db, pkg_stats_t type);
1182 : :
1183 : : /**
1184 : : * pkg plugin functions
1185 : : * @todo Document
1186 : : */
1187 : : int pkg_plugins_init(void);
1188 : : void pkg_plugins_shutdown(void);
1189 : : int pkg_plugins(struct pkg_plugin **plugin);
1190 : : int pkg_plugin_set(struct pkg_plugin *p, pkg_plugin_key key, const char *str);
1191 : : const char *pkg_plugin_get(struct pkg_plugin *p, pkg_plugin_key key);
1192 : : void *pkg_plugin_func(struct pkg_plugin *p, const char *func);
1193 : :
1194 : : int pkg_plugin_conf_add(struct pkg_plugin *p, pkg_object_t type, const char *key, const char *def);
1195 : : const pkg_object *pkg_plugin_conf(struct pkg_plugin *p);
1196 : :
1197 : : int pkg_plugin_parse(struct pkg_plugin *p);
1198 : : void pkg_plugin_errno(struct pkg_plugin *p, const char *func, const char *arg);
1199 : : void pkg_plugin_error(struct pkg_plugin *p, const char *fmt, ...);
1200 : : void pkg_plugin_info(struct pkg_plugin *p, const char *fmt, ...);
1201 : : /**
1202 : : * This is where plugin hook into the library using pkg_plugin_hook()
1203 : : * @todo: Document
1204 : : */
1205 : : typedef int(*pkg_plugin_callback)(void *data, struct pkgdb *db);
1206 : : int pkg_plugins_hook_run(pkg_plugin_hook_t hook, void *data, struct pkgdb *db);
1207 : : int pkg_plugin_hook_register(struct pkg_plugin *p, pkg_plugin_hook_t hook, pkg_plugin_callback callback);
1208 : :
1209 : : /**
1210 : : * Get the value of a configuration key
1211 : : */
1212 : :
1213 : : const pkg_object *pkg_config_get(const char *);
1214 : : pkg_object_t pkg_object_type(const pkg_object *);
1215 : : int64_t pkg_object_int(const pkg_object *o);
1216 : : bool pkg_object_bool(const pkg_object *o);
1217 : : const char *pkg_object_string(const pkg_object *o);
1218 : : void pkg_object_free(pkg_object *o);
1219 : : const char *pkg_object_key(const pkg_object *);
1220 : : const pkg_object *pkg_object_iterate(const pkg_object *, pkg_iter *);
1221 : : char *pkg_object_dump(const pkg_object *o);
1222 : : char *pkg_config_dump(void);
1223 : :
1224 : : /**
1225 : : * @todo Document
1226 : : */
1227 : : int pkg_version_cmp(const char * const , const char * const);
1228 : : pkg_change_t pkg_version_change_between(const struct pkg * pkg1, const struct pkg *pkg2);
1229 : :
1230 : : /**
1231 : : * Fetch a file.
1232 : : * @return An error code.
1233 : : */
1234 : : int pkg_fetch_file(struct pkg_repo *repo, const char *url, char *dest, time_t t,
1235 : : ssize_t offset, int64_t size);
1236 : : /**
1237 : : * Fetch a file to temporary destination
1238 : : */
1239 : : int pkg_fetch_file_tmp(struct pkg_repo *repo, const char *url, char *dest,
1240 : : time_t t);
1241 : :
1242 : : /**
1243 : : * Get cached name of a package
1244 : : */
1245 : : int pkg_repo_cached_name(struct pkg *pkg, char *dest, size_t destlen);
1246 : :
1247 : : /* glue to deal with ports */
1248 : : int ports_parse_plist(struct pkg *, const char *, const char *);
1249 : :
1250 : : /**
1251 : : * Special structure to report about conflicts
1252 : : */
1253 : : struct pkg_event_conflict {
1254 : : char *uid;
1255 : : struct pkg_event_conflict *next;
1256 : : };
1257 : :
1258 : : /*
1259 : : * Capsicum sandbox callbacks
1260 : : */
1261 : : typedef int (*pkg_sandbox_cb)(int fd, void *user_data);
1262 : :
1263 : : /**
1264 : : * Event type used to report progress or problems.
1265 : : */
1266 : : typedef enum {
1267 : : /* informational */
1268 : : PKG_EVENT_INSTALL_BEGIN = 0,
1269 : : PKG_EVENT_INSTALL_FINISHED,
1270 : : PKG_EVENT_DEINSTALL_BEGIN,
1271 : : PKG_EVENT_DEINSTALL_FINISHED,
1272 : : PKG_EVENT_UPGRADE_BEGIN,
1273 : : PKG_EVENT_UPGRADE_FINISHED,
1274 : : PKG_EVENT_EXTRACT_BEGIN,
1275 : : PKG_EVENT_EXTRACT_FINISHED,
1276 : : PKG_EVENT_DELETE_FILES_BEGIN,
1277 : : PKG_EVENT_DELETE_FILES_FINISHED,
1278 : : PKG_EVENT_ADD_DEPS_BEGIN,
1279 : : PKG_EVENT_ADD_DEPS_FINISHED,
1280 : : PKG_EVENT_FETCHING,
1281 : : PKG_EVENT_FETCH_BEGIN,
1282 : : PKG_EVENT_FETCH_FINISHED,
1283 : : PKG_EVENT_UPDATE_ADD,
1284 : : PKG_EVENT_UPDATE_REMOVE,
1285 : : PKG_EVENT_INTEGRITYCHECK_BEGIN,
1286 : : PKG_EVENT_INTEGRITYCHECK_FINISHED,
1287 : : PKG_EVENT_INTEGRITYCHECK_CONFLICT,
1288 : : PKG_EVENT_NEWPKGVERSION,
1289 : : PKG_EVENT_NOTICE,
1290 : : PKG_EVENT_DEBUG,
1291 : : PKG_EVENT_INCREMENTAL_UPDATE_BEGIN,
1292 : : PKG_EVENT_INCREMENTAL_UPDATE, // _FINISHED
1293 : : PKG_EVENT_QUERY_YESNO,
1294 : : PKG_EVENT_QUERY_SELECT,
1295 : : PKG_EVENT_SANDBOX_CALL,
1296 : : PKG_EVENT_SANDBOX_GET_STRING,
1297 : : PKG_EVENT_PROGRESS_START,
1298 : : PKG_EVENT_PROGRESS_TICK,
1299 : : PKG_EVENT_BACKUP,
1300 : : PKG_EVENT_RESTORE,
1301 : : /* errors */
1302 : : PKG_EVENT_ERROR,
1303 : : PKG_EVENT_ERRNO,
1304 : : PKG_EVENT_ARCHIVE_COMP_UNSUP = 65536,
1305 : : PKG_EVENT_ALREADY_INSTALLED,
1306 : : PKG_EVENT_FAILED_CKSUM,
1307 : : PKG_EVENT_CREATE_DB_ERROR,
1308 : : PKG_EVENT_LOCKED,
1309 : : PKG_EVENT_REQUIRED,
1310 : : PKG_EVENT_MISSING_DEP,
1311 : : PKG_EVENT_NOREMOTEDB,
1312 : : PKG_EVENT_NOLOCALDB,
1313 : : PKG_EVENT_FILE_MISMATCH,
1314 : : PKG_EVENT_DEVELOPER_MODE,
1315 : : PKG_EVENT_PLUGIN_ERRNO,
1316 : : PKG_EVENT_PLUGIN_ERROR,
1317 : : PKG_EVENT_PLUGIN_INFO,
1318 : : PKG_EVENT_NOT_FOUND,
1319 : : PKG_EVENT_NEW_ACTION,
1320 : : PKG_EVENT_MESSAGE,
1321 : : PKG_EVENT_FILE_MISSING,
1322 : : PKG_EVENT_CLEANUP_CALLBACK_REGISTER,
1323 : : PKG_EVENT_CLEANUP_CALLBACK_UNREGISTER,
1324 : : PKG_EVENT_CONFLICTS,
1325 : : PKG_EVENT_TRIGGERS_BEGIN,
1326 : : PKG_EVENT_TRIGGER,
1327 : : PKG_EVENT_TRIGGERS_FINISHED,
1328 : : PKG_EVENT_PKG_ERRNO
1329 : : } pkg_event_t;
1330 : :
1331 : : struct pkg_event {
1332 : : pkg_event_t type;
1333 : : union {
1334 : : struct {
1335 : : const char *func;
1336 : : const char *arg;
1337 : : int no;
1338 : : } e_errno;
1339 : : struct {
1340 : : char *msg;
1341 : : } e_pkg_error;
1342 : : struct {
1343 : : char *msg;
1344 : : } e_pkg_notice;
1345 : : struct {
1346 : : int total;
1347 : : int done;
1348 : : } e_upd_add;
1349 : : struct {
1350 : : int total;
1351 : : int done;
1352 : : } e_upd_remove;
1353 : : struct {
1354 : : const char *url;
1355 : : } e_fetching;
1356 : : struct {
1357 : : struct pkg *pkg;
1358 : : } e_already_installed;
1359 : : struct {
1360 : : struct pkg *pkg;
1361 : : } e_install_begin;
1362 : : struct {
1363 : : struct pkg *pkg;
1364 : : struct pkg *old;
1365 : : } e_install_finished;
1366 : : struct {
1367 : : struct pkg *pkg;
1368 : : } e_deinstall_begin;
1369 : : struct {
1370 : : struct pkg *pkg;
1371 : : } e_deinstall_finished;
1372 : : struct {
1373 : : struct pkg *n;
1374 : : struct pkg *o;
1375 : : } e_upgrade_begin;
1376 : : struct {
1377 : : struct pkg *n;
1378 : : struct pkg *o;
1379 : : } e_upgrade_finished;
1380 : : struct {
1381 : : struct pkg *pkg;
1382 : : } e_extract_begin;
1383 : : struct {
1384 : : struct pkg *pkg;
1385 : : } e_extract_finished;
1386 : : struct {
1387 : : struct pkg *pkg;
1388 : : } e_delete_files_begin;
1389 : : struct {
1390 : : struct pkg *pkg;
1391 : : } e_delete_files_finished;
1392 : : struct {
1393 : : struct pkg *pkg;
1394 : : } e_add_deps_begin;
1395 : : struct {
1396 : : struct pkg *pkg;
1397 : : } e_add_deps_finished;
1398 : : struct {
1399 : : struct pkg *pkg;
1400 : : struct pkg_dep *dep;
1401 : : } e_missing_dep;
1402 : : struct {
1403 : : struct pkg *pkg;
1404 : : } e_locked;
1405 : : struct {
1406 : : struct pkg *pkg;
1407 : : int force;
1408 : : } e_required;
1409 : : struct {
1410 : : const char *repo;
1411 : : } e_remotedb;
1412 : : struct {
1413 : : struct pkg *pkg;
1414 : : struct pkg_file *file;
1415 : : const char *newsum;
1416 : : } e_file_mismatch;
1417 : : struct {
1418 : : struct pkg_plugin *plugin;
1419 : : char *msg;
1420 : : } e_plugin_info;
1421 : : struct {
1422 : : struct pkg_plugin *plugin;
1423 : : const char *func;
1424 : : const char *arg;
1425 : : int no;
1426 : : } e_plugin_errno;
1427 : : struct {
1428 : : struct pkg_plugin *plugin;
1429 : : char *msg;
1430 : : } e_plugin_error;
1431 : : struct {
1432 : : const char *pkg_name;
1433 : : } e_not_found;
1434 : : struct {
1435 : : const char *pkg_uid;
1436 : : const char *pkg_path;
1437 : : struct pkg_event_conflict *conflicts;
1438 : : } e_integrity_conflict;
1439 : : struct {
1440 : : int conflicting;
1441 : : } e_integrity_finished;
1442 : : struct {
1443 : : const char *reponame;
1444 : : int processed;
1445 : : } e_incremental_update;
1446 : : struct {
1447 : : int level;
1448 : : char *msg;
1449 : : } e_debug;
1450 : : struct {
1451 : : const char *msg;
1452 : : int deft;
1453 : : } e_query_yesno;
1454 : : struct {
1455 : : const char *msg;
1456 : : const char **items;
1457 : : int ncnt;
1458 : : int deft;
1459 : : } e_query_select;
1460 : : struct {
1461 : : pkg_sandbox_cb call;
1462 : : int fd;
1463 : : void *userdata;
1464 : : } e_sandbox_call;
1465 : : struct {
1466 : : pkg_sandbox_cb call;
1467 : : void *userdata;
1468 : : char **result;
1469 : : int64_t *len;
1470 : : } e_sandbox_call_str;
1471 : : struct {
1472 : : char *msg;
1473 : : } e_progress_start;
1474 : : struct {
1475 : : int64_t current;
1476 : : int64_t total;
1477 : : } e_progress_tick;
1478 : : struct {
1479 : : const char *msg;
1480 : : } e_pkg_message;
1481 : : struct {
1482 : : struct pkg *pkg;
1483 : : struct pkg_file *file;
1484 : : } e_file_missing;
1485 : : struct {
1486 : : void *data;
1487 : : void (*cleanup_cb)(void *data);
1488 : : } e_cleanup_callback;
1489 : : struct {
1490 : : struct pkg *p1;
1491 : : struct pkg *p2;
1492 : : const char *path;
1493 : : } e_conflicts;
1494 : : struct {
1495 : : const char *name;
1496 : : bool cleanup;
1497 : : } e_trigger;
1498 : : };
1499 : : };
1500 : :
1501 : : /**
1502 : : * Event callback mechanism. Events will be reported using this callback,
1503 : : * providing an event identifier and up to two event-specific pointers.
1504 : : */
1505 : : typedef int(*pkg_event_cb)(void *, struct pkg_event *);
1506 : :
1507 : : void pkg_event_register(pkg_event_cb cb, void *data);
1508 : :
1509 : : bool pkg_compiled_for_same_os_major(void);
1510 : : int pkg_ini(const char *, const char *, pkg_init_flags);
1511 : : int pkg_init(const char *, const char *);
1512 : : const char *pkg_libversion(void);
1513 : : int pkg_initialized(void);
1514 : : void pkg_shutdown(void);
1515 : :
1516 : : int pkg_test_filesum(struct pkg *);
1517 : :
1518 : : void pkgdb_cmd(int argc, char **argv);
1519 : : int pkg_sshserve(int fd);
1520 : :
1521 : : int pkg_key_new(struct pkg_key **, const char *, const char *,
1522 : : pkg_password_cb *);
1523 : : int pkg_key_create(struct pkg_key *, const struct iovec *, int);
1524 : : int pkg_key_pubkey(struct pkg_key *, char **, size_t *);
1525 : : int pkg_key_sign_data(struct pkg_key *, const unsigned char *, size_t,
1526 : : unsigned char **, size_t *);
1527 : : int pkg_key_info(struct pkg_key *, struct iovec **, int *);
1528 : : void pkg_key_free(struct pkg_key *);
1529 : :
1530 : : int pkg_repos_total_count(void);
1531 : : int pkg_repos_activated_count(void);
1532 : : int pkg_repos(struct pkg_repo **);
1533 : : const char *pkg_repo_url(struct pkg_repo *r);
1534 : : const char *pkg_repo_name(struct pkg_repo *r);
1535 : : const char *pkg_repo_key(struct pkg_repo *r);
1536 : : const char *pkg_repo_fingerprints(struct pkg_repo *r);
1537 : : signature_t pkg_repo_signature_type(struct pkg_repo *r);
1538 : : bool pkg_repo_enabled(struct pkg_repo *r);
1539 : : mirror_t pkg_repo_mirror_type(struct pkg_repo *r);
1540 : : unsigned pkg_repo_priority(struct pkg_repo *r);
1541 : : unsigned pkg_repo_ip_version(struct pkg_repo *r);
1542 : : struct pkg_repo *pkg_repo_find(const char *name);
1543 : : int pkg_repo_fetch_remote_tmp(struct pkg_repo *repo,
1544 : : const char *filename, const char *extension,
1545 : : time_t *t, int *rc, bool silent);
1546 : :
1547 : : /**
1548 : : * pkg_printf() and friends. These parallel the similarly named libc
1549 : : * functions printf(), fprintf() etc.
1550 : : */
1551 : :
1552 : : /**
1553 : : * print to stdout data from pkg as indicated by the format code format
1554 : : * @param ... Varargs list of struct pkg etc. supplying the data
1555 : : * @param format String with embedded %-escapes indicating what to print
1556 : : * @return count of the number of characters printed
1557 : : */
1558 : : int pkg_printf(const char * restrict format, ...);
1559 : :
1560 : : /**
1561 : : * print to stdout data from pkg as indicated by the format code format
1562 : : * @param ap Varargs list of struct pkg etc. supplying the data
1563 : : * @param format String with embedded %-escapes indicating what to print
1564 : : * @return count of the number of characters printed
1565 : : */
1566 : : int pkg_vprintf(const char * restrict format, va_list ap);
1567 : :
1568 : : /**
1569 : : * print to named stream from pkg as indicated by the format code format
1570 : : * @param ... Varargs list of struct pkg etc. supplying the data
1571 : : * @param format String with embedded %-escapes indicating what to output
1572 : : * @return count of the number of characters printed
1573 : : */
1574 : : int pkg_fprintf(FILE * restrict stream, const char * restrict format, ...);
1575 : :
1576 : : /**
1577 : : * print to named stream from pkg as indicated by the format code format
1578 : : * @param ap varargs arglist
1579 : : * @param format String with embedded %-escapes indicating what to output
1580 : : * @return count of the number of characters printed
1581 : : */
1582 : : int pkg_vfprintf(FILE * restrict stream, const char * restrict format,
1583 : : va_list ap);
1584 : :
1585 : : /**
1586 : : * print to file descriptor fd data from pkg as indicated by the format
1587 : : * code format
1588 : : * @param fd Previously opened file descriptor to print to
1589 : : * @param ... Varargs list of struct pkg etc. supplying the data
1590 : : * @param format String with embedded %-escapes indicating what to print
1591 : : * @return count of the number of characters printed
1592 : : */
1593 : : int pkg_dprintf(int fd, const char * restrict format, ...);
1594 : :
1595 : : /**
1596 : : * print to file descriptor fd data from pkg as indicated by the format
1597 : : * code format
1598 : : * @param fd Previously opened file descriptor to print to
1599 : : * @param ap Varargs list of struct pkg etc. supplying the data
1600 : : * @param format String with embedded %-escapes indicating what to print
1601 : : * @return count of the number of characters printed
1602 : : */
1603 : : int pkg_vdprintf(int fd, const char * restrict format, va_list ap);
1604 : :
1605 : : /**
1606 : : * print to buffer str of given size data from pkg as indicated by the
1607 : : * format code format as a NULL-terminated string
1608 : : * @param str Character array buffer to receive output
1609 : : * @param size Length of the buffer str
1610 : : * @param ... Varargs list of struct pkg etc. supplying the data
1611 : : * @param format String with embedded %-escapes indicating what to output
1612 : : * @return count of the number of characters that would have been output
1613 : : * disregarding truncation to fit size
1614 : : */
1615 : : int pkg_snprintf(char * restrict str, size_t size,
1616 : : const char * restrict format, ...);
1617 : :
1618 : : /**
1619 : : * print to buffer str of given size data from pkg as indicated by the
1620 : : * format code format as a NULL-terminated string
1621 : : * @param str Character array buffer to receive output
1622 : : * @param size Length of the buffer str
1623 : : * @param ap Varargs list of struct pkg etc. supplying the data
1624 : : * @param format String with embedded %-escapes indicating what to output
1625 : : * @return count of the number of characters that would have been output
1626 : : * disregarding truncation to fit size
1627 : : */
1628 : : int pkg_vsnprintf(char * restrict str, size_t size,
1629 : : const char * restrict format,va_list ap);
1630 : :
1631 : : /**
1632 : : * Allocate a string buffer ret sufficiently big to contain formatted
1633 : : * data data from pkg as indicated by the format code format
1634 : : * @param ret location of pointer to be set to point to buffer containing
1635 : : * result
1636 : : * @param ... Varargs list of struct pkg etc. supplying the data
1637 : : * @param format String with embedded %-escapes indicating what to output
1638 : : * @return count of the number of characters printed
1639 : : */
1640 : : int pkg_asprintf(char **ret, const char * restrict format, ...);
1641 : :
1642 : : /**
1643 : : * Allocate a string buffer ret sufficiently big to contain formatted
1644 : : * data data from pkg as indicated by the format code format
1645 : : * @param ret location of pointer to be set to point to buffer containing
1646 : : * result
1647 : : * @param ap Varargs list of struct pkg etc. supplying the data
1648 : : * @param format String with embedded %-escapes indicating what to output
1649 : : * @return count of the number of characters printed
1650 : : */
1651 : : int pkg_vasprintf(char **ret, const char * restrict format, va_list ap);
1652 : :
1653 : : bool pkg_has_message(struct pkg *p);
1654 : : bool pkg_is_locked(const struct pkg * restrict p);
1655 : :
1656 : :
1657 : : /**
1658 : : * Defines how many chars of checksum are there in a package's name
1659 : : * We define this number as sufficient for 24k packages.
1660 : : * To find out probability of collision it is possible to use the following
1661 : : * python function to calculate 'birthday paradox' probability:
1662 : : * def bp(m, n):
1663 : : * power = -(n * n) / (2. * m)
1664 : : * return 1. - exp(power)
1665 : : *
1666 : : * For our choice of 2^40 (or 10 hex characters) it is:
1667 : : * >>> bp(float(2 ** 40), 24500.)
1668 : : * 0.00027292484660568217
1669 : : *
1670 : : * And it is negligible probability
1671 : : */
1672 : : #define PKG_FILE_CKSUM_CHARS 10
1673 : :
1674 : : char *pkg_utils_tokenize(char **);
1675 : : int pkg_utils_count_spaces(const char *);
1676 : : int pkg_mkdirs(const char *path);
1677 : : bool pkg_copy_file(int from, int to);
1678 : : int pkg_add_port(struct pkgdb *db, struct pkg *pkg, const char *root, \
1679 : : const char *locationn, bool testing);
1680 : : char *pkg_absolutepath(const char *src, char *dest, size_t dest_len, bool fromroot);
1681 : :
1682 : : void pkg_cache_full_clean(void);
1683 : :
1684 : : const char *pkg_get_cachedir(void);
1685 : : int pkg_get_cachedirfd(void);
1686 : : int pkg_get_dbdirfd(void);
1687 : :
1688 : : int pkg_namecmp(struct pkg *, struct pkg *);
1689 : :
1690 : : #ifndef PKG_FORMAT_ATTRIBUTE
1691 : : #ifdef __GNUC__
1692 : : #define PKG_FORMAT_ATTRIBUTE(x, y) __attribute__ ((format (printf, (x), (y))));
1693 : : #else
1694 : : #define PKG_FORMAT_ATTRIBUTE(x, y)
1695 : : #endif
1696 : : #endif
1697 : : void pkg_emit_error(const char *fmt, ...) PKG_FORMAT_ATTRIBUTE(1, 2);
1698 : : void pkg_emit_notice(const char *fmt, ...) PKG_FORMAT_ATTRIBUTE(1, 2);
1699 : :
1700 : : /**
1701 : : * Default implementation for handling the PKG_EVENT_SANDBOX_CALL event.
1702 : : */
1703 : : int pkg_handle_sandboxed_call(pkg_sandbox_cb func, int fd, void *ud);
1704 : : /**
1705 : : * Default implementation for handling the PKG_EVENT_SANDBOX_GET_STRING event.
1706 : : */
1707 : : int pkg_handle_sandboxed_get_string(pkg_sandbox_cb func, char **result, int64_t *len, void *ud);
1708 : : /**
1709 : : * A helper function that switches the process to the "nobody" user.
1710 : : */
1711 : : void pkg_drop_privileges(void);
1712 : :
1713 : : struct pkg_create *pkg_create_new(void);
1714 : : void pkg_create_free(struct pkg_create *);
1715 : : bool pkg_create_set_format(struct pkg_create *, const char *);
1716 : : void pkg_create_set_compression_threads(struct pkg_create *, int);
1717 : : void pkg_create_set_compression_level(struct pkg_create *, int);
1718 : : void pkg_create_set_overwrite(struct pkg_create *, bool);
1719 : : void pkg_create_set_rootdir(struct pkg_create *, const char *);
1720 : : void pkg_create_set_output_dir(struct pkg_create *, const char *);
1721 : : void pkg_create_set_timestamp(struct pkg_create *, time_t);
1722 : : void pkg_create_set_expand_manifest(struct pkg_create *, bool);
1723 : : int pkg_create(struct pkg_create *, const char *, const char *, bool);
1724 : : int pkg_create_i(struct pkg_create *, struct pkg *, bool);
1725 : : int pkg_execute_deferred_triggers(void);
1726 : : int pkg_add_triggers(void);
1727 : :
1728 : : struct pkg_kvlist_iterator *pkg_kvlist_iterator(struct pkg_kvlist *l);
1729 : : struct pkg_kv *pkg_kvlist_next(struct pkg_kvlist_iterator *it);
1730 : : struct pkg_stringlist_iterator *pkg_stringlist_iterator(struct pkg_stringlist *l);
1731 : : const char *pkg_stringlist_next(struct pkg_stringlist_iterator *it);
1732 : : struct pkg_el *pkg_get_element(struct pkg *p, pkg_attr a);
1733 : : pkg_kvl_t *pkg_external_libs_version(void);
1734 : :
1735 : : static inline void
1736 : 307 : pkg_get_s(struct pkg *p, pkg_attr a, const char **val)
1737 : : {
1738 : 307 : struct pkg_el *e = pkg_get_element(p, a);
1739 : 307 : *val = NULL;
1740 : :
1741 [ + - - - : 307 : switch (e->type) {
- - ]
1742 : : case PKG_STR:
1743 : 307 : *val = e->string;
1744 : 307 : break;
1745 : : case PKG_BOOLEAN:
1746 : 0 : *val = e->boolean ? "true" : "false";
1747 : 0 : break;
1748 : : case PKG_INTEGER:
1749 : 0 : break;
1750 : : case PKG_KVLIST:
1751 : 0 : free(e->stringlist);
1752 : : case PKG_STRINGLIST:
1753 : 0 : free(e->kvlist);
1754 : 0 : break;
1755 : : }
1756 : 307 : free(e);
1757 : 307 : };
1758 : :
1759 : : static inline void
1760 : 490 : pkg_get_i(struct pkg *p, pkg_attr a, int64_t *val)
1761 : : {
1762 : 490 : struct pkg_el *e = pkg_get_element(p, a);
1763 : 490 : int64_t ret = -1;
1764 : :
1765 [ - - + - : 490 : switch (e->type) {
- - ]
1766 : : case PKG_STR:
1767 : 0 : ret = e->string != NULL;
1768 : 0 : break;
1769 : : case PKG_BOOLEAN:
1770 : 0 : ret = e->boolean;
1771 : 0 : break;
1772 : : case PKG_INTEGER:
1773 : 490 : ret = e->integer;
1774 : 490 : break;
1775 : : case PKG_KVLIST:
1776 : 0 : free(e->stringlist);
1777 : 0 : break;
1778 : : case PKG_STRINGLIST:
1779 : 0 : free(e->kvlist);
1780 : 0 : break;
1781 : : }
1782 : 490 : free(e);
1783 : 490 : *val = ret;
1784 : 490 : };
1785 : :
1786 : : static inline void
1787 : 13 : pkg_get_b(struct pkg *p, pkg_attr a, bool *val)
1788 : : {
1789 : 13 : struct pkg_el *e = pkg_get_element(p, a);
1790 : 13 : bool ret = false;
1791 : :
1792 [ - + - - : 13 : switch (e->type) {
- - ]
1793 : : case PKG_STR:
1794 : 0 : ret = e->string != NULL;
1795 : 0 : break;
1796 : : case PKG_BOOLEAN:
1797 : 13 : ret = e->boolean;
1798 : 13 : break;
1799 : : case PKG_INTEGER:
1800 : 0 : ret = e->integer > 0;
1801 : 0 : break;
1802 : : case PKG_KVLIST:
1803 : 0 : free(e->stringlist);
1804 : 0 : break;
1805 : : case PKG_STRINGLIST:
1806 : 0 : free(e->kvlist);
1807 : 0 : break;
1808 : : }
1809 : 13 : free(e);
1810 : 13 : *val = ret;
1811 : 13 : };
1812 : :
1813 : : static inline void
1814 : 8 : pkg_get_kv(struct pkg *p, pkg_attr a, struct pkg_kvlist **val)
1815 : : {
1816 : 8 : struct pkg_el *e = pkg_get_element(p, a);
1817 : 8 : struct pkg_kvlist *kv = NULL;
1818 : :
1819 [ - + ]: 8 : if (e->type == PKG_KVLIST)
1820 : 8 : kv = e->kvlist;
1821 : 8 : free(e);
1822 : 8 : *val = kv;
1823 : 8 : }
1824 : :
1825 : : static inline void
1826 : 0 : pkg_get_sl(struct pkg *p, pkg_attr a, struct pkg_stringlist **val)
1827 : : {
1828 : 0 : struct pkg_el *e = pkg_get_element(p, a);
1829 : 0 : struct pkg_stringlist *sl = NULL;
1830 : :
1831 [ # # ]: 0 : if (e->type == PKG_STRINGLIST)
1832 : 0 : sl = e->stringlist;
1833 : 0 : free(e);
1834 : 0 : *val = sl;
1835 : 0 : }
1836 : : static inline void
1837 : : pkg_get_invalid(struct pkg *p __attribute__((__unused__)),
1838 : : pkg_attr a __attribute__((__unused__)),
1839 : : void *v __attribute__((__unused__)))
1840 : : {
1841 : : fprintf(stderr, "invalid attribute type for pkg_get\n");
1842 : : abort();
1843 : : }
1844 : :
1845 : : int pkg_set_s(struct pkg *pkg, pkg_attr a, const char *val);
1846 : : int pkg_set_i(struct pkg *pkg, pkg_attr a, int64_t i);
1847 : : int pkg_set_b(struct pkg *pkg, pkg_attr a, bool b);
1848 : : static inline int
1849 : : pkg_set_invalid(struct pkg *p __attribute__((__unused__)),
1850 : : pkg_attr a __attribute__((__unused__)),
1851 : : void *v __attribute__((__unused__)))
1852 : : {
1853 : : fprintf(stderr, "Invalid attribute type for pkg_set\n");
1854 : : abort();
1855 : : }
1856 : :
1857 : : #define pkg_get(p, t, a) _Generic((a), \
1858 : : const char **: pkg_get_s, \
1859 : : int64_t *: pkg_get_i, \
1860 : : bool *: pkg_get_b, \
1861 : : struct pkg_kvlist **: pkg_get_kv, \
1862 : : struct pkg_stringlist **: pkg_get_sl, \
1863 : : default: pkg_get_invalid)(p, t, a)
1864 : :
1865 : : #define pkg_set(p, t, a) _Generic((a), \
1866 : : const char *: pkg_set_s, \
1867 : : char *: pkg_set_s, \
1868 : : int64_t: pkg_set_i, \
1869 : : bool: pkg_set_b, \
1870 : : default: pkg_set_invalid)(p, t, a)
1871 : :
1872 : : #ifdef __cplusplus
1873 : : }
1874 : : #endif
1875 : : #endif
|
