diff --git a/libpkg/Makefile.am b/libpkg/Makefile.am index b075314..f01ba83 100644 --- a/libpkg/Makefile.am +++ b/libpkg/Makefile.am @@ -32,7 +32,6 @@ libpkg_la_SOURCES= pkg.c \ pkg_jobs_conflicts.c \ pkg_jobs_universe.c \ pkg_manifest.c \ - pkg_object.c \ pkg_ports.c \ pkg_printf.c \ pkg_repo.c \ diff --git a/libpkg/fetch.c b/libpkg/fetch.c index 06ae143..33fbdb9 100644 --- a/libpkg/fetch.c +++ b/libpkg/fetch.c @@ -335,7 +335,7 @@ start_ssh(struct pkg_repo *repo, struct url *u, off_t *sz) int sshout[2]; const char *argv[4]; - ssh_args = pkg_object_string(pkg_config_get("PKG_SSH_ARGS")); + ssh_args = pkg_config[PKG_CONFIG_SSH_ARGS]->value.string; if (repo->ssh == NULL) { /* Use socket pair because pipe have blocking issues */ @@ -471,8 +471,8 @@ pkg_fetch_file_to_fd(struct pkg_repo *repo, const char *url, int dest, time_t *t bool pkg_url_scheme = false; struct sbuf *fetchOpts = NULL; - max_retry = pkg_object_int(pkg_config_get("FETCH_RETRY")); - fetch_timeout = pkg_object_int(pkg_config_get("FETCH_TIMEOUT")); + max_retry = pkg_config[PKG_CONFIG_FETCH_RETRY]->value.number; + fetch_timeout = pkg_config[PKG_CONFIG_FETCH_TIMEOUT]->value.number; fetchTimeout = (int) fetch_timeout; diff --git a/libpkg/packing.c b/libpkg/packing.c index 4a169f6..6bf5203 100644 --- a/libpkg/packing.c +++ b/libpkg/packing.c @@ -214,7 +214,7 @@ packing_append_file_attr(struct packing *pack, const char *filepath, if (perm != 0) archive_entry_set_perm(entry, perm); - unset_timestamp = pkg_object_bool(pkg_config_get("UNSET_TIMESTAMP")); + unset_timestamp = pkg_config[PKG_CONFIG_UNSET_TIMESTAMP]->value.boolean; if (unset_timestamp) { archive_entry_unset_atime(entry); diff --git a/libpkg/pkg.c b/libpkg/pkg.c index 56532fb..a731ff4 100644 --- a/libpkg/pkg.c +++ b/libpkg/pkg.c @@ -720,7 +720,7 @@ pkg_adduid(struct pkg *pkg, const char *name, const char *uidstr) HASH_FIND_STR(pkg->users, name, u); if (u != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate user listing: %s, fatal (developer mode)", name); return (EPKG_FATAL); } else { @@ -759,7 +759,7 @@ pkg_addgid(struct pkg *pkg, const char *name, const char *gidstr) HASH_FIND_STR(pkg->groups, name, g); if (g != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate group listing: %s, fatal (developer mode)", name); return (EPKG_FATAL); } else { @@ -800,7 +800,7 @@ pkg_adddep(struct pkg *pkg, const char *name, const char *origin, const char *ve pkg_debug(3, "Pkg: add a new dependency origin: %s, name: %s, version: %s", origin, name, version); HASH_FIND_STR(pkg->deps, origin, d); if (d != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("%s-%s: duplicate dependency listing: %s-%s, fatal (developer mode)", pkg->name, pkg->version, name, version); return (EPKG_FATAL); @@ -871,7 +871,7 @@ pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const ch if (check_duplicates) { HASH_FIND_STR(pkg->files, path, f); if (f != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate file listing: %s, fatal (developer mode)", f->path); return (EPKG_FATAL); } else { @@ -912,7 +912,7 @@ pkg_addconfig_file(struct pkg *pkg, const char *path, const char *content) HASH_FIND_STR(pkg->config_files, path, f); if (f != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate file listing: %s, fatal (developer mode)", f->path); return (EPKG_FATAL); } else { @@ -940,7 +940,7 @@ pkg_strel_add(struct pkg_strel **list, const char *val, const char *title) LL_FOREACH(*list, c) { if (strcmp(c->value, val) == 0) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate %s listing: %s, fatal" " (developer mode)", title, val); return (EPKG_FATAL); @@ -978,7 +978,7 @@ pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char if (check_duplicates) { HASH_FIND_STR(pkg->dirs, path, d); if (d != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate directory listing: %s, fatal (developer mode)", d->path); return (EPKG_FATAL); } else { @@ -1171,7 +1171,7 @@ pkg_addoption(struct pkg *pkg, const char *key, const char *value) pkg_option_new(&o); sbuf_set(&o->key, key); } else if ( o->value != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate options listing: %s, fatal (developer mode)", key); return (EPKG_FATAL); } else { @@ -1209,7 +1209,7 @@ pkg_addoption_default(struct pkg *pkg, const char *key, pkg_option_new(&o); sbuf_set(&o->key, key); } else if ( o->default_value != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate default value for option: %s, fatal (developer mode)", key); return (EPKG_FATAL); } else { @@ -1246,7 +1246,7 @@ pkg_addoption_description(struct pkg *pkg, const char *key, pkg_option_new(&o); sbuf_set(&o->key, key); } else if ( o->description != NULL) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate description for option: %s, fatal (developer mode)", key); return (EPKG_FATAL); } else { @@ -1390,7 +1390,7 @@ pkg_kv_add(struct pkg_kv **list, const char *key, const char *val, const char *t LL_FOREACH(*list, kv) { if (strcmp(kv->key, key) == 0) { - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) { + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) { pkg_emit_error("duplicate %s: %s, fatal" " (developer mode)", title, key); return (EPKG_FATAL); @@ -1914,9 +1914,7 @@ int pkg_open_root_fd(struct pkg *pkg) { const char *path; - const ucl_object_t *obj; - obj = NULL; if (pkg->rootfd != -1) return (EPKG_OK); @@ -1929,7 +1927,7 @@ pkg_open_root_fd(struct pkg *pkg) if ((pkg->rootfd = open(path , O_DIRECTORY|O_CLOEXEC)) >= 0 ) return (EPKG_OK); - pkg_emit_errno("open", obj ? pkg_object_string(obj) : "/"); + pkg_emit_errno("open", path); return (EPKG_FATAL); } diff --git a/libpkg/pkg.h.in b/libpkg/pkg.h.in index 3218665..3c2691b 100644 --- a/libpkg/pkg.h.in +++ b/libpkg/pkg.h.in @@ -83,7 +83,6 @@ struct pkg_dep; struct pkg_conflict; struct pkg_file; struct pkg_dir; -struct pkg_strel; struct pkg_option; struct pkg_license; struct pkg_user; @@ -91,6 +90,27 @@ struct pkg_group; struct pkg_shlib; struct pkg_provide; struct pkg_config_file; +extern struct pkg_config **pkg_config; +struct pkg_config { + int8_t type; + char *name; + char *desc; + union { + int64_t number; + char *string; + bool boolean; + struct pkg_kv *kv; + struct pkg_strel *list; + } value; + union { + int64_t number; + const char *string; + bool boolean; + struct pkg_kv *kv; + struct pkg_strel *list; + + } def; +}; struct pkgdb; struct pkgdb_it; @@ -105,15 +125,17 @@ struct pkg_plugin; struct pkg_manifest_key; struct pkg_manifest_parser; -typedef struct ucl_object_s pkg_object; -typedef void * pkg_iter; - struct pkg_kv { char *key; char *value; struct pkg_kv *next; }; +struct pkg_strel { + char *value; + struct pkg_strel *next; +}; + /** * The system-wide pkg(8) status: ie. is it a) installed or otherwise * available on the sysem, b) database (local.sqlite) initialised and @@ -377,9 +399,9 @@ typedef enum { PKG_BOOL, PKG_INT, PKG_ARRAY, - PKG_OBJECT, + PKG_KEYVALUE, PKG_NULL -} pkg_object_t; +} pkg_config_t; /** * Keys for accessing pkg plugin data @@ -511,6 +533,56 @@ typedef enum { #define PKG_OPEN_TRY (0x1 << 2) /** + * Configuration entries + */ +enum { + PKG_CONFIG_DBDIR = 0, + PKG_CONFIG_CACHEDIR = 1, + PKG_CONFIG_PORTSDIR = 2, + PKG_CONFIG_INDEXDIR = 3, + PKG_CONFIG_INDEXFILE = 4, + PKG_CONFIG_HANDLE_RC_SCRIPTS = 5, + PKG_CONFIG_ASSUME_ALWAYS_YES = 6, + PKG_CONFIG_REPOS_DIR = 7, + PKG_CONFIG_PLIST_KEYWORDS_DIR = 8, + PKG_CONFIG_SYSLOG = 9, + PKG_CONFIG_ABI = 10, + PKG_CONFIG_ALTABI = 11, + PKG_CONFIG_DEVELOPER_MODE = 12, + PKG_CONFIG_VULNXML_SITE = 13, + PKG_CONFIG_FETCH_RETRY = 14, + PKG_CONFIG_PLUGINS_DIR = 15, + PKG_CONFIG_ENABLE_PLUGINS = 16, + PKG_CONFIG_PLUGINS = 17, + PKG_CONFIG_DEBUG_SCRIPTS = 18, + PKG_CONFIG_PLUGINS_CONF_DIR = 19, + PKG_CONFIG_PERMISSIVE = 20, + PKG_CONFIG_REPO_AUTOUPDATE = 21, + PKG_CONFIG_NAMESERVER = 22, + PKG_CONFIG_EVENT_PIPE = 23, + PKG_CONFIG_FETCH_TIMEOUT = 24, + PKG_CONFIG_UNSET_TIMESTAMP = 25, + PKG_CONFIG_SSH_RESTRICT_DIR = 26, + PKG_CONFIG_ENV = 27, + PKG_CONFIG_SSH_ARGS = 28, + PKG_CONFIG_DEBUG_LEVEL = 29, + PKG_CONFIG_ALIAS = 30, + PKG_CONFIG_CUDF_SOLVER = 31, + PKG_CONFIG_SAT_SOLVER = 32, + PKG_CONFIG_RUN_SCRIPTS = 33, + PKG_CONFIG_CASE_SENSITIVE_MATCH = 34, + PKG_CONFIG_LOCK_WAIT = 35, + PKG_CONFIG_LOCK_RETRIES = 36, + PKG_CONFIG_SQLITE_PROFILE = 37, + PKG_CONFIG_WORKERS_COUNT = 38, + PKG_CONFIG_READ_LOCK = 39, + PKG_CONFIG_PLIST_ACCEPT_DIRECTORIES = 40, + PKG_CONFIG_IP_VERSION = 41, + PKG_CONFIG_AUTOMERGE = 42, + PKG_CONFIG_END = 43 /* should always be the last */ +}; + +/** * test if pkg is installed and activated. * @param count If all the tests pass, and count is non-NULL, * write the number of installed packages into *count @@ -1127,8 +1199,8 @@ int pkg_plugin_set(struct pkg_plugin *p, pkg_plugin_key key, const char *str); const char *pkg_plugin_get(struct pkg_plugin *p, pkg_plugin_key key); void *pkg_plugin_func(struct pkg_plugin *p, const char *func); -int pkg_plugin_conf_add(struct pkg_plugin *p, pkg_object_t type, const char *key, const char *def); -const pkg_object *pkg_plugin_conf(struct pkg_plugin *p); +int pkg_plugin_conf_add(struct pkg_plugin *p, pkg_config_t type, const char *key, const char *def); +struct pkg_config **pkg_plugin_conf(struct pkg_plugin *p); int pkg_plugin_parse(struct pkg_plugin *p); void pkg_plugin_errno(struct pkg_plugin *p, const char *func, const char *arg); @@ -1146,20 +1218,6 @@ int pkg_plugin_hook_register(struct pkg_plugin *p, pkg_plugin_hook_t hook, pkg_p * Get the value of a configuration key */ -const pkg_object *pkg_conf(void); -const pkg_object *pkg_config_get(const char *); -pkg_object_t pkg_object_type(const pkg_object *); -const pkg_object *pkg_object_find(const pkg_object *o, const char *key); -int64_t pkg_object_int(const pkg_object *o); -bool pkg_object_bool(const pkg_object *o); -const char *pkg_object_string(const pkg_object *o); -void pkg_object_free(pkg_object *o); -const char *pkg_object_key(const pkg_object *); -const pkg_object *pkg_object_iterate(const pkg_object *, pkg_iter *); -unsigned pkg_object_count(const pkg_object *); -const char *pkg_object_dump(const pkg_object *o); -const char *pkg_config_dump(void); - /** * @todo Document */ diff --git a/libpkg/pkg_add.c b/libpkg/pkg_add.c index b563791..a6f4b6a 100644 --- a/libpkg/pkg_add.c +++ b/libpkg/pkg_add.c @@ -146,7 +146,7 @@ do_extract(struct archive *a, struct archive_entry *ae, const char *location, const struct pkg_file *lf, *rf; struct pkg_config_file *lcf, *rcf; struct sbuf *newconf; - bool automerge = pkg_object_bool(pkg_config_get("AUTOMERGE")); + bool automerge = pkg_config[PKG_CONFIG_AUTOMERGE]->value.boolean; #ifndef HAVE_ARC4RANDOM srand(time(NULL)); @@ -393,7 +393,7 @@ pkg_add_cleanup_old(struct pkg *old, struct pkg *new, int flags) int ret = EPKG_OK; bool handle_rc; - handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS")); + handle_rc = pkg_config[PKG_CONFIG_HANDLE_RC_SCRIPTS]->value.boolean; if (handle_rc) pkg_start_stop_rc_scripts(old, PKG_RC_STOP); @@ -556,7 +556,7 @@ pkg_add_common(struct pkgdb *db, const char *path, unsigned flags, * and that the service is running */ - handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS")); + handle_rc = pkg_config[PKG_CONFIG_HANDLE_RC_SCRIPTS]->value.boolean; if (handle_rc) pkg_start_stop_rc_scripts(pkg, PKG_RC_START); diff --git a/libpkg/pkg_config.c b/libpkg/pkg_config.c index 3f9ddda..4c10a03 100644 --- a/libpkg/pkg_config.c +++ b/libpkg/pkg_config.c @@ -73,262 +73,262 @@ struct config_entry { static char myabi[BUFSIZ], myabi_legacy[BUFSIZ]; static struct pkg_repo *repos = NULL; -ucl_object_t *config = NULL; +struct pkg_config **config; static struct config_entry c[] = { - { + [PKG_CONFIG_DBDIR] = { PKG_STRING, "PKG_DBDIR", "/var/db/pkg", "Where the package databases are stored", }, - { + [PKG_CONFIG_CACHEDIR] = { PKG_STRING, "PKG_CACHEDIR", "/var/cache/pkg", "Directory containing cache of downloaded packages", }, - { + [PKG_CONFIG_PORTSDIR] = { PKG_STRING, "PORTSDIR", "/usr/ports", "Location of the ports collection", }, - { + [PKG_CONFIG_INDEXDIR] = { PKG_STRING, "INDEXDIR", NULL, /* Default to PORTSDIR unless defined */ "Location of the ports INDEX", }, - { + [PKG_CONFIG_INDEXFILE] = { PKG_STRING, "INDEXFILE", INDEXFILE, "Filename of the ports INDEX", }, - { + [PKG_CONFIG_HANDLE_RC_SCRIPTS] = { PKG_BOOL, "HANDLE_RC_SCRIPTS", "NO", "Automatically handle restarting services", }, - { + [PKG_CONFIG_ASSUME_ALWAYS_YES] = { PKG_BOOL, "ASSUME_ALWAYS_YES", "NO", "Answer 'yes' to all pkg(8) questions", }, - { + [PKG_CONFIG_REPOS_DIR] = { PKG_ARRAY, "REPOS_DIR", "/etc/pkg/,"PREFIX"/etc/pkg/repos/", "Location of the repository configuration files" }, - { + [PKG_CONFIG_PLIST_KEYWORDS_DIR] = { PKG_STRING, "PLIST_KEYWORDS_DIR", NULL, "Directory containing definitions of plist keywords", }, - { + [PKG_CONFIG_SYSLOG] = { PKG_BOOL, "SYSLOG", "YES", "Log pkg(8) operations via syslog(3)", }, - { + [PKG_CONFIG_ABI] = { PKG_STRING, "ABI", myabi, "Override the automatically detected ABI", }, - { + [PKG_CONFIG_ALTABI] = { PKG_STRING, "ALTABI", myabi_legacy, "Override the automatically detected old-form ABI", }, - { + [PKG_CONFIG_DEVELOPER_MODE] = { PKG_BOOL, "DEVELOPER_MODE", "NO", "Add extra strict, pedantic warnings as an aid to package maintainers", }, - { + [PKG_CONFIG_VULNXML_SITE] = { PKG_STRING, "VULNXML_SITE", DEFAULT_VULNXML_URL, "URL giving location of the vulnxml database", }, - { + [PKG_CONFIG_FETCH_RETRY] = { PKG_INT, "FETCH_RETRY", "3", "How many times to retry fetching files", }, - { + [PKG_CONFIG_PLUGINS_DIR] = { PKG_STRING, "PKG_PLUGINS_DIR", PREFIX"/lib/pkg/", "Directory which pkg(8) will load plugins from", }, - { + [PKG_CONFIG_ENABLE_PLUGINS] = { PKG_BOOL, "PKG_ENABLE_PLUGINS", "YES", "Activate plugin support", }, - { + [PKG_CONFIG_PLUGINS] = { PKG_ARRAY, "PLUGINS", NULL, "List of plugins that pkg(8) should load", }, - { + [PKG_CONFIG_DEBUG_SCRIPTS] = { PKG_BOOL, "DEBUG_SCRIPTS", "NO", "Run shell scripts in verbose mode to facilitate debugging", }, - { + [PKG_CONFIG_PLUGINS_CONF_DIR] = { PKG_STRING, "PLUGINS_CONF_DIR", PREFIX"/etc/pkg/", "Directory containing plugin configuration data", }, - { + [PKG_CONFIG_PERMISSIVE] = { PKG_BOOL, "PERMISSIVE", "NO", "Permit package installation despite presence of conflicting packages", }, - { + [PKG_CONFIG_REPO_AUTOUPDATE] = { PKG_BOOL, "REPO_AUTOUPDATE", "YES", "Automatically update repository catalogues prior to package updates", }, - { + [PKG_CONFIG_NAMESERVER] = { PKG_STRING, "NAMESERVER", NULL, "Use this nameserver when looking up addresses", }, - { + [PKG_CONFIG_EVENT_PIPE] = { PKG_STRING, "EVENT_PIPE", NULL, "Send all events to the specified fifo or Unix socket", }, - { + [PKG_CONFIG_FETCH_TIMEOUT] = { PKG_INT, "FETCH_TIMEOUT", "30", "Number of seconds before fetch(3) times out", }, - { + [PKG_CONFIG_UNSET_TIMESTAMP] = { PKG_BOOL, "UNSET_TIMESTAMP", "NO", "Do not include timestamps in the package", }, - { + [PKG_CONFIG_SSH_RESTRICT_DIR] = { PKG_STRING, "SSH_RESTRICT_DIR", NULL, "Directory the ssh subsystem will be restricted to", }, - { - PKG_OBJECT, + [PKG_CONFIG_ENV] = { + PKG_KEYVALUE, "PKG_ENV", NULL, "Environment variables pkg will use", }, - { + [PKG_CONFIG_SSH_ARGS] = { PKG_STRING, "PKG_SSH_ARGS", NULL, "Extras arguments to pass to ssh(1)", }, - { + [PKG_CONFIG_DEBUG_LEVEL] = { PKG_INT, "DEBUG_LEVEL", "0", "Level for debug messages", }, - { - PKG_OBJECT, + [PKG_CONFIG_ALIAS] = { + PKG_KEYVALUE, "ALIAS", NULL, "Command aliases", }, - { + [PKG_CONFIG_CUDF_SOLVER] = { PKG_STRING, "CUDF_SOLVER", NULL, "Experimental: tells pkg to use an external CUDF solver", }, - { + [PKG_CONFIG_SAT_SOLVER] = { PKG_STRING, "SAT_SOLVER", NULL, "Experimental: tells pkg to use an external SAT solver", }, - { + [PKG_CONFIG_RUN_SCRIPTS] = { PKG_BOOL, "RUN_SCRIPTS", "YES", "Run post/pre actions scripts", }, - { + [PKG_CONFIG_CASE_SENSITIVE_MATCH] = { PKG_BOOL, "CASE_SENSITIVE_MATCH", "NO", "Match package names case sensitively", }, - { + [PKG_CONFIG_LOCK_WAIT] = { PKG_INT, "LOCK_WAIT", "1", "Wait time to regain a lock if it is not available" }, - { + [PKG_CONFIG_LOCK_RETRIES] = { PKG_INT, "LOCK_RETRIES", "5", "Retries performed to obtain a lock" }, - { + [PKG_CONFIG_SQLITE_PROFILE] = { PKG_BOOL, "SQLITE_PROFILE", "NO", "Profile sqlite queries" }, - { + [PKG_CONFIG_WORKERS_COUNT] = { PKG_INT, "WORKERS_COUNT", "0", "How many workers are used for pkg-repo (hw.ncpu if 0)" }, - { + [PKG_CONFIG_READ_LOCK] = { PKG_BOOL, "READ_LOCK", "NO", "Use read locking for query database" }, - { + [PKG_CONFIG_PLIST_ACCEPT_DIRECTORIES] = { PKG_BOOL, "PLIST_ACCEPT_DIRECTORIES", "NO", "Accept directories listed like plain files in plist" }, - { + [PKG_CONFIG_IP_VERSION] = { PKG_INT, "IP_VERSION", "0", "Restrict network access to IPv4 or IPv6 only" }, - { + [PKG_CONFIG_AUTOMERGE] = { PKG_BOOL, "AUTOMERGE", "YES", @@ -399,17 +399,6 @@ pkg_initialized(void) return (parsed); } -const pkg_object * -pkg_config_get(const char *key) { - return (ucl_object_find_key(config, key)); -} - -const char * -pkg_config_dump(void) -{ - return (pkg_object_dump(config)); -} - static void disable_plugins_if_static(void) { @@ -419,7 +408,7 @@ disable_plugins_if_static(void) /* if dlh is NULL then we are in static binary */ if (dlh == NULL) - ucl_object_replace_key(config, ucl_object_frombool(false), "ENABLE_PLUGINS", 14, false); + pkg_config[PKG_CONFIG_ENABLE_PLUGINS]->value.boolean = false; else dlclose(dlh); @@ -574,7 +563,7 @@ add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_ini use_ipvx = 6; if (use_ipvx != 4 && use_ipvx != 6) - use_ipvx = pkg_object_int(pkg_config_get("IP_VERSION")); + use_ipvx = pkg_config[PKG_CONFIG_IP_VERSION]->value.number; if (use_ipvx == 4) r->flags = REPO_FLAGS_USE_IPV4; @@ -614,10 +603,10 @@ load_repo_file(const char *repofile, pkg_init_flags flags) p = ucl_parser_new(0); - myarch = pkg_object_string(pkg_config_get("ABI")); + myarch = pkg_config[PKG_CONFIG_ABI]->value.string; ucl_parser_register_variable (p, "ABI", myarch); - myarch_legacy = pkg_object_string(pkg_config_get("ALTABI")); + myarch_legacy = pkg_config[PKG_CONFIG_ALTABI]->value.string; ucl_parser_register_variable (p, "ALTABI", myarch_legacy); pkg_debug(1, "PKgConfig: loading %s", repofile); @@ -669,17 +658,18 @@ load_repo_files(const char *repodir, pkg_init_flags flags) static void load_repositories(const char *repodir, pkg_init_flags flags) { - const pkg_object *reposlist, *cur; - pkg_iter it = NULL; + struct pkg_strel *el; if (repodir != NULL) { load_repo_files(repodir, flags); return; } - reposlist = pkg_config_get( "REPOS_DIR"); - while ((cur = pkg_object_iterate(reposlist, &it))) - load_repo_files(pkg_object_string(cur), flags); + el = pkg_config[PKG_CONFIG_REPOS_DIR]->value.list; + while (el != NULL) { + load_repo_files(el->value, flags); + el = el->next; + } } bool @@ -689,7 +679,7 @@ pkg_compiled_for_same_os_major(void) const char *myabi; int osmajor; - myabi = pkg_object_string(pkg_config_get("ABI")); + myabi = pkg_config[PKG_CONFIG_ABI]->value.string; myabi = strchr(myabi,':'); myabi++; @@ -719,13 +709,15 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) const char *nsname = NULL; const char *evpipe = NULL; const ucl_object_t *cur, *object; - ucl_object_t *obj = NULL, *o, *ncfg; + ucl_object_t *obj = NULL; ucl_object_iter_t it = NULL; struct sbuf *ukey = NULL; - bool fatal_errors = false; + struct pkg_config *conf; + const char *errstr; + struct pkg_kv *kv1, *kv2; + struct pkg_strel *el1, *el2; k = NULL; - o = NULL; pkg_get_myarch(myabi, BUFSIZ); pkg_get_myarch_legacy(myabi_legacy, BUFSIZ); @@ -740,28 +732,34 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) return (EPKG_FATAL); } - config = ucl_object_typed_new(UCL_OBJECT); + /* Null terminate the config to allow the user to loop over it */ + config = calloc(PKG_CONFIG_END, sizeof(struct pkg_config *)); for (i = 0; i < c_size; i++) { + conf = calloc(1, sizeof(struct pkg_config)); + config[i] = conf; + conf->name = strdup(c[i].key); + conf->type = c[i].type; switch (c[i].type) { case PKG_STRING: - obj = ucl_object_fromstring_common( - c[i].def != NULL ? c[i].def : "", 0, UCL_STRING_TRIM); - ucl_object_insert_key(config, obj, - c[i].key, strlen(c[i].key), false); + conf->def.string = c[i].def; + if (conf->def.string != NULL) + conf->value.string = strdup(conf->def.string); break; case PKG_INT: - ucl_object_insert_key(config, - ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_INT), - c[i].key, strlen(c[i].key), false); + conf->def.number = strtonum(c[i].def, 0, INT64_MAX, &errstr); + conf->value.number = conf->def.number; break; case PKG_BOOL: - ucl_object_insert_key(config, - ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_BOOLEAN), - c[i].key, strlen(c[i].key), false); + conf->def.boolean = false; + if (strcasecmp(c[i].def, "yes") == 0 || + strcasecmp(c[i].def, "true") == 0 || + strcasecmp(c[i].def, "on") == 0 || + c[i].def[0] == '1') + conf->def.boolean = true; + conf->value.boolean = conf->def.boolean; break; - case PKG_OBJECT: - obj = ucl_object_typed_new(UCL_OBJECT); + case PKG_KEYVALUE: if (c[i].def != NULL) { walk = buf = c[i].def; while ((buf = strchr(buf, ',')) != NULL) { @@ -772,9 +770,14 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) break; value++; } - ucl_object_insert_key(obj, - ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM), - key, value - key, false); + kv1 = calloc(1, sizeof(struct pkg_kv)); + kv2 = calloc(1, sizeof(struct pkg_kv)); + kv1->key = strndup(key, value - key); + kv1->value = strndup(value + 1, buf - value - 1); + kv2->key = strndup(key, value - key); + kv2->value = strndup(value + 1, buf - value - 1); + LL_APPEND(conf->def.kv, kv1); + LL_APPEND(conf->value.kv, kv2); buf++; walk = buf; } @@ -785,30 +788,36 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) break; value++; } - if (o == NULL) - o = ucl_object_typed_new(UCL_OBJECT); - ucl_object_insert_key(o, - ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM), - key, value - key, false); + kv1 = calloc(1, sizeof(struct pkg_kv)); + kv2 = calloc(1, sizeof(struct pkg_kv)); + kv1->key = strndup(key, value - key); + kv1->value = strdup(value + 1); + kv2->key = strndup(key, value - key); + kv2->value = strdup(value + 1); + LL_APPEND(conf->def.kv, kv1); + LL_APPEND(conf->value.kv, kv2); } - ucl_object_insert_key(config, obj, - c[i].key, strlen(c[i].key), false); break; case PKG_ARRAY: - obj = ucl_object_typed_new(UCL_ARRAY); if (c[i].def != NULL) { walk = buf = c[i].def; while ((buf = strchr(buf, ',')) != NULL) { - ucl_array_append(obj, - ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM)); + el1 = calloc(1, sizeof(struct pkg_strel)); + el1->value = strndup(walk, buf - walk); + el2 = calloc(1, sizeof(struct pkg_strel)); + el2->value = strndup(walk, buf - walk); + LL_APPEND(conf->def.list, el1); + LL_APPEND(conf->value.list, el2); buf++; walk = buf; } - ucl_array_append(obj, - ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM)); + el1 = calloc(1, sizeof(struct pkg_strel)); + el1->value = strdup(walk); + el2 = calloc(1, sizeof(struct pkg_strel)); + el2->value = strdup(walk); + LL_APPEND(conf->def.list, el1); + LL_APPEND(conf->value.list, el2); } - ucl_object_insert_key(config, obj, - c[i].key, strlen(c[i].key), false); break; } } @@ -828,167 +837,184 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) } - ncfg = NULL; - while (obj != NULL && (cur = ucl_iterate_object(obj, &it, true))) { - sbuf_init(&ukey); - key = ucl_object_key(cur); - for (i = 0; key[i] != '\0'; i++) - sbuf_putc(ukey, toupper(key[i])); - sbuf_finish(ukey); - object = ucl_object_find_keyl(config, sbuf_data(ukey), sbuf_len(ukey)); - - if (strncasecmp(sbuf_data(ukey), "PACKAGESITE", sbuf_len(ukey)) - == 0 || strncasecmp(sbuf_data(ukey), "PUBKEY", - sbuf_len(ukey)) == 0 || strncasecmp(sbuf_data(ukey), - "MIRROR_TYPE", sbuf_len(ukey)) == 0) { - pkg_emit_error("%s in pkg.conf is no longer " - "supported. Convert to the new repository style." - " See pkg.conf(5)", sbuf_data(ukey)); - fatal_errors = true; - continue; + for (i = 0; i < PKG_CONFIG_END; i++) { + object = ucl_object_find_key(obj, pkg_config[i]->name); + val = getenv(pkg_config[i]->name); + if (object == NULL) { + sbuf_init(&ukey); + for (int j = 0; pkg_config[i]->name[j] != '\0'; j++) + sbuf_putc(ukey, toupper(pkg_config[i]->name[j])); + sbuf_finish(ukey); + object = ucl_object_find_keyl(obj, sbuf_data(ukey), sbuf_len(ukey)); } - - /* ignore unknown keys */ if (object == NULL) continue; - - if (object->type != cur->type) { - pkg_emit_error("Malformed key %s, ignoring", key); - continue; - } - - if (ncfg == NULL) - ncfg = ucl_object_typed_new(UCL_OBJECT); - ucl_object_insert_key(ncfg, ucl_object_copy(cur), sbuf_data(ukey), sbuf_len(ukey), true); - } - - if (fatal_errors) { - ucl_object_unref(ncfg); - ucl_parser_free(p); - return (EPKG_FATAL); - } - - if (ncfg != NULL) { - it = NULL; - while (( cur = ucl_iterate_object(ncfg, &it, true))) { - key = ucl_object_key(cur); - ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true); - } - ucl_object_unref(ncfg); - } - - ncfg = NULL; - it = NULL; - while ((cur = ucl_iterate_object(config, &it, true))) { - o = NULL; - key = ucl_object_key(cur); - val = getenv(key); - if (val == NULL) - continue; - switch (cur->type) { - case UCL_STRING: - o = ucl_object_fromstring_common(val, 0, UCL_STRING_TRIM); + switch (pkg_config[i]->type) { + case PKG_INT: + if (val != NULL) { + if (strcspn(val, "0123456789") != strlen(val)) { + pkg_config[i]->value.number = strtonum(val, 0, INT64_MAX, &errstr); + continue; + } + pkg_emit_error("Invalid env var for key %s, ignoring", pkg_config[i]->name); + } + if (object->type == UCL_INT) { + pkg_config[i]->value.number = ucl_object_toint(object); + continue; + } + break; + case PKG_BOOL: + if (val != NULL) { + if (strcasecmp(val, "on") == 0 || + strcasecmp(val, "true") == 0 || + strcasecmp(val, "yes") == 0 || + strcmp(val, "1") == 0) { + pkg_config[i]->value.boolean = true; + continue; + } + if (strcasecmp(val, "off") == 0 || + strcasecmp(val, "false") == 0 || + strcasecmp(val, "no") == 0 || + strcmp(val, "0") == 0) { + pkg_config[i]->value.boolean = false; + continue; + } + pkg_emit_error("Invalid env var for key %s, ignoring", pkg_config[i]->name); + } + if (object->type == UCL_INT) { + if (ucl_object_toint(object) == 1) { + pkg_config[i]->value.boolean = true; + continue; + } + if (ucl_object_toint(object) == 0) { + pkg_config[i]->value.boolean = false; + continue; + } + pkg_emit_error("Malformed key %s, ignoring", ucl_object_key(object)); + continue; + } + if (object->type == UCL_STRING) { + if (strcasecmp(ucl_object_tostring(object), "on") == 0 || + strcasecmp(ucl_object_tostring(object), "yes") == 0) { + pkg_config[i]->value.boolean = true; + continue; + } + if (strcasecmp(ucl_object_tostring(object), "off") == 0 || + strcasecmp(ucl_object_tostring(object), "no") == 0) { + pkg_config[i]->value.boolean = false; + continue; + } + } + if (object->type == UCL_BOOLEAN) { + pkg_config[i]->value.boolean = ucl_object_toboolean(object); + continue; + } break; - case UCL_INT: - o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_INT); - if (o->type != UCL_INT) { - pkg_emit_error("Invalid type for environment " - "variable %s, got %s, while expecting an integer", - key, val); - ucl_object_unref(o); + case PKG_STRING: + if (val != NULL) { + free(pkg_config[i]->value.string); + pkg_config[i]->value.string = strdup(val); + continue; + } + if (object->type == UCL_INT || object->type == UCL_BOOLEAN || object->type == UCL_STRING) { + free(pkg_config[i]->value.string); + pkg_config[i]->value.string = strdup(ucl_object_tostring_forced(object)); continue; } break; - case UCL_BOOLEAN: - o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_BOOLEAN); - if (o->type != UCL_BOOLEAN) { - pkg_emit_error("Invalid type for environment " - "variable %s, got %s, while expecting a boolean", - key, val); - ucl_object_unref(o); + case PKG_ARRAY: + if (val != NULL) { + walk = buf = c[i].def; + while ((buf = strchr(buf, ',')) != NULL) { + el1 = calloc(1, sizeof(struct pkg_strel)); + el1->value = strndup(walk, buf - walk); + LL_APPEND(conf->value.list, el1); + buf++; + walk = buf; + } + el1 = calloc(1, sizeof(struct pkg_strel)); + el1->value = strdup(walk); + LL_APPEND(conf->value.list, el1); + continue; + } + if (object->type == UCL_ARRAY) { + LL_FREE(pkg_config[i]->value.list, pkg_strel_free); + it = NULL; + while ((cur = ucl_iterate_object(obj, &it, true))) { + pkg_strel_new(&el1, ucl_object_tostring_forced(cur)); + LL_APPEND(pkg_config[i]->value.list, el1); + } continue; } break; - case UCL_OBJECT: - o = ucl_object_typed_new(UCL_OBJECT); - walk = buf = val; - while ((buf = strchr(buf, ',')) != NULL) { - k = walk; + case PKG_KEYVALUE: + if (val != NULL) { + walk = buf = c[i].def; + while ((buf = strchr(buf, ',')) != NULL) { + key = walk; + value = walk; + while (*value != ',') { + if (*value == '=') + break; + value++; + } + kv1 = calloc(1, sizeof(struct pkg_kv)); + kv1->key = strndup(key, value - key); + kv1->value = strndup(value + 1, buf - value - 1); + LL_APPEND(conf->value.kv, kv1); + buf++; + walk = buf; + } + key = walk; value = walk; while (*value != ',') { if (*value == '=') break; value++; } - ucl_object_insert_key(o, - ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM), - k, value - k, false); - buf++; - walk = buf; - } - key = walk; - value = walk; - while (*value != '\0') { - if (*value == '=') - break; - value++; + kv1 = calloc(1, sizeof(struct pkg_kv)); + kv1->key = strndup(key, value - key); + kv1->value = strdup(value + 1); + LL_APPEND(conf->value.kv, kv1); + continue; } - ucl_object_insert_key(o, - ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM), - k, value - k, false); - break; - case UCL_ARRAY: - o = ucl_object_typed_new(UCL_ARRAY); - walk = buf = val; - while ((buf = strchr(buf, ',')) != NULL) { - ucl_array_append(o, - ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM)); - buf++; - walk = buf; + if (object->type == UCL_OBJECT) { + LL_FREE(pkg_config[i]->value.kv, pkg_kv_free); + it = NULL; + while ((cur = ucl_iterate_object(obj, &it, true))) { + pkg_kv_new(&kv1, ucl_object_key(cur), ucl_object_tostring_forced(cur)); + LL_APPEND(pkg_config[i]->value.kv, kv1); + } + continue; } - ucl_array_append(o, - ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM)); - break; default: - /* ignore other types */ + /*ignore*/ + continue; break; } - if (o != NULL) { - if (ncfg == NULL) - ncfg = ucl_object_typed_new(UCL_OBJECT); - ucl_object_insert_key(ncfg, o, key, strlen(key), true); - } + pkg_emit_error("Malformed key %s, ignoring", ucl_object_key(object)); } - if (ncfg != NULL) { - it = NULL; - while (( cur = ucl_iterate_object(ncfg, &it, true))) { - key = ucl_object_key(cur); - ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true); - } - ucl_object_unref(ncfg); - } + ucl_object_unref(obj); + ucl_parser_free(p); disable_plugins_if_static(); parsed = true; - ucl_object_unref(obj); - ucl_parser_free(p); pkg_debug(1, "%s", "pkg initialized"); /* Start the event pipe */ - evpipe = pkg_object_string(pkg_config_get("EVENT_PIPE")); + evpipe = pkg_config[PKG_CONFIG_EVENT_PIPE]->value.string; if (evpipe != NULL) connect_evpipe(evpipe); - it = NULL; - object = ucl_object_find_key(config, "PKG_ENV"); - while ((cur = ucl_iterate_object(object, &it, true))) { - evkey = ucl_object_key(cur); - pkg_debug(1, "Setting env var: %s", evkey); + kv1 = pkg_config[PKG_CONFIG_ENV]->value.kv; + while (kv1 != NULL) { + pkg_debug(1, "Setting env var: %s=%s", kv1->key, kv1->value); if (evkey != NULL && evkey[0] != '\0') - setenv(evkey, ucl_object_tostring_forced(cur), 1); + setenv(kv1->key, kv1->value, 1); + kv1 = kv1->next; } /* load the repositories */ @@ -997,9 +1023,9 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags) setenv("HTTP_USER_AGENT", "pkg/"PKGVERSION, 1); /* bypass resolv.conf with specified NAMESERVER if any */ - nsname = pkg_object_string(pkg_config_get("NAMESERVER")); + nsname = pkg_config[PKG_CONFIG_NAMESERVER]->value.string; if (nsname != NULL) - set_nameserver(ucl_object_tostring_forced(o)); + set_nameserver(nsname); return (EPKG_OK); } @@ -1084,7 +1110,6 @@ pkg_shutdown(void) /* NOTREACHED */ } - ucl_object_unref(config); HASH_FREE(repos, pkg_repo_free); parsed = false; diff --git a/libpkg/pkg_create.c b/libpkg/pkg_create.c index 5ff5d50..624746a 100644 --- a/libpkg/pkg_create.c +++ b/libpkg/pkg_create.c @@ -145,7 +145,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, ret = packing_append_file_attr(pkg_archive, fpath, file->path, file->uname, file->gname, file->perm); - developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); + developer = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; if (developer && ret != EPKG_OK) return (ret); } @@ -156,7 +156,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, ret = packing_append_file_attr(pkg_archive, fpath, dir->path, dir->uname, dir->gname, dir->perm); - developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); + developer = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; if (developer && ret != EPKG_OK) return (ret); } diff --git a/libpkg/pkg_delete.c b/libpkg/pkg_delete.c index 146a7d4..e8de3ea 100644 --- a/libpkg/pkg_delete.c +++ b/libpkg/pkg_delete.c @@ -68,7 +68,7 @@ pkg_delete(struct pkg *pkg, struct pkgdb *db, unsigned flags) * stop the different related services if the users do want that * and that the service is running */ - handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS")); + handle_rc = pkg_config[PKG_CONFIG_HANDLE_RC_SCRIPTS]->value.boolean; if (handle_rc) pkg_start_stop_rc_scripts(pkg, PKG_RC_STOP); diff --git a/libpkg/pkg_elf.c b/libpkg/pkg_elf.c index d6d1ce7..c99036e 100644 --- a/libpkg/pkg_elf.c +++ b/libpkg/pkg_elf.c @@ -233,8 +233,8 @@ analyse_elf(struct pkg *pkg, const char *fpath, bool developer = false; bool is_shlib = false; - developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); - myarch = pkg_object_string(pkg_config_get("ABI")); + developer = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; + myarch = pkg_config[PKG_CONFIG_ABI]->value.string; int fd; @@ -448,7 +448,7 @@ pkg_analyse_files(struct pkgdb *db, struct pkg *pkg, const char *stage) char fpath[MAXPATHLEN]; bool developer = false, failures = false; - developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); + developer = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; pkg_list_free(pkg, PKG_SHLIBS_REQUIRED); pkg_list_free(pkg, PKG_SHLIBS_PROVIDED); diff --git a/libpkg/pkg_event.c b/libpkg/pkg_event.c index ea19955..f680518 100644 --- a/libpkg/pkg_event.c +++ b/libpkg/pkg_event.c @@ -547,7 +547,7 @@ pkg_emit_install_finished(struct pkg *p) ev.type = PKG_EVENT_INSTALL_FINISHED; ev.e_install_finished.pkg = p; - syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG")); + syslog_enabled = pkg_config[PKG_CONFIG_SYSLOG]->value.boolean; if (syslog_enabled) { syslog(LOG_NOTICE, "%s-%s installed", p->name, p->version); @@ -674,7 +674,7 @@ pkg_emit_deinstall_finished(struct pkg *p) ev.type = PKG_EVENT_DEINSTALL_FINISHED; ev.e_deinstall_finished.pkg = p; - syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG")); + syslog_enabled = pkg_config[PKG_CONFIG_SYSLOG]->value.boolean; if (syslog_enabled) { syslog(LOG_NOTICE, "%s-%s deinstalled", p->name, p->version); @@ -705,7 +705,7 @@ pkg_emit_upgrade_finished(struct pkg *new, struct pkg *old) ev.e_upgrade_finished.new = new; ev.e_upgrade_finished.old = old; - syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG")); + syslog_enabled = pkg_config[PKG_CONFIG_SYSLOG]->value.boolean; if (syslog_enabled) { const char *actions[] = { [PKG_DOWNGRADE] = "downgraded", @@ -940,7 +940,7 @@ pkg_debug(int level, const char *fmt, ...) va_list ap; int64_t expectlevel; - expectlevel = pkg_object_int(pkg_config_get("DEBUG_LEVEL")); + expectlevel = pkg_config[PKG_CONFIG_DEBUG_LEVEL]->value.number; if (expectlevel < level) return; diff --git a/libpkg/pkg_jobs.c b/libpkg/pkg_jobs.c index 8ac466c..5fafc43 100644 --- a/libpkg/pkg_jobs.c +++ b/libpkg/pkg_jobs.c @@ -1608,7 +1608,7 @@ pkg_jobs_solve(struct pkg_jobs *j) } if (ret == EPKG_OK) { - if ((solver = pkg_object_string(pkg_config_get("CUDF_SOLVER"))) != NULL) { + if ((solver = pkg_config[PKG_CONFIG_CUDF_SOLVER]->value.string) != NULL) { pchild = process_spawn_pipe(spipe, solver); if (pchild == -1) return (EPKG_FATAL); @@ -1627,7 +1627,7 @@ again: pkg_jobs_universe_process_upgrade_chains(j); problem = pkg_solve_jobs_to_sat(j); if (problem != NULL) { - if ((solver = pkg_object_string(pkg_config_get("SAT_SOLVER"))) != NULL) { + if ((solver = pkg_config[PKG_CONFIG_SAT_SOLVER]->value.string) != NULL) { pchild = process_spawn_pipe(spipe, solver); if (pchild == -1) return (EPKG_FATAL); @@ -1831,7 +1831,7 @@ pkg_jobs_execute(struct pkg_jobs *j) if ((j->flags & PKG_FLAG_NOSCRIPT) == PKG_FLAG_NOSCRIPT) flags |= PKG_DELETE_NOSCRIPT; - handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS")); + handle_rc = pkg_config[PKG_CONFIG_HANDLE_RC_SCRIPTS]->value.boolean; retcode = pkgdb_upgrade_lock(j->db, PKGDB_LOCK_ADVISORY, PKGDB_LOCK_EXCLUSIVE); @@ -2008,7 +2008,7 @@ pkg_jobs_fetch(struct pkg_jobs *j) if (j->destdir == NULL || !mirror) - cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR")); + cachedir = pkg_config[PKG_CONFIG_CACHEDIR]->value.string; else cachedir = j->destdir; diff --git a/libpkg/pkg_manifest.c b/libpkg/pkg_manifest.c index 924cdea..4a586e7 100644 --- a/libpkg/pkg_manifest.c +++ b/libpkg/pkg_manifest.c @@ -907,7 +907,7 @@ pkg_emit_filelist(struct pkg *pkg, FILE *f) return (EPKG_OK); } -pkg_object* +ucl_object_t * pkg_emit_object(struct pkg *pkg, short flags) { struct pkg_strel *el; diff --git a/libpkg/pkg_old.c b/libpkg/pkg_old.c index 1dd6a71..61c1c68 100644 --- a/libpkg/pkg_old.c +++ b/libpkg/pkg_old.c @@ -221,7 +221,7 @@ pkg_register_old(struct pkg *pkg) pkg_to_old(pkg); pkg_old_emit_content(pkg, &content); - pkgdbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + pkgdbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; pkg_snprintf(path, sizeof(path), "%S/%n-%v", pkgdbdir, pkg, pkg); mkdir(path, 0755); diff --git a/libpkg/pkg_ports.c b/libpkg/pkg_ports.c index 5b4f826..cfdc5b9 100644 --- a/libpkg/pkg_ports.c +++ b/libpkg/pkg_ports.c @@ -260,7 +260,7 @@ dir(struct plist *p, char *line, struct file_attr *a) pkg_emit_errno("lstat", testpath); if (p->stage != NULL) ret = EPKG_FATAL; - developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); + developer = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; if (developer) { pkg_emit_developer_mode("Plist error: @dirrm %s", line); ret = EPKG_FATAL; @@ -290,7 +290,7 @@ warn_deprecated_dir(void) return; warned_deprecated_dir = true; - if (pkg_object_bool(pkg_config_get("DEVELOPER_MODE"))) + if (pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean) pkg_emit_error("Warning: @dirrm[try] is deprecated, please" " use @dir"); } @@ -338,7 +338,7 @@ meta_file(struct plist *p, char *line, struct file_attr *a, bool is_config) pkg_emit_errno("lstat", testpath); if (p->stage != NULL) ret = EPKG_FATAL; - developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); + developer = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; if (developer) { pkg_emit_developer_mode("Plist error, missing file: %s", line); ret = EPKG_FATAL; @@ -383,7 +383,7 @@ meta_file(struct plist *p, char *line, struct file_attr *a, bool is_config) } } if (S_ISDIR(st.st_mode) && - !pkg_object_bool(pkg_config_get("PLIST_ACCEPT_DIRECTORIES"))) { + !pkg_config[PKG_CONFIG_PLIST_ACCEPT_DIRECTORIES]->value.boolean) { pkg_emit_error("Plist error, directory listed as a file: %s", line); free_file_attr(a); return (EPKG_FATAL); @@ -935,9 +935,9 @@ external_keyword(struct plist *plist, char *keyword, char *line, struct file_att ucl_object_t *o, *schema; struct ucl_schema_error err; - keyword_dir = pkg_object_string(pkg_config_get("PLIST_KEYWORDS_DIR")); + keyword_dir = pkg_config[PKG_CONFIG_PLIST_KEYWORDS_DIR]->value.string; if (keyword_dir == NULL) { - keyword_dir = pkg_object_string(pkg_config_get("PORTSDIR")); + keyword_dir = pkg_config[PKG_CONFIG_PORTSDIR]->value.string; snprintf(keyfile_path, sizeof(keyfile_path), "%s/Keywords/%s.ucl", keyword_dir, keyword); } else { diff --git a/libpkg/pkg_repo.c b/libpkg/pkg_repo.c index 5502a58..2ad6112 100644 --- a/libpkg/pkg_repo.c +++ b/libpkg/pkg_repo.c @@ -882,7 +882,7 @@ pkg_repo_fetch_meta(struct pkg_repo *repo, time_t *t) struct sig_cert *sc = NULL, *s, *stmp; struct pkg_repo_check_cbdata cbdata; - dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; fd = pkg_repo_fetch_remote_tmp(repo, "meta", "txz", t, &rc); if (fd == -1) diff --git a/libpkg/pkg_repo_create.c b/libpkg/pkg_repo_create.c index 7929f15..d9f752a 100644 --- a/libpkg/pkg_repo_create.c +++ b/libpkg/pkg_repo_create.c @@ -578,7 +578,7 @@ pkg_create_repo(char *path, const char *output_dir, bool filelist, repopath[0] = path; repopath[1] = NULL; - num_workers = pkg_object_int(pkg_config_get("WORKERS_COUNT")); + num_workers = pkg_config[PKG_CONFIG_WORKERS_COUNT]->value.number; if (num_workers <= 0) { len = sizeof(num_workers); if (sysctlbyname("hw.ncpu", &num_workers, &len, NULL, 0) == -1) diff --git a/libpkg/pkg_solve.c b/libpkg/pkg_solve.c index 26dd8cb..e34b73a 100644 --- a/libpkg/pkg_solve.c +++ b/libpkg/pkg_solve.c @@ -282,7 +282,7 @@ pkg_debug_print_rule(struct pkg_solve_rule *rule) int64_t expectlevel; /* Avoid expensive printing if debug level is less than required */ - expectlevel = pkg_object_int(pkg_config_get("DEBUG_LEVEL")); + expectlevel = pkg_config[PKG_CONFIG_DEBUG_LEVEL]->value.number; if (expectlevel < 3) return; diff --git a/libpkg/pkg_status.c b/libpkg/pkg_status.c index e651294..3496c6a 100644 --- a/libpkg/pkg_status.c +++ b/libpkg/pkg_status.c @@ -43,7 +43,6 @@ static bool is_exec_at_localbase(const char *progname); pkg_status_t pkg_status(int *count) { - const pkg_object *o; const char *progname; char dbpath[MAXPATHLEN]; int numpkgs = 0; @@ -69,8 +68,7 @@ pkg_status(int *count) /* Does the local.sqlite pkg database exist, and can we open it for reading? */ - o = pkg_config_get("PKG_DBDIR"); - snprintf(dbpath, sizeof(dbpath), "%s/local.sqlite", pkg_object_string(o)); + snprintf(dbpath, sizeof(dbpath), "%s/local.sqlite", pkg_config[PKG_CONFIG_DBDIR]->value.string); if (eaccess(dbpath, R_OK) == -1) return (PKG_STATUS_NODB); diff --git a/libpkg/pkgdb.c b/libpkg/pkgdb.c index 8b3b208..4281f6a 100644 --- a/libpkg/pkgdb.c +++ b/libpkg/pkgdb.c @@ -764,7 +764,6 @@ pkgdb_check_access(unsigned mode, const char* dbdir, const char *dbname) int pkgdb_access(unsigned mode, unsigned database) { - const pkg_object *o; const char *dbdir; int retval = EPKG_OK; @@ -788,8 +787,7 @@ pkgdb_access(unsigned mode, unsigned database) * EPKG_OK: We can go ahead */ - o = pkg_config_get("PKG_DBDIR"); - dbdir = pkg_object_string(o); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; if ((mode & ~(PKGDB_MODE_READ|PKGDB_MODE_WRITE|PKGDB_MODE_CREATE)) != 0) return (EPKG_FATAL); /* EINVAL */ @@ -900,7 +898,7 @@ pkgdb_open_all(struct pkgdb **db_p, pkgdb_t type, const char *reponame) db = *db_p; } - dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; if (!reopen && (db = calloc(1, sizeof(struct pkgdb))) == NULL) { pkg_emit_errno("malloc", "pkgdb"); return (EPKG_FATAL); @@ -1003,7 +1001,7 @@ pkgdb_open_all(struct pkgdb **db_p, pkgdb_t type, const char *reponame) } - profile = pkg_object_bool(pkg_config_get("SQLITE_PROFILE")); + profile = pkg_config[PKG_CONFIG_SQLITE_PROFILE]->value.boolean; if (profile) { pkg_debug(1, "pkgdb profiling is enabled"); sqlite3_profile(db->sqlite, pkgdb_profile_callback, NULL); @@ -1657,9 +1655,9 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced) goto cleanup; } if (!forced) { - devmode = pkg_object_bool(pkg_config_get("DEVELOPER_MODE")); + devmode = pkg_config[PKG_CONFIG_DEVELOPER_MODE]->value.boolean; if (!devmode) - permissive = pkg_object_bool(pkg_config_get("PERMISSIVE")); + permissive = pkg_config[PKG_CONFIG_PERMISSIVE]->value.boolean; pkg_emit_error("%s-%s conflicts with %s-%s" " (installs files into the same place). " " Problematic file: %s%s", @@ -2545,7 +2543,7 @@ pkgshell_open(const char **reponame) sqlite3_auto_extension((void(*)(void))pkgdb_sqlcmd_init); - dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; snprintf(localpath, sizeof(localpath), "%s/local.sqlite", dbdir); *reponame = strdup(localpath); @@ -2665,16 +2663,10 @@ pkgdb_try_lock(struct pkgdb *db, const char *lock_sql, pkgdb_lock_t type, unsigned int tries = 0; struct timespec ts; int ret = EPKG_END; - const pkg_object *timeout, *max_tries; int64_t num_timeout = 1, num_maxtries = 1; - timeout = pkg_config_get("LOCK_WAIT"); - max_tries = pkg_config_get("LOCK_RETRIES"); - - if (timeout) - num_timeout = pkg_object_int(timeout); - if (max_tries) - num_maxtries = pkg_object_int(max_tries); + num_timeout = pkg_config[PKG_CONFIG_LOCK_WAIT]->value.number; + num_maxtries = pkg_config[PKG_CONFIG_LOCK_RETRIES]->value.number; while (tries <= num_maxtries) { ret = sqlite3_exec(db->sqlite, lock_sql, NULL, NULL, NULL); @@ -2745,7 +2737,7 @@ pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type) switch (type) { case PKGDB_LOCK_READONLY: - if (!ucl_object_toboolean(pkg_config_get("READ_LOCK"))) + if (!pkg_config[PKG_CONFIG_READ_LOCK]->value.boolean) return (EPKG_OK); lock_sql = readonly_lock_sql; pkg_debug(1, "want to get a read only lock on a database"); @@ -2821,7 +2813,7 @@ pkgdb_release_lock(struct pkgdb *db, pkgdb_lock_t type) switch (type) { case PKGDB_LOCK_READONLY: - if (!ucl_object_toboolean(pkg_config_get("READ_LOCK"))) + if (!pkg_config[PKG_CONFIG_READ_LOCK]->value.boolean) return (EPKG_OK); unlock_sql = readonly_unlock_sql; diff --git a/libpkg/plugins.c b/libpkg/plugins.c index 8dc6f18..dde26a1 100644 --- a/libpkg/plugins.c +++ b/libpkg/plugins.c @@ -57,7 +57,7 @@ struct pkg_plugin { void *lh; /* library handle */ bool parsed; struct plugin_hook *hooks; - pkg_object *conf; + struct pkg_config **conf; struct pkg_plugin *next; }; @@ -166,83 +166,10 @@ pkg_plugin_get(struct pkg_plugin *p, pkg_plugin_key key) } int -pkg_plugin_conf_add(struct pkg_plugin *p, pkg_object_t type, const char *key, +pkg_plugin_conf_add(struct pkg_plugin *p, pkg_config_t type, const char *key, const char *def) { - ucl_object_t *o = NULL; - const char *walk, *buf, *value, *k; - k = NULL; - - switch (type) { - case PKG_STRING: - o = ucl_object_fromstring_common(def, 0, UCL_STRING_TRIM); - break; - case PKG_BOOL: - o = ucl_object_fromstring_common(def, 0, UCL_STRING_PARSE_BOOLEAN); - if (o->type != UCL_BOOLEAN) { - ucl_object_unref(o); - return (EPKG_FATAL); - } - break; - case PKG_INT: - o = ucl_object_fromstring_common(def, 0, UCL_STRING_PARSE_INT); - if (o->type != UCL_INT) { - ucl_object_unref(o); - return (EPKG_FATAL); - } - break; - case PKG_OBJECT: - walk = buf = def; - while ((buf = strchr(buf, ',')) != NULL) { - k = walk; - value = walk; - while (*value != ',') { - if (*value == '=') - break; - value++; - } - if (o == NULL) - o = ucl_object_typed_new(UCL_OBJECT); - ucl_object_insert_key(o, - ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM), - k, value - k, false); - buf++; - walk = buf; - } - key = walk; - value = walk; - while (*value != '\0') { - if (*value == '=') - break; - value++; - } - if (o == NULL) - o = ucl_object_typed_new(UCL_OBJECT); - ucl_object_insert_key(o, - ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM), - k, value - k, false); - break; - case PKG_ARRAY: - walk = buf = def; - while ((buf = strchr(buf, ',')) != NULL) { - if (o == NULL) - o = ucl_object_typed_new(UCL_ARRAY); - ucl_array_append(o, - ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM)); - buf++; - walk = buf; - } - if (o == NULL) - o = ucl_object_typed_new(UCL_ARRAY); - ucl_array_append(o, - ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM)); - break; - default: - break; - } - - if (o != NULL) - ucl_object_replace_key(p->conf, o, key, strlen(key), false); + /* NOT IMPLEMENTED */ return (EPKG_OK); } @@ -266,42 +193,37 @@ pkg_plugins_init(void) { struct pkg_plugin *p = NULL; char pluginfile[MAXPATHLEN]; - const ucl_object_t *obj, *cur; - ucl_object_iter_t it = NULL; + struct pkg_strel *el; const char *plugdir; bool plug_enabled = false; int (*init_func)(struct pkg_plugin *); - plug_enabled = pkg_object_bool(pkg_config_get("PKG_ENABLE_PLUGINS")); + plug_enabled = pkg_config[PKG_CONFIG_ENABLE_PLUGINS]->value.boolean; if (!plug_enabled) return (EPKG_OK); /* * Discover available plugins */ - plugdir = pkg_object_string(pkg_config_get("PKG_PLUGINS_DIR")); + plugdir = pkg_config[PKG_CONFIG_PLUGINS_DIR]->value.string; - obj = pkg_config_get("PLUGINS"); - while ((cur = ucl_iterate_object(obj, &it, true))) { + LL_FOREACH(pkg_config[PKG_CONFIG_PLUGINS]->value.list, el) { /* * Load the plugin */ - if (cur->type != UCL_STRING) - continue; - snprintf(pluginfile, sizeof(pluginfile), "%s/%s.so", plugdir, - pkg_object_string(cur)); + el->value); p = calloc(1, sizeof(struct pkg_plugin)); if ((p->lh = dlopen(pluginfile, RTLD_LAZY)) == NULL) { pkg_emit_error("Loading of plugin '%s' failed: %s", - pkg_object_string(cur), dlerror()); + el->value, dlerror()); free(p); return (EPKG_FATAL); } if ((init_func = dlsym(p->lh, "pkg_plugin_init")) == NULL) { pkg_emit_error("Cannot load init function for plugin '%s'", - pkg_object_string(cur)); + el->value); pkg_emit_error("Plugin '%s' will not be loaded: %s", - pkg_object_string(cur), dlerror()); + el->value, dlerror()); dlclose(p->lh); free(p); return (EPKG_FATAL); @@ -324,51 +246,13 @@ pkg_plugin_parse(struct pkg_plugin *p) char confpath[MAXPATHLEN]; const char *path; const char *plugname; - struct ucl_parser *pr; - const ucl_object_t *cur, *o; - ucl_object_t *obj; - ucl_object_iter_t it = NULL; - const char *key; - - pr = ucl_parser_new(0); - path = pkg_object_string(pkg_config_get("PLUGINS_CONF_DIR")); + path = pkg_config[PKG_CONFIG_PLUGINS_CONF_DIR]->value.string; plugname = pkg_plugin_get(p, PKG_PLUGIN_NAME); snprintf(confpath, sizeof(confpath), "%s/%s.conf", path, plugname); - if (!ucl_parser_add_file(pr, confpath)) { - if (errno == ENOENT) { - ucl_parser_free(pr); - p->parsed = true; - return (EPKG_OK); - } - pkg_emit_error("%s\n", ucl_parser_get_error(pr)); - ucl_parser_free(pr); - - return (EPKG_FATAL); - } - - obj = ucl_parser_get_object(pr); - - while ((cur = ucl_iterate_object(obj, &it, true))) { - key = ucl_object_key(cur); - o = ucl_object_find_key(p->conf, key); - if (o == NULL) - continue; - - if (o->type != cur->type) { - pkg_emit_error("Malformed key %s, ignoring", key); - continue; - } - - ucl_object_delete_key(p->conf, key); - ucl_object_insert_key(p->conf, ucl_object_ref(cur), key, strlen(key), false); - } - - p->parsed = true; - ucl_object_unref(obj); - ucl_parser_free(pr); + /* NOT IMPLEMENTED */ return (EPKG_OK); } @@ -397,7 +281,7 @@ pkg_plugins_shutdown(void) return; } -const pkg_object * +struct pkg_config ** pkg_plugin_conf(struct pkg_plugin *p) { return (p->conf); diff --git a/libpkg/private/pkg.h b/libpkg/private/pkg.h index 176f440..3daa681 100644 --- a/libpkg/private/pkg.h +++ b/libpkg/private/pkg.h @@ -187,11 +187,6 @@ struct pkg_dep { UT_hash_handle hh; }; -struct pkg_strel { - char *value; - struct pkg_strel *next; -}; - enum pkg_conflict_type { PKG_CONFLICT_ALL = 0, PKG_CONFLICT_REMOTE_LOCAL, @@ -599,8 +594,6 @@ bool ucl_object_emit_sbuf(const ucl_object_t *obj, enum ucl_emitter emit_type, bool ucl_object_emit_file(const ucl_object_t *obj, enum ucl_emitter emit_type, FILE *); -pkg_object* pkg_emit_object(struct pkg *pkg, short flags); - /* Hash is in format :: */ #define PKG_CHECKSUM_SHA256_LEN (SHA256_DIGEST_LENGTH * 2 + sizeof("100") * 2 + 2) #define PKG_CHECKSUM_CUR_VERSION 2 diff --git a/libpkg/repo/binary/fetch.c b/libpkg/repo/binary/fetch.c index 7cc3934..517f7db 100644 --- a/libpkg/repo/binary/fetch.c +++ b/libpkg/repo/binary/fetch.c @@ -58,7 +58,7 @@ pkg_repo_binary_get_cached_name(struct pkg_repo *repo, struct pkg *pkg, const char *cachedir = NULL; struct stat st; - cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR")); + cachedir = pkg_config[PKG_CONFIG_CACHEDIR]->value.string; if (pkg->repopath != NULL) ext = strrchr(pkg->repopath, '.'); @@ -145,7 +145,7 @@ pkg_repo_binary_try_fetch(struct pkg_repo *repo, struct pkg *pkg, if (destdir != NULL) cachedir = destdir; else - cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR")); + cachedir = pkg_config[PKG_CONFIG_CACHEDIR]->value.string; snprintf(dest, sizeof(dest), "%s/%s", cachedir, pkg->repopath); } diff --git a/libpkg/repo/binary/init.c b/libpkg/repo/binary/init.c index 5366b7b..3643b3c 100644 --- a/libpkg/repo/binary/init.c +++ b/libpkg/repo/binary/init.c @@ -303,7 +303,7 @@ pkg_repo_binary_open(struct pkg_repo *repo, unsigned mode) struct pkg *pkg = NULL; sqlite3_initialize(); - dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; /* * Fall back on unix-dotfile locking strategy if on a network filesystem @@ -405,7 +405,7 @@ pkg_repo_binary_create(struct pkg_repo *repo) int retcode; sqlite3_initialize(); - dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; snprintf(filepath, sizeof(filepath), "%s/%s", dbdir, pkg_repo_binary_get_filename(pkg_repo_name(repo))); @@ -520,12 +520,10 @@ pkg_repo_binary_close(struct pkg_repo *repo, bool commit) int pkg_repo_binary_access(struct pkg_repo *repo, unsigned mode) { - const pkg_object *o; const char *dbdir; int ret = EPKG_OK; - o = pkg_config_get("PKG_DBDIR"); - dbdir = pkg_object_string(o); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; ret = pkgdb_check_access(mode, dbdir, pkg_repo_binary_get_filename(pkg_repo_name(repo))); diff --git a/libpkg/repo/binary/update.c b/libpkg/repo/binary/update.c index b011df7..33f8496 100644 --- a/libpkg/repo/binary/update.c +++ b/libpkg/repo/binary/update.c @@ -573,7 +573,7 @@ pkg_repo_binary_update(struct pkg_repo *repo, bool force) if (!pkg_repo_enabled(repo)) return (EPKG_OK); - dbdir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + dbdir = pkg_config[PKG_CONFIG_DBDIR]->value.string; pkg_debug(1, "PkgRepo: verifying update for %s", pkg_repo_name(repo)); /* First of all, try to open and init repo and check whether it is fine */ diff --git a/libpkg/scripts.c b/libpkg/scripts.c index edc160a..f5b29a9 100644 --- a/libpkg/scripts.c +++ b/libpkg/scripts.c @@ -75,7 +75,7 @@ pkg_script_run(struct pkg * const pkg, pkg_script type) {"POST-DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_POST_DEINSTALL}, }; - if (!pkg_object_bool(pkg_config_get("RUN_SCRIPTS"))) + if (!pkg_config[PKG_CONFIG_RUN_SCRIPTS]->value.boolean) return (EPKG_OK); for (i = 0; i < sizeof(map) / sizeof(map[0]); i++) { @@ -91,7 +91,7 @@ pkg_script_run(struct pkg * const pkg, pkg_script type) if (j == map[i].a || j == map[i].b) { sbuf_reset(script_cmd); setenv("PKG_PREFIX", pkg->prefix, 1); - debug = pkg_object_bool(pkg_config_get("DEBUG_SCRIPTS")); + debug = pkg_config[PKG_CONFIG_DEBUG_SCRIPTS]->value.boolean; if (debug) sbuf_printf(script_cmd, "set -x\n"); pkg_sbuf_printf(script_cmd, "set -- %n-%v", pkg, pkg); diff --git a/libpkg/ssh.c b/libpkg/ssh.c index 56069c8..dea5c6b 100644 --- a/libpkg/ssh.c +++ b/libpkg/ssh.c @@ -62,7 +62,7 @@ pkg_sshserve(int fd) char rpath[MAXPATHLEN]; const char *restricted = NULL; - restricted = pkg_object_string(pkg_config_get("SSH_RESTRICT_DIR")); + restricted = pkg_config[PKG_CONFIG_SSH_ARGS]->value.string; printf("ok: pkg "PKGVERSION"\n"); for (;;) { diff --git a/libpkg/utils.c b/libpkg/utils.c index 366156b..c856e19 100644 --- a/libpkg/utils.c +++ b/libpkg/utils.c @@ -566,8 +566,8 @@ bool is_valid_abi(const char *arch, bool emit_error) { const char *myarch, *myarch_legacy; - myarch = pkg_object_string(pkg_config_get("ABI")); - myarch_legacy = pkg_object_string(pkg_config_get("ALTABI")); + myarch = pkg_config[PKG_CONFIG_ABI]->value.string; + myarch_legacy = pkg_config[PKG_CONFIG_ALTABI]->value.string; if (fnmatch(arch, myarch, FNM_CASEFOLD) == FNM_NOMATCH && strncasecmp(arch, myarch, strlen(myarch)) != 0 && diff --git a/src/annotate.c b/src/annotate.c index 2a6cc98..3bcb9f4 100644 --- a/src/annotate.c +++ b/src/annotate.c @@ -221,10 +221,10 @@ exec_annotate(int argc, char **argv) { NULL, 0, NULL, 0 }, }; - /* Set default case sensitivity for searching */ - pkgdb_set_case_sensitivity( - pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH")) - ); + /* Set default case sensitivity for searching */ + pkgdb_set_case_sensitivity(pkg_config[ + PKG_CONFIG_CASE_SENSITIVE_MATCH]->value.boolean + ); while ((ch = getopt_long(argc, argv, "+aACDgiMqSxy", longopts, NULL)) != -1) { diff --git a/src/audit.c b/src/audit.c index 7a05ca7..26f7e08 100644 --- a/src/audit.c +++ b/src/audit.c @@ -132,7 +132,7 @@ exec_audit(int argc, char **argv) struct sbuf *sb; struct pkg_check_entry *check = NULL, *cur, *tmp; - db_dir = pkg_object_string(pkg_config_get("PKG_DBDIR")); + db_dir = pkg_config[PKG_CONFIG_DBDIR]->value.string; snprintf(audit_file_buf, sizeof(audit_file_buf), "%s/vuln.xml", db_dir); struct option longopts[] = { @@ -168,7 +168,7 @@ exec_audit(int argc, char **argv) audit = pkg_audit_new(); if (fetch == true) { - portaudit_site = pkg_object_string(pkg_config_get("VULNXML_SITE")); + portaudit_site = pkg_config[PKG_CONFIG_VULNXML_SITE]->value.string; if (pkg_audit_fetch(portaudit_site, audit_file) != EPKG_OK) { return (EX_IOERR); } diff --git a/src/clean.c b/src/clean.c index 224f435..2806955 100644 --- a/src/clean.c +++ b/src/clean.c @@ -218,7 +218,7 @@ exec_clean(int argc, char **argv) argc -= optind; argv += optind; - cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR")); + cachedir = pkg_config[PKG_CONFIG_CACHEDIR]->value.string; paths[0] = __DECONST(char*, cachedir); paths[1] = NULL; diff --git a/src/config.c b/src/config.c index 1038700..0382aff 100644 --- a/src/config.c +++ b/src/config.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include @@ -45,13 +46,13 @@ usage_config(void) int exec_config(int argc, char **argv) { - const pkg_object *conf, *o; - pkg_iter it = NULL; const char *buf; char *key; int64_t integer; int i; bool b; + struct pkg_strel *el; + struct pkg_kv *kv; if (argc != 2) { usage_config(); @@ -59,36 +60,41 @@ exec_config(int argc, char **argv) } key = argv[1]; - for (i = 0; key[i] != '\0'; i++) - key[i] = toupper(key[i]); - conf = pkg_config_get(key); - if (conf == NULL) { + for (i = 0; i < PKG_CONFIG_END; i++) { + if (strcasecmp(pkg_config[i]->name, key) == 0) + break; + } + if (i == PKG_CONFIG_END) { warnx("No such configuration options: %s", key); return (EX_SOFTWARE); } - switch (pkg_object_type(conf)) { + switch (pkg_config[i]->type) { case PKG_STRING: - buf = pkg_object_string(conf); + buf = pkg_config[i]->value.string; printf("%s\n", buf == NULL ? "" : buf); break; case PKG_BOOL: - b = pkg_object_bool(conf); + b = pkg_config[i]->value.boolean; printf("%s\n", b ? "yes" : "no"); break; case PKG_INT: - integer = pkg_object_int(conf); + integer = pkg_config[i]->value.number; printf("%"PRId64"\n", integer); break; - case PKG_OBJECT: - while ((o = pkg_object_iterate(conf, &it))) { - printf("%s: %s\n", pkg_object_key(o), pkg_object_string(o)); + case PKG_KEYVALUE: + kv = pkg_config[i]->value.kv; + while (kv != NULL) { + printf("%s: %s\n", kv->key, kv->value); + kv = kv->next; } break; case PKG_ARRAY: - while ((o = pkg_object_iterate(conf, &it))) { - printf("%s\n", pkg_object_string(o)); + el = pkg_config[i]->value.list; + while (el != NULL) { + printf("%s\n", el->value); + el = el->next; } break; default: diff --git a/src/globals.c b/src/globals.c index 66c8d63..44e2ad3 100644 --- a/src/globals.c +++ b/src/globals.c @@ -34,10 +34,10 @@ int newpkgversion; /* New package version is available */ void set_globals(void) { - yes = pkg_object_bool(pkg_config_get("ASSUME_ALWAYS_YES")); + yes = pkg_config[PKG_CONFIG_ASSUME_ALWAYS_YES]->value.boolean; dry_run = 0; - auto_update = pkg_object_bool(pkg_config_get("REPO_AUTOUPDATE")); - case_sensitive = pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH")); + auto_update = pkg_config[PKG_CONFIG_REPO_AUTOUPDATE]->value.boolean; + case_sensitive = pkg_config[PKG_CONFIG_CASE_SENSITIVE_MATCH]->value.boolean; force = 0; quiet = 0; newpkgversion = 0;