static int
check_binpkgs_hash(struct xbps_handle *xhp, prop_object_iterator_t iter)
{
prop_object_t obj;
const char *pkgver, *repoloc, *filen, *sha256, *trans;
const char *pkgname, *version;
char *binfile;
int rv = 0;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
prop_dictionary_get_cstring_nocopy(obj, "transaction", &trans);
if ((strcmp(trans, "remove") == 0) ||
(strcmp(trans, "configure") == 0))
continue;
prop_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname);
prop_dictionary_get_cstring_nocopy(obj, "version", &version);
prop_dictionary_get_cstring_nocopy(obj, "repository", &repoloc);
assert(repoloc != NULL);
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
assert(pkgver != NULL);
prop_dictionary_get_cstring_nocopy(obj, "filename", &filen);
assert(filen != NULL);
prop_dictionary_get_cstring_nocopy(obj,
"filename-sha256", &sha256);
assert(sha256 != NULL);
binfile = xbps_path_from_repository_uri(xhp, obj, repoloc);
if (binfile == NULL) {
rv = EINVAL;
break;
}
xbps_set_cb_state(xhp, XBPS_STATE_VERIFY, 0, pkgname, version,
"Verifying `%s' package integrity...", filen, repoloc);
rv = xbps_file_hash_check(binfile, sha256);
if (rv != 0) {
free(binfile);
xbps_set_cb_state(xhp, XBPS_STATE_VERIFY_FAIL,
rv, pkgname, version,
"Failed to verify `%s' package integrity: %s",
filen, strerror(rv));
break;
}
free(binfile);
}
prop_object_iterator_reset(iter);
return rv;
}
static int
remove_symlinks(struct xbps_handle *xhp, xbps_array_t a, const char *grname)
{
unsigned int i, cnt;
cnt = xbps_array_count(a);
for (i = 0; i < cnt; i++) {
xbps_string_t str;
char *l, *lnk;
str = xbps_array_get(a, i);
l = left(xbps_string_cstring_nocopy(str));
assert(l);
if (l[0] != '/') {
const char *tgt;
char *tgt_dup, *tgt_dir;
tgt = right(xbps_string_cstring_nocopy(str));
tgt_dup = strdup(tgt);
assert(tgt_dup);
tgt_dir = dirname(tgt_dup);
lnk = xbps_xasprintf("%s%s/%s", xhp->rootdir, tgt_dir, l);
free(tgt_dup);
} else {
lnk = xbps_xasprintf("%s%s", xhp->rootdir, l);
}
xbps_set_cb_state(xhp, XBPS_STATE_ALTGROUP_LINK_REMOVED, 0, NULL,
"Removing '%s' alternatives group symlink: %s", grname, l);
unlink(lnk);
free(lnk);
free(l);
}
return 0;
}
static bool
check_remove_pkg_files(struct xbps_handle *xhp,
xbps_dictionary_t pkgd, const char *pkgver, uid_t euid)
{
struct stat st;
xbps_array_t array;
xbps_object_iterator_t iter;
xbps_object_t obj;
const char *objs[] = { "files", "conf_files", "links", "dirs" };
const char *file;
char path[PATH_MAX];
bool fail = false;
for (uint8_t i = 0; i < __arraycount(objs); i++) {
array = xbps_dictionary_get(pkgd, objs[i]);
if (array == NULL || xbps_array_count(array) == 0)
continue;
iter = xbps_array_iter_from_dict(pkgd, objs[i]);
if (iter == NULL)
continue;
while ((obj = xbps_object_iterator_next(iter))) {
xbps_dictionary_get_cstring_nocopy(obj, "file", &file);
snprintf(path, sizeof(path), "%s/%s", xhp->rootdir, file);
/*
* Check if effective user ID owns the file; this is
* enough to ensure the user has write permissions
* on the directory.
*/
if (euid == 0 || (!lstat(path, &st) && euid == st.st_uid)) {
/* success */
continue;
}
if (errno != ENOENT) {
/*
* only bail out if something else than ENOENT
* is returned.
*/
int rv = errno;
if (rv == 0) {
/* lstat succeeds but euid != uid */
rv = EPERM;
}
fail = true;
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FILE_FAIL,
rv, pkgver,
"%s: cannot remove `%s': %s",
pkgver, file, strerror(rv));
}
errno = 0;
}
xbps_object_iterator_release(iter);
}
return fail;
}
int
xbps_alternatives_register(struct xbps_handle *xhp, xbps_dictionary_t pkgd)
{
xbps_array_t allkeys;
xbps_dictionary_t alternatives, pkg_alternatives;
const char *pkgver;
char *pkgname;
int rv = 0;
assert(xhp);
if (xhp->pkgdb == NULL)
return EINVAL;
pkg_alternatives = xbps_dictionary_get(pkgd, "alternatives");
if (!xbps_dictionary_count(pkg_alternatives))
return 0;
alternatives = xbps_dictionary_get(xhp->pkgdb, "_XBPS_ALTERNATIVES_");
if (alternatives == NULL) {
alternatives = xbps_dictionary_create();
xbps_dictionary_set(xhp->pkgdb, "_XBPS_ALTERNATIVES_", alternatives);
xbps_object_release(alternatives);
}
alternatives = xbps_dictionary_get(xhp->pkgdb, "_XBPS_ALTERNATIVES_");
assert(alternatives);
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
pkgname = xbps_pkg_name(pkgver);
if (pkgname == NULL)
return EINVAL;
allkeys = xbps_dictionary_all_keys(pkg_alternatives);
for (unsigned int i = 0; i < xbps_array_count(allkeys); i++) {
xbps_array_t array;
xbps_object_t keysym;
const char *keyname;
bool alloc = false;
keysym = xbps_array_get(allkeys, i);
keyname = xbps_dictionary_keysym_cstring_nocopy(keysym);
array = xbps_dictionary_get(alternatives, keyname);
if (array == NULL) {
alloc = true;
array = xbps_array_create();
} else {
/* already registered */
if (xbps_match_string_in_array(array, pkgname))
continue;
}
xbps_array_add_cstring(array, pkgname);
xbps_dictionary_set(alternatives, keyname, array);
xbps_set_cb_state(xhp, XBPS_STATE_ALTGROUP_ADDED, 0, NULL,
"%s: registered '%s' alternatives group", pkgver, keyname);
if (alloc) {
/* apply alternatives for this group */
rv = create_symlinks(xhp,
xbps_dictionary_get(pkg_alternatives, keyname),
keyname);
xbps_object_release(array);
if (rv != 0)
break;
}
}
xbps_object_release(allkeys);
free(pkgname);
return rv;
}
int
xbps_alternatives_unregister(struct xbps_handle *xhp, xbps_dictionary_t pkgd)
{
xbps_array_t allkeys;
xbps_dictionary_t alternatives, pkg_alternatives;
const char *pkgver;
char *pkgname;
bool update = false;
int rv = 0;
assert(xhp);
alternatives = xbps_dictionary_get(xhp->pkgdb, "_XBPS_ALTERNATIVES_");
if (alternatives == NULL)
return 0;
pkg_alternatives = xbps_dictionary_get(pkgd, "alternatives");
if (!xbps_dictionary_count(pkg_alternatives))
return 0;
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
if ((pkgname = xbps_pkg_name(pkgver)) == NULL)
return EINVAL;
xbps_dictionary_get_bool(pkgd, "alternatives-update", &update);
allkeys = xbps_dictionary_all_keys(pkg_alternatives);
for (unsigned int i = 0; i < xbps_array_count(allkeys); i++) {
xbps_array_t array;
xbps_object_t keysym;
const char *first = NULL, *keyname;
keysym = xbps_array_get(allkeys, i);
keyname = xbps_dictionary_keysym_cstring_nocopy(keysym);
array = xbps_dictionary_get(alternatives, keyname);
if (array == NULL)
continue;
xbps_array_get_cstring_nocopy(array, 0, &first);
if (strcmp(pkgname, first) == 0) {
/* this pkg is the current alternative for this group */
rv = remove_symlinks(xhp,
xbps_dictionary_get(pkg_alternatives, keyname),
keyname);
if (rv != 0)
break;
}
xbps_set_cb_state(xhp, XBPS_STATE_ALTGROUP_REMOVED, 0, NULL,
"%s: unregistered '%s' alternatives group", pkgver, keyname);
if (!update)
xbps_remove_string_from_array(array, pkgname);
if (xbps_array_count(array) == 0) {
xbps_dictionary_remove(alternatives, keyname);
} else {
xbps_dictionary_t curpkgd;
first = NULL;
xbps_array_get_cstring_nocopy(array, 0, &first);
curpkgd = xbps_pkgdb_get_pkg(xhp, first);
assert(curpkgd);
xbps_set_cb_state(xhp, XBPS_STATE_ALTGROUP_SWITCHED, 0, NULL,
"Switched '%s' alternatives group to '%s'", keyname, first);
pkg_alternatives = xbps_dictionary_get(curpkgd, "alternatives");
rv = create_symlinks(xhp,
xbps_dictionary_get(pkg_alternatives, keyname),
keyname);
if (rv != 0)
break;
}
}
xbps_object_release(allkeys);
free(pkgname);
return rv;
}
int
xbps_alternatives_set(struct xbps_handle *xhp, const char *pkgname,
const char *group)
{
xbps_array_t allkeys;
xbps_dictionary_t alternatives, pkg_alternatives, pkgd;
const char *pkgver;
int rv = 0;
assert(xhp);
assert(pkgname);
alternatives = xbps_dictionary_get(xhp->pkgdb, "_XBPS_ALTERNATIVES_");
if (alternatives == NULL)
return ENOENT;
pkgd = xbps_pkgdb_get_pkg(xhp, pkgname);
if (pkgd == NULL)
return ENOENT;
pkg_alternatives = xbps_dictionary_get(pkgd, "alternatives");
if (!xbps_dictionary_count(pkg_alternatives))
return ENOENT;
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
allkeys = xbps_dictionary_all_keys(pkg_alternatives);
for (unsigned int i = 0; i < xbps_array_count(allkeys); i++) {
xbps_array_t array;
xbps_object_t keysym;
xbps_string_t kstr;
const char *keyname;
keysym = xbps_array_get(allkeys, i);
keyname = xbps_dictionary_keysym_cstring_nocopy(keysym);
if (group && strcmp(keyname, group)) {
rv = ENOENT;
continue;
}
array = xbps_dictionary_get(alternatives, keyname);
if (array == NULL)
continue;
/* put this alternative group at the head */
xbps_remove_string_from_array(array, pkgname);
kstr = xbps_string_create_cstring(pkgname);
xbps_array_add_first(array, kstr);
xbps_object_release(kstr);
/* apply the alternatives group */
xbps_set_cb_state(xhp, XBPS_STATE_ALTGROUP_ADDED, 0, NULL,
"%s: applying '%s' alternatives group", pkgver, keyname);
rv = create_symlinks(xhp, xbps_dictionary_get(pkg_alternatives, keyname), keyname);
if (rv != 0)
break;
}
xbps_object_release(allkeys);
return rv;
}
static int
create_symlinks(struct xbps_handle *xhp, xbps_array_t a, const char *grname)
{
unsigned int i, cnt;
cnt = xbps_array_count(a);
for (i = 0; i < cnt; i++) {
xbps_string_t str;
char *tgt_dup, *tgt_dir, *lnk_dup, *lnk_dir;
char *l, *lnk, *tgt = NULL;
const char *tgt0;
int rv;
str = xbps_array_get(a, i);
l = left(xbps_string_cstring_nocopy(str));
assert(l);
tgt0 = right(xbps_string_cstring_nocopy(str));
assert(tgt0);
/* always create target dir, for dangling symlinks */
tgt_dup = strdup(tgt0);
assert(tgt_dup);
tgt_dir = dirname(tgt_dup);
if (strcmp(tgt_dir, ".")) {
tgt = xbps_xasprintf("%s%s", xhp->rootdir, tgt_dir);
if (xbps_mkpath(tgt, 0755) != 0) {
if (errno != EEXIST) {
rv = errno;
xbps_dbg_printf(xhp, "failed to create "
"target dir '%s' for group '%s': %s\n",
tgt, grname, strerror(errno));
free(tgt_dup);
free(tgt);
free(l);
return rv;
}
}
free(tgt);
}
/* always create link dir, for dangling symlinks */
lnk_dup = strdup(l);
assert(lnk_dup);
lnk_dir = dirname(lnk_dup);
if (strcmp(lnk_dir, ".")) {
lnk = xbps_xasprintf("%s%s", xhp->rootdir, lnk_dir);
if (xbps_mkpath(lnk, 0755) != 0) {
if (errno != EEXIST) {
rv = errno;
xbps_dbg_printf(xhp, "failed to create symlink"
"dir '%s' for group '%s': %s\n",
lnk, grname, strerror(errno));
free(tgt_dup);
free(lnk_dup);
free(lnk);
free(l);
return rv;
}
}
free(lnk);
}
free(lnk_dup);
if (l[0] != '/') {
lnk = xbps_xasprintf("%s%s/%s", xhp->rootdir, tgt_dir, l);
free(tgt_dup);
tgt_dup = strdup(tgt0);
assert(tgt_dup);
tgt = strdup(basename(tgt_dup));
free(tgt_dup);
} else {
free(tgt_dup);
tgt = strdup(tgt0);
lnk = xbps_xasprintf("%s%s", xhp->rootdir, l);
}
xbps_set_cb_state(xhp, XBPS_STATE_ALTGROUP_LINK_ADDED, 0, NULL,
"Creating '%s' alternatives group symlink: %s -> %s", grname, l, tgt);
unlink(lnk);
if (tgt[0] == '/') {
tgt_dup = relpath(lnk + strlen(xhp->rootdir), tgt);
free(tgt);
tgt = tgt_dup;
}
if ((rv = symlink(tgt, lnk)) != 0) {
xbps_dbg_printf(xhp, "failed to create alt symlink '%s'"
"for group '%s': %s\n", lnk, grname,
strerror(errno));
free(tgt);
free(lnk);
free(l);
return rv;
}
free(tgt);
free(lnk);
free(l);
}
return 0;
}
static int
download_binpkgs(struct xbps_handle *xhp, prop_object_iterator_t iter)
{
prop_object_t obj;
const char *pkgver, *repoloc, *filen, *trans;
const char *pkgname, *version, *fetchstr;
char *binfile;
int rv = 0;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
prop_dictionary_get_cstring_nocopy(obj, "transaction", &trans);
if ((strcmp(trans, "remove") == 0) ||
(strcmp(trans, "configure") == 0))
continue;
prop_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname);
prop_dictionary_get_cstring_nocopy(obj, "version", &version);
prop_dictionary_get_cstring_nocopy(obj, "repository", &repoloc);
assert(repoloc != NULL);
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
assert(pkgver != NULL);
prop_dictionary_get_cstring_nocopy(obj, "filename", &filen);
assert(filen != NULL);
binfile = xbps_path_from_repository_uri(xhp, obj, repoloc);
if (binfile == NULL) {
rv = EINVAL;
break;
}
/*
* If downloaded package is in cachedir continue.
*/
if (access(binfile, R_OK) == 0) {
free(binfile);
continue;
}
/*
* Create cachedir.
*/
if (xbps_mkpath(xhp->cachedir, 0755) == -1) {
xbps_set_cb_state(xhp, XBPS_STATE_DOWNLOAD_FAIL,
errno, pkgname, version,
"%s: [trans] cannot create cachedir `%s': %s",
pkgver, xhp->cachedir, strerror(errno));
free(binfile);
rv = errno;
break;
}
xbps_set_cb_state(xhp, XBPS_STATE_DOWNLOAD,
0, pkgname, version,
"Downloading binary package `%s' (from `%s')...",
filen, repoloc);
/*
* Fetch binary package.
*/
rv = xbps_fetch_file(xhp, binfile, xhp->cachedir, false, NULL);
if (rv == -1) {
fetchstr = xbps_fetch_error_string();
xbps_set_cb_state(xhp, XBPS_STATE_DOWNLOAD_FAIL,
fetchLastErrCode != 0 ? fetchLastErrCode : errno,
pkgname, version,
"%s: [trans] failed to download binary package "
"`%s' from `%s': %s", pkgver, filen, repoloc,
fetchstr ? fetchstr : strerror(errno));
free(binfile);
break;
}
rv = 0;
free(binfile);
}
prop_object_iterator_reset(iter);
return rv;
}
int HIDDEN
xbps_remove_pkg_files(struct xbps_handle *xhp,
xbps_dictionary_t dict,
const char *key,
const char *pkgver)
{
struct stat st;
xbps_array_t array;
xbps_object_iterator_t iter;
xbps_object_t obj;
const char *file, *sha256, *curobj = NULL;
char *path = NULL, *pkgname = NULL;
char buf[PATH_MAX];
int rv = 0;
assert(xbps_object_type(dict) == XBPS_TYPE_DICTIONARY);
assert(key != NULL);
array = xbps_dictionary_get(dict, key);
if (xbps_array_count(array) == 0)
return 0;
iter = xbps_array_iter_from_dict(dict, key);
if (iter == NULL)
return ENOMEM;
if (strcmp(key, "files") == 0)
curobj = "file";
else if (strcmp(key, "conf_files") == 0)
curobj = "configuration file";
else if (strcmp(key, "links") == 0)
curobj = "link";
else if (strcmp(key, "dirs") == 0)
curobj = "directory";
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
while ((obj = xbps_object_iterator_next(iter))) {
xbps_dictionary_get_cstring_nocopy(obj, "file", &file);
path = xbps_xasprintf("%s/%s", xhp->rootdir, file);
if ((strcmp(key, "files") == 0) ||
(strcmp(key, "conf_files") == 0)) {
/*
* Check SHA256 hash in regular files and
* configuration files.
*/
xbps_dictionary_get_cstring_nocopy(obj,
"sha256", &sha256);
rv = xbps_file_hash_check(path, sha256);
if (rv == ENOENT) {
/* missing file, ignore it */
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
rv, pkgver,
"%s: failed to check hash for %s `%s': %s",
pkgver, curobj, file, strerror(rv));
free(path);
rv = 0;
continue;
} else if (rv == ERANGE) {
rv = 0;
if ((xhp->flags &
XBPS_FLAG_FORCE_REMOVE_FILES) == 0) {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
0, pkgver,
"%s: %s `%s' SHA256 mismatch, "
"preserving file", pkgver,
curobj, file);
free(path);
continue;
} else {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
0, pkgver,
"%s: %s `%s' SHA256 mismatch, "
"forcing removal", pkgver,
curobj, file);
}
} else if (rv != 0 && rv != ERANGE) {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
rv, pkgver,
"%s: [remove] failed to check hash for "
"%s `%s': %s", pkgver, curobj, file,
strerror(rv));
free(path);
break;
}
} else if (strcmp(key, "links") == 0) {
/*
* All regular files from package were removed at this
* point, so we will only remove dangling symlinks.
*/
if (realpath(path, buf) == NULL) {
if (errno != ENOENT && errno != ELOOP) {
free(path);
rv = errno;
break;
}
}
if (stat(buf, &st) == 0) {
free(path);
continue;
}
}
/*
* Remove the object if possible.
*/
if (remove(path) == -1) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FILE_FAIL,
errno, pkgver,
"%s: failed to remove %s `%s': %s", pkgver,
curobj, file, strerror(errno));
errno = 0;
} else {
/* success */
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FILE,
0, pkgver, "Removed %s `%s'", curobj, file);
}
free(path);
}
xbps_object_iterator_release(iter);
free(pkgname);
return rv;
}
int HIDDEN
xbps_remove_pkg(struct xbps_handle *xhp, const char *pkgver, bool update)
{
xbps_dictionary_t pkgd = NULL, pkgfilesd = NULL;
char *pkgname, metafile[PATH_MAX];
int rv = 0;
pkg_state_t state = 0;
uid_t euid;
assert(xhp);
assert(pkgver);
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
euid = geteuid();
if ((pkgd = xbps_pkgdb_get_pkg(xhp, pkgname)) == NULL) {
rv = errno;
xbps_dbg_printf(xhp, "[remove] cannot find %s in pkgdb: %s\n",
pkgver, strerror(rv));
goto out;
}
if ((rv = xbps_pkg_state_dictionary(pkgd, &state)) != 0) {
xbps_dbg_printf(xhp, "[remove] cannot find %s in pkgdb: %s\n",
pkgver, strerror(rv));
goto out;
}
xbps_dbg_printf(xhp, "attempting to remove %s state %d\n", pkgver, state);
if (!update)
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE, 0, pkgver, NULL);
if (chdir(xhp->rootdir) == -1) {
rv = errno;
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: [remove] failed to chdir to rootdir `%s': %s",
pkgver, xhp->rootdir, strerror(rv));
goto out;
}
/* internalize pkg files dictionary from metadir */
snprintf(metafile, sizeof(metafile), "%s/.%s-files.plist", xhp->metadir, pkgname);
pkgfilesd = xbps_plist_dictionary_from_file(xhp, metafile);
if (pkgfilesd == NULL)
xbps_dbg_printf(xhp, "WARNING: metaplist for %s "
"doesn't exist!\n", pkgver);
/* If package was "half-removed", remove it fully. */
if (state == XBPS_PKG_STATE_HALF_REMOVED)
goto purge;
/*
* Run the pre remove action and show pre-remove message if exists.
*/
rv = xbps_pkg_exec_script(xhp, pkgd, "remove-script", "pre", update);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
errno, pkgver,
"%s: [remove] REMOVE script failed to "
"execute pre ACTION: %s",
pkgver, strerror(rv));
goto out;
}
/* show remove-msg if exists */
if ((rv = xbps_cb_message(xhp, pkgd, "remove-msg")) != 0)
goto out;
/* unregister alternatives */
if (update)
xbps_dictionary_set_bool(pkgd, "alternatives-update", true);
if ((rv = xbps_alternatives_unregister(xhp, pkgd)) != 0)
goto out;
/*
* If updating a package, we just need to execute the current
* pre-remove action target and we are done. Its files will be
* overwritten later in unpack phase.
*/
if (update) {
free(pkgname);
return 0;
}
if (pkgfilesd) {
/*
* Do the removal in 2 phases:
* 1- check if user has enough perms to remove all entries
* 2- perform removal
*/
if (check_remove_pkg_files(xhp, pkgfilesd, pkgver, euid)) {
rv = EPERM;
goto out;
}
/* Remove links */
if ((rv = remove_pkg_files(xhp, pkgfilesd, "links", pkgver)) != 0)
goto out;
/* Remove regular files */
if ((rv = remove_pkg_files(xhp, pkgfilesd, "files", pkgver)) != 0)
goto out;
/* Remove configuration files */
if ((rv = remove_pkg_files(xhp, pkgfilesd, "conf_files", pkgver)) != 0)
goto out;
/* Remove dirs */
if ((rv = remove_pkg_files(xhp, pkgfilesd, "dirs", pkgver)) != 0)
goto out;
}
/*
* Execute the post REMOVE action if file exists and we aren't
* updating the package.
*/
rv = xbps_pkg_exec_script(xhp, pkgd, "remove-script", "post", false);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: [remove] REMOVE script failed to execute "
"post ACTION: %s", pkgver, strerror(rv));
goto out;
}
/*
* Set package state to "half-removed".
*/
rv = xbps_set_pkg_state_installed(xhp, pkgver,
XBPS_PKG_STATE_HALF_REMOVED);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: [remove] failed to set state to half-removed: %s",
pkgver, strerror(rv));
goto out;
}
purge:
/*
* Execute the purge REMOVE action if file exists.
*/
rv = xbps_pkg_exec_script(xhp, pkgd, "remove-script", "purge", false);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: REMOVE script failed to execute "
"purge ACTION: %s", pkgver, strerror(rv));
goto out;
}
/*
* Remove package metadata plist.
*/
if (remove(metafile) == -1) {
if (errno != ENOENT) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: failed to remove metadata file: %s",
pkgver, strerror(errno));
}
}
/*
* Unregister package from pkgdb.
*/
xbps_dictionary_remove(xhp->pkgdb, pkgname);
xbps_dbg_printf(xhp, "[remove] unregister %s returned %d\n", pkgver, rv);
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_DONE, 0, pkgver, NULL);
out:
if (pkgname != NULL)
free(pkgname);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL, rv, pkgver,
"%s: failed to remove package: %s", pkgver, strerror(rv));
}
return rv;
}
static int
create_pkg_metaplist(struct xbps_handle *xhp, const char *pkgname, const char *pkgver,
xbps_dictionary_t propsd, xbps_dictionary_t filesd,
const void *instbuf, const size_t instbufsiz,
const void *rembuf, const size_t rembufsiz)
{
xbps_array_t array;
xbps_dictionary_t pkg_metad;
xbps_data_t data;
char *buf;
int rv = 0;
xbps_dictionary_make_immutable(propsd);
pkg_metad = xbps_dictionary_copy_mutable(propsd);
/* Add objects from XBPS_PKGFILES */
array = xbps_dictionary_get(filesd, "files");
if (xbps_array_count(array))
xbps_dictionary_set(pkg_metad, "files", array);
array = xbps_dictionary_get(filesd, "conf_files");
if (xbps_array_count(array))
xbps_dictionary_set(pkg_metad, "conf_files", array);
array = xbps_dictionary_get(filesd, "links");
if (xbps_array_count(array))
xbps_dictionary_set(pkg_metad, "links", array);
array = xbps_dictionary_get(filesd, "dirs");
if (xbps_array_count(array))
xbps_dictionary_set(pkg_metad, "dirs", array);
/* Add install/remove scripts data objects */
if (instbuf != NULL) {
data = xbps_data_create_data(instbuf, instbufsiz);
assert(data);
xbps_dictionary_set(pkg_metad, "install-script", data);
xbps_object_release(data);
}
if (rembuf != NULL) {
data = xbps_data_create_data(rembuf, rembufsiz);
assert(data);
xbps_dictionary_set(pkg_metad, "remove-script", data);
xbps_object_release(data);
}
/* Remove unneeded objs from transaction */
xbps_dictionary_remove(pkg_metad, "remove-and-update");
xbps_dictionary_remove(pkg_metad, "transaction");
xbps_dictionary_remove(pkg_metad, "state");
xbps_dictionary_remove(pkg_metad, "pkgname");
xbps_dictionary_remove(pkg_metad, "version");
/*
* Externalize pkg dictionary to metadir.
*/
if (access(xhp->metadir, R_OK|X_OK) == -1) {
if (errno == ENOENT) {
xbps_mkpath(xhp->metadir, 0755);
} else {
return errno;
}
}
buf = xbps_xasprintf("%s/.%s.plist", XBPS_META_PATH, pkgname);
if (!xbps_dictionary_externalize_to_file(pkg_metad, buf)) {
rv = errno;
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
errno, pkgver,
"%s: [unpack] failed to write metadata file `%s': %s",
pkgver, buf, strerror(errno));
}
free(buf);
xbps_object_release(pkg_metad);
return rv;
}
int HIDDEN
xbps_unpack_binary_pkg(struct xbps_handle *xhp, xbps_dictionary_t pkg_repod)
{
struct archive *ar = NULL;
struct stat st;
const char *pkgver;
char *bpkg = NULL;
int pkg_fd = -1, rv = 0;
assert(xbps_object_type(pkg_repod) == XBPS_TYPE_DICTIONARY);
xbps_dictionary_get_cstring_nocopy(pkg_repod, "pkgver", &pkgver);
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK, 0, pkgver, NULL);
bpkg = xbps_repository_pkg_path(xhp, pkg_repod);
if (bpkg == NULL) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
errno, pkgver,
"%s: [unpack] cannot determine binary package "
"file for `%s': %s", pkgver, bpkg, strerror(errno));
return errno;
}
if ((ar = archive_read_new()) == NULL) {
free(bpkg);
return ENOMEM;
}
/*
* Enable support for tar format and gzip/bzip2/lzma compression methods.
*/
archive_read_support_compression_gzip(ar);
archive_read_support_compression_bzip2(ar);
archive_read_support_compression_xz(ar);
archive_read_support_format_tar(ar);
pkg_fd = open(bpkg, O_RDONLY|O_CLOEXEC);
if (pkg_fd == -1) {
rv = errno;
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to open binary package `%s': %s",
pkgver, bpkg, strerror(rv));
goto out;
}
if (fstat(pkg_fd, &st) == -1) {
rv = errno;
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to fstat binary package `%s': %s",
pkgver, bpkg, strerror(rv));
goto out;
}
if (archive_read_open_fd(ar, pkg_fd, st.st_blksize) == ARCHIVE_FATAL) {
rv = archive_errno(ar);
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to read binary package `%s': %s",
pkgver, bpkg, strerror(rv));
goto out;
}
/*
* Extract archive files.
*/
if ((rv = unpack_archive(xhp, pkg_repod, pkgver, bpkg, ar)) != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to unpack files from archive: %s",
pkgver, strerror(rv));
goto out;
}
/*
* Set package state to unpacked.
*/
if ((rv = xbps_set_pkg_state_installed(xhp, pkgver,
XBPS_PKG_STATE_UNPACKED)) != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to set state to unpacked: %s",
pkgver, strerror(rv));
}
out:
if (pkg_fd != -1)
close(pkg_fd);
if (ar)
archive_read_finish(ar);
if (bpkg)
free(bpkg);
return rv;
}
static int
unpack_archive(struct xbps_handle *xhp,
xbps_dictionary_t pkg_repod,
const char *pkgver,
const char *fname,
struct archive *ar)
{
xbps_dictionary_t propsd, filesd, old_filesd;
xbps_array_t array, obsoletes;
xbps_object_t obj;
void *instbuf = NULL, *rembuf = NULL;
struct stat st;
struct xbps_unpack_cb_data xucd;
struct archive_entry *entry;
size_t i, entry_idx = 0, instbufsiz = 0, rembufsiz = 0;
ssize_t entry_size;
const char *file, *entry_pname, *transact, *tgtlnk;
char *pkgname, *dname, *buf, *buf2, *p, *p2;
int ar_rv, rv, entry_type, flags;
bool preserve, update, conf_file, file_exists, skip_obsoletes;
bool softreplace, skip_extract, force, metafile;
uid_t euid;
assert(xbps_object_type(pkg_repod) == XBPS_TYPE_DICTIONARY);
assert(ar != NULL);
propsd = filesd = old_filesd = NULL;
force = preserve = update = conf_file = file_exists = false;
skip_obsoletes = softreplace = metafile = false;
xbps_dictionary_get_bool(pkg_repod, "preserve", &preserve);
xbps_dictionary_get_bool(pkg_repod, "skip-obsoletes", &skip_obsoletes);
xbps_dictionary_get_bool(pkg_repod, "softreplace", &softreplace);
xbps_dictionary_get_cstring_nocopy(pkg_repod,
"transaction", &transact);
euid = geteuid();
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
if (xhp->flags & XBPS_FLAG_FORCE_UNPACK)
force = true;
if (xhp->unpack_cb != NULL) {
/* initialize data for unpack cb */
memset(&xucd, 0, sizeof(xucd));
}
if (access(xhp->rootdir, R_OK) == -1) {
if (errno != ENOENT) {
rv = errno;
goto out;
}
if (xbps_mkpath(xhp->rootdir, 0750) == -1) {
rv = errno;
goto out;
}
}
if (chdir(xhp->rootdir) == -1) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
errno, pkgver,
"%s: [unpack] failed to chdir to rootdir `%s': %s",
pkgver, xhp->rootdir, strerror(errno));
rv = errno;
goto out;
}
if (strcmp(transact, "update") == 0)
update = true;
/*
* Process the archive files.
*/
flags = set_extract_flags(euid);
for (;;) {
ar_rv = archive_read_next_header(ar, &entry);
if (ar_rv == ARCHIVE_EOF || ar_rv == ARCHIVE_FATAL)
break;
else if (ar_rv == ARCHIVE_RETRY)
continue;
entry_pname = archive_entry_pathname(entry);
entry_size = archive_entry_size(entry);
entry_type = archive_entry_filetype(entry);
/*
* Ignore directories from archive.
*/
if (entry_type == AE_IFDIR) {
archive_read_data_skip(ar);
continue;
}
if (strcmp("./INSTALL", entry_pname) == 0) {
/*
* Store file in a buffer and execute
* the "pre" action from it.
*/
instbufsiz = entry_size;
instbuf = malloc(entry_size);
assert(instbuf);
if (archive_read_data(ar, instbuf, entry_size) !=
entry_size) {
rv = EINVAL;
goto out;
}
rv = xbps_pkg_exec_buffer(xhp, instbuf, instbufsiz,
pkgver, "pre", update);
if (rv != 0) {
xbps_set_cb_state(xhp,
XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] INSTALL script failed "
"to execute pre ACTION: %s",
pkgver, strerror(rv));
goto out;
}
continue;
} else if (strcmp("./REMOVE", entry_pname) == 0) {
/* store file in a buffer */
rembufsiz = entry_size;
rembuf = malloc(entry_size);
assert(rembuf);
if (archive_read_data(ar, rembuf, entry_size) !=
entry_size) {
rv = EINVAL;
goto out;
}
continue;
} else if (strcmp("./files.plist", entry_pname) == 0) {
filesd = xbps_archive_get_dictionary(ar, entry);
if (filesd == NULL) {
rv = errno;
goto out;
}
continue;
} else if (strcmp("./props.plist", entry_pname) == 0) {
propsd = xbps_archive_get_dictionary(ar, entry);
if (propsd == NULL) {
rv = errno;
goto out;
}
continue;
}
/*
* XXX: duplicate code.
* Create the metaplist file before unpacking any real file.
*/
if (propsd && filesd && !metafile) {
rv = create_pkg_metaplist(xhp, pkgname, pkgver,
propsd, filesd, instbuf, instbufsiz,
rembuf, rembufsiz);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to create metaplist file: %s",
pkgver, strerror(rv));
goto out;
}
metafile = true;
}
/*
* If XBPS_PKGFILES or XBPS_PKGPROPS weren't found
* in the archive at this phase, skip all data.
*/
if (propsd == NULL || filesd == NULL) {
archive_read_data_skip(ar);
/*
* If we have processed 4 entries and the two
* required metadata files weren't found, bail out.
* This is not an XBPS binary package.
*/
if (entry_idx >= 3) {
xbps_set_cb_state(xhp,
XBPS_STATE_UNPACK_FAIL, ENODEV, pkgver,
"%s: [unpack] invalid binary package `%s'.",
pkgver, fname);
rv = ENODEV;
goto out;
}
entry_idx++;
continue;
}
/*
* Prepare unpack callback ops.
*/
if (xhp->unpack_cb != NULL) {
xucd.xhp = xhp;
xucd.pkgver = pkgver;
xucd.entry = entry_pname;
xucd.entry_size = entry_size;
xucd.entry_is_conf = false;
}
/*
* Compute total entries in progress data, if set.
* total_entries = files + conf_files + links.
*/
if (xhp->unpack_cb != NULL) {
xucd.entry_total_count = 0;
array = xbps_dictionary_get(filesd, "files");
xucd.entry_total_count +=
(ssize_t)xbps_array_count(array);
array = xbps_dictionary_get(filesd, "conf_files");
xucd.entry_total_count +=
(ssize_t)xbps_array_count(array);
array = xbps_dictionary_get(filesd, "links");
xucd.entry_total_count +=
(ssize_t)xbps_array_count(array);
}
/*
* Always check that extracted file exists and hash
* doesn't match, in that case overwrite the file.
* Otherwise skip extracting it.
*/
conf_file = skip_extract = file_exists = false;
if (lstat(entry_pname, &st) == 0)
file_exists = true;
if (!force && (entry_type == AE_IFREG)) {
buf = strchr(entry_pname, '.') + 1;
assert(buf != NULL);
if (file_exists) {
/*
* Handle configuration files. Check if current
* entry is a configuration file and take action
* if required. Skip packages that don't have
* "conf_files" array on its XBPS_PKGPROPS
* dictionary.
*/
if (xbps_entry_is_a_conf_file(propsd, buf)) {
conf_file = true;
if (xhp->unpack_cb != NULL)
xucd.entry_is_conf = true;
rv = xbps_entry_install_conf_file(xhp,
filesd, entry, entry_pname, pkgver,
pkgname);
if (rv == -1) {
/* error */
goto out;
} else if (rv == 0) {
/*
* Keep curfile as is.
*/
skip_extract = true;
}
} else {
rv = xbps_file_hash_check_dictionary(
xhp, filesd, "files", buf);
if (rv == -1) {
/* error */
xbps_dbg_printf(xhp,
"%s: failed to check"
" hash for `%s': %s\n",
pkgver, entry_pname,
strerror(errno));
goto out;
} else if (rv == 0) {
/*
* hash match, skip extraction.
*/
xbps_dbg_printf(xhp,
"%s: file %s "
"matches existing SHA256, "
"skipping...\n",
pkgver, entry_pname);
skip_extract = true;
}
}
}
} else if (!force && (entry_type == AE_IFLNK)) {
/*
* Check if current link from binpkg hasn't been
* modified, otherwise extract new link.
*/
buf = realpath(entry_pname, NULL);
if (buf) {
if (strcmp(xhp->rootdir, "/")) {
p = buf;
p += strlen(xhp->rootdir);
} else
p = buf;
tgtlnk = find_pkg_symlink_target(filesd,
entry_pname);
assert(tgtlnk);
if (strncmp(tgtlnk, "./", 2) == 0) {
buf2 = strdup(entry_pname);
assert(buf2);
dname = dirname(buf2);
p2 = xbps_xasprintf("%s/%s", dname, tgtlnk);
free(buf2);
} else {
p2 = strdup(tgtlnk);
assert(p2);
}
xbps_dbg_printf(xhp, "%s: symlink %s cur: %s "
"new: %s\n", pkgver, entry_pname, p, p2);
if (strcmp(p, p2) == 0) {
xbps_dbg_printf(xhp, "%s: symlink "
"%s matched, skipping...\n",
pkgver, entry_pname);
skip_extract = true;
}
free(buf);
free(p2);
}
}
/*
* Check if current file mode differs from file mode
* in binpkg and apply perms if true.
*/
if (!force && file_exists && skip_extract &&
(archive_entry_mode(entry) != st.st_mode)) {
if (chmod(entry_pname,
archive_entry_mode(entry)) != 0) {
xbps_dbg_printf(xhp,
"%s: failed "
"to set perms %s to %s: %s\n",
pkgver, archive_entry_strmode(entry),
entry_pname,
strerror(errno));
rv = EINVAL;
goto out;
}
xbps_dbg_printf(xhp, "%s: entry %s changed file "
"mode to %s.\n", pkgver, entry_pname,
archive_entry_strmode(entry));
}
/*
* Check if current uid/gid differs from file in binpkg,
* and change permissions if true.
*/
if ((!force && file_exists && skip_extract && (euid == 0)) &&
(((archive_entry_uid(entry) != st.st_uid)) ||
((archive_entry_gid(entry) != st.st_gid)))) {
if (lchown(entry_pname,
archive_entry_uid(entry),
archive_entry_gid(entry)) != 0) {
xbps_dbg_printf(xhp,
"%s: failed "
"to set uid/gid to %u:%u (%s)\n",
pkgver, archive_entry_uid(entry),
archive_entry_gid(entry),
strerror(errno));
} else {
xbps_dbg_printf(xhp, "%s: entry %s changed "
"uid/gid to %u:%u.\n", pkgver, entry_pname,
archive_entry_uid(entry),
archive_entry_gid(entry));
}
}
if (!update && conf_file && file_exists && !skip_extract) {
/*
* If installing new package preserve old configuration
* file but renaming it to <file>.old.
*/
buf = xbps_xasprintf("%s.old", entry_pname);
(void)rename(entry_pname, buf);
free(buf);
buf = NULL;
xbps_set_cb_state(xhp,
XBPS_STATE_CONFIG_FILE, 0, pkgver,
"Renamed old configuration file "
"`%s' to `%s.old'.", entry_pname, entry_pname);
}
if (!force && skip_extract) {
archive_read_data_skip(ar);
continue;
}
/*
* Reset entry_pname again because if entry's pathname
* has been changed it will become a dangling pointer.
*/
entry_pname = archive_entry_pathname(entry);
/*
* Extract entry from archive.
*/
if (archive_read_extract(ar, entry, flags) != 0) {
rv = archive_errno(ar);
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to extract file `%s': %s",
pkgver, entry_pname, strerror(rv));
} else {
if (xhp->unpack_cb != NULL) {
xucd.entry_extract_count++;
(*xhp->unpack_cb)(&xucd, xhp->unpack_cb_data);
}
}
}
/*
* XXX: duplicate code.
* Create the metaplist file if it wasn't created before.
*/
if (propsd && filesd && !metafile) {
rv = create_pkg_metaplist(xhp, pkgname, pkgver,
propsd, filesd, instbuf, instbufsiz,
rembuf, rembufsiz);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver,
"%s: [unpack] failed to create metaplist file: %s",
pkgver, strerror(rv));
goto out;
}
}
/*
* If there was any error extracting files from archive, error out.
*/
if ((rv = archive_errno(ar)) != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_UNPACK_FAIL,
rv, pkgver, NULL,
"%s: [unpack] failed to extract files: %s",
pkgver, fname, archive_error_string(ar));
goto out;
}
/*
* Skip checking for obsolete files on:
* - New package installation without "softreplace" keyword.
* - Package with "preserve" keyword.
* - Package with "skip-obsoletes" keyword.
*/
if (skip_obsoletes || preserve || (!softreplace && !update))
goto out;
/*
* Check and remove obsolete files on:
* - Package upgrade.
* - Package with "softreplace" keyword.
*/
old_filesd = xbps_pkgdb_get_pkg_metadata(xhp, pkgname);
if (old_filesd == NULL)
goto out;
obsoletes = xbps_find_pkg_obsoletes(xhp, old_filesd, filesd);
for (i = 0; i < xbps_array_count(obsoletes); i++) {
obj = xbps_array_get(obsoletes, i);
file = xbps_string_cstring_nocopy(obj);
if (remove(file) == -1) {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_OBSOLETE_FAIL,
errno, pkgver,
"%s: failed to remove obsolete entry `%s': %s",
pkgver, file, strerror(errno));
continue;
}
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_OBSOLETE,
0, pkgver, "%s: removed obsolete entry: %s", pkgver, file);
xbps_object_release(obj);
}
xbps_object_release(old_filesd);
out:
if (xbps_object_type(filesd) == XBPS_TYPE_DICTIONARY)
xbps_object_release(filesd);
if (xbps_object_type(propsd) == XBPS_TYPE_DICTIONARY)
xbps_object_release(propsd);
if (pkgname != NULL)
free(pkgname);
if (instbuf != NULL)
free(instbuf);
if (rembuf != NULL)
free(rembuf);
return rv;
}
int
xbps_transaction_commit(struct xbps_handle *xhp)
{
prop_object_t obj;
prop_object_iterator_t iter;
size_t i;
const char *pkgname, *version, *pkgver, *tract;
int rv = 0;
bool update, install, sr;
assert(prop_object_type(xhp->transd) == PROP_TYPE_DICTIONARY);
update = install = false;
iter = xbps_array_iter_from_dict(xhp->transd, "packages");
if (iter == NULL)
return EINVAL;
/*
* Download binary packages (if they come from a remote repository).
*/
xbps_set_cb_state(xhp, XBPS_STATE_TRANS_DOWNLOAD, 0, NULL, NULL, NULL);
if ((rv = download_binpkgs(xhp, iter)) != 0)
goto out;
/*
* Check SHA256 hashes for binary packages in transaction.
*/
xbps_set_cb_state(xhp, XBPS_STATE_TRANS_VERIFY, 0, NULL, NULL, NULL);
if ((rv = check_binpkgs_hash(xhp, iter)) != 0)
goto out;
/*
* Install, update, configure or remove packages as specified
* in the transaction dictionary.
*/
xbps_set_cb_state(xhp, XBPS_STATE_TRANS_RUN, 0, NULL, NULL, NULL);
i = 0;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
if ((xhp->transaction_frequency_flush > 0) &&
(++i >= xhp->transaction_frequency_flush)) {
rv = xbps_pkgdb_update(xhp, true);
if (rv != 0 && rv != ENOENT)
goto out;
i = 0;
}
update = false;
prop_dictionary_get_cstring_nocopy(obj, "transaction", &tract);
prop_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname);
prop_dictionary_get_cstring_nocopy(obj, "version", &version);
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
if (strcmp(tract, "remove") == 0) {
update = false;
sr = false;
/*
* Remove package.
*/
prop_dictionary_get_bool(obj, "remove-and-update",
&update);
prop_dictionary_get_bool(obj, "softreplace", &sr);
rv = xbps_remove_pkg(xhp, pkgname, version, update, sr);
if (rv != 0)
goto out;
} else if (strcmp(tract, "configure") == 0) {
/*
* Reconfigure pending package.
*/
rv = xbps_configure_pkg(xhp, pkgname, false, false, false);
if (rv != 0)
goto out;
} else {
/*
* Install or update a package.
*/
if (strcmp(tract, "update") == 0)
update = true;
else
install = true;
if (update) {
/*
* Update a package: execute pre-remove
* action if found before unpacking.
*/
xbps_set_cb_state(xhp, XBPS_STATE_UPDATE, 0,
pkgname, version, NULL);
rv = xbps_remove_pkg(xhp, pkgname, version,
true, false);
if (rv != 0) {
xbps_set_cb_state(xhp,
XBPS_STATE_UPDATE_FAIL,
rv, pkgname, version,
"%s: [trans] failed to update "
"package to `%s': %s", pkgver,
version, strerror(rv));
goto out;
}
} else {
/* Install a package */
xbps_set_cb_state(xhp, XBPS_STATE_INSTALL,
0, pkgname, version, NULL);
}
/*
* Unpack binary package.
*/
if ((rv = xbps_unpack_binary_pkg(xhp, obj)) != 0)
goto out;
/*
* Register package.
*/
if ((rv = xbps_register_pkg(xhp, obj, false)) != 0)
goto out;
}
}
prop_object_iterator_reset(iter);
/* force a flush now packages were removed/unpacked */
if ((rv = xbps_pkgdb_update(xhp, true)) != 0)
goto out;
/* if there are no packages to install or update we are done */
if (!update && !install)
goto out;
/*
* Configure all unpacked packages.
*/
xbps_set_cb_state(xhp, XBPS_STATE_TRANS_CONFIGURE, 0, NULL, NULL, NULL);
i = 0;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
if (xhp->transaction_frequency_flush > 0 &&
++i >= xhp->transaction_frequency_flush) {
if ((rv = xbps_pkgdb_update(xhp, true)) != 0)
goto out;
i = 0;
}
prop_dictionary_get_cstring_nocopy(obj, "transaction", &tract);
if ((strcmp(tract, "remove") == 0) ||
(strcmp(tract, "configure") == 0))
continue;
prop_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname);
prop_dictionary_get_cstring_nocopy(obj, "version", &version);
update = false;
if (strcmp(tract, "update") == 0)
update = true;
rv = xbps_configure_pkg(xhp, pkgname, false, update, false);
if (rv != 0)
goto out;
/*
* Notify client callback when a package has been
* installed or updated.
*/
if (update) {
xbps_set_cb_state(xhp, XBPS_STATE_UPDATE_DONE, 0,
pkgname, version, NULL);
} else {
xbps_set_cb_state(xhp, XBPS_STATE_INSTALL_DONE, 0,
pkgname, version, NULL);
}
}
/* Force a flush now that packages are configured */
rv = xbps_pkgdb_update(xhp, true);
out:
prop_object_iterator_release(iter);
return rv;
}
/*
* Returns 1 if entry should be installed, 0 if don't or -1 on error.
*/
int HIDDEN
xbps_entry_install_conf_file(struct xbps_handle *xhp,
xbps_dictionary_t filesd,
struct archive_entry *entry,
const char *entry_pname,
const char *pkgver,
const char *pkgname)
{
xbps_dictionary_t forigd;
xbps_object_t obj, obj2;
xbps_object_iterator_t iter, iter2;
const char *cffile, *sha256_new = NULL;
char *buf, *sha256_cur = NULL, *sha256_orig = NULL;
int rv = 0;
assert(xbps_object_type(filesd) == XBPS_TYPE_DICTIONARY);
assert(entry != NULL);
assert(entry_pname != NULL);
assert(pkgver != NULL);
iter = xbps_array_iter_from_dict(filesd, "conf_files");
if (iter == NULL)
return -1;
/*
* Get original hash for the file from current
* installed package.
*/
xbps_dbg_printf(xhp, "%s: processing conf_file %s\n",
pkgver, entry_pname);
forigd = xbps_pkgdb_get_pkg_metadata(xhp, pkgname);
if (forigd == NULL) {
xbps_dbg_printf(xhp, "%s: conf_file %s not currently "
"installed\n", pkgver, entry_pname);
rv = 1;
goto out;
}
iter2 = xbps_array_iter_from_dict(forigd, "conf_files");
if (iter2 != NULL) {
while ((obj2 = xbps_object_iterator_next(iter2))) {
xbps_dictionary_get_cstring_nocopy(obj2,
"file", &cffile);
buf = xbps_xasprintf(".%s", cffile);
if (strcmp(entry_pname, buf) == 0) {
xbps_dictionary_get_cstring(obj2, "sha256",
&sha256_orig);
free(buf);
break;
}
free(buf);
buf = NULL;
}
xbps_object_iterator_release(iter2);
}
/*
* First case: original hash not found, install new file.
*/
if (sha256_orig == NULL) {
xbps_dbg_printf(xhp, "%s: conf_file %s not installed\n",
pkgver, entry_pname);
rv = 1;
goto out;
}
/*
* Compare original, installed and new hash for current file.
*/
while ((obj = xbps_object_iterator_next(iter))) {
xbps_dictionary_get_cstring_nocopy(obj, "file", &cffile);
buf = xbps_xasprintf(".%s", cffile);
if (strcmp(entry_pname, buf)) {
free(buf);
buf = NULL;
continue;
}
sha256_cur = xbps_file_hash(buf);
free(buf);
xbps_dictionary_get_cstring_nocopy(obj, "sha256", &sha256_new);
if (sha256_cur == NULL) {
if (errno == ENOENT) {
/*
* File not installed, install new one.
*/
xbps_dbg_printf(xhp, "%s: conf_file %s not "
"installed\n", pkgver, entry_pname);
rv = 1;
break;
} else {
rv = -1;
break;
}
}
/*
* Orig = X, Curr = X, New = X
*
* Keep file as is (no changes).
*/
if ((strcmp(sha256_orig, sha256_cur) == 0) &&
(strcmp(sha256_orig, sha256_new) == 0) &&
(strcmp(sha256_cur, sha256_new) == 0)) {
xbps_dbg_printf(xhp, "%s: conf_file %s orig = X, "
"cur = X, new = X\n", pkgver, entry_pname);
rv = 0;
break;
/*
* Orig = X, Curr = X, New = Y
*
* Install new file (installed file hasn't been modified).
*/
} else if ((strcmp(sha256_orig, sha256_cur) == 0) &&
(strcmp(sha256_orig, sha256_new)) &&
(strcmp(sha256_cur, sha256_new))) {
xbps_set_cb_state(xhp, XBPS_STATE_CONFIG_FILE,
0, pkgver,
"Updating configuration file `%s' provided "
"by `%s'.", cffile, pkgver);
rv = 1;
break;
/*
* Orig = X, Curr = Y, New = X
*
* Keep installed file as is because it has been modified,
* but new package doesn't contain new changes compared
* to the original version.
*/
} else if ((strcmp(sha256_orig, sha256_new) == 0) &&
(strcmp(sha256_cur, sha256_new)) &&
(strcmp(sha256_orig, sha256_cur))) {
xbps_set_cb_state(xhp, XBPS_STATE_CONFIG_FILE,
0, pkgver,
"Keeping modified configuration file `%s'.",
cffile);
rv = 0;
break;
/*
* Orig = X, Curr = Y, New = Y
*
* Keep file as is because changes made are compatible
* with new version.
*/
} else if ((strcmp(sha256_cur, sha256_new) == 0) &&
(strcmp(sha256_orig, sha256_new)) &&
(strcmp(sha256_orig, sha256_cur))) {
xbps_dbg_printf(xhp, "%s: conf_file %s orig = X, "
"cur = Y, new = Y\n", pkgver, entry_pname);
rv = 0;
break;
/*
* Orig = X, Curr = Y, New = Z
*
* Install new file as <file>.new-<version>
*/
} else if ((strcmp(sha256_orig, sha256_cur)) &&
(strcmp(sha256_cur, sha256_new)) &&
(strcmp(sha256_orig, sha256_new))) {
const char *version;
version = xbps_pkg_version(pkgver);
assert(version);
buf = xbps_xasprintf(".%s.new-%s",
cffile, version);
xbps_set_cb_state(xhp, XBPS_STATE_CONFIG_FILE,
0, pkgver,
"Installing new configuration file to "
"`%s.new-%s'.", cffile, version);
archive_entry_set_pathname(entry, buf);
free(buf);
rv = 1;
break;
}
}
out:
if (sha256_orig)
free(sha256_orig);
if (sha256_cur)
free(sha256_cur);
xbps_object_iterator_release(iter);
xbps_dbg_printf(xhp, "%s: conf_file %s returned %d\n",
pkgver, entry_pname, rv);
return rv;
}
static int
remove_pkg_files(struct xbps_handle *xhp,
xbps_dictionary_t dict,
const char *key,
const char *pkgver)
{
xbps_array_t array;
xbps_object_iterator_t iter;
xbps_object_t obj;
const char *curobj = NULL;
/* These are symlinks in Void and must not be removed */
const char *basesymlinks[] = {
"/bin",
"/sbin",
"/usr/sbin",
"/lib",
"/lib32",
"/lib64",
"/usr/lib32",
"/usr/lib64",
"/var/run",
};
int rv = 0;
assert(xbps_object_type(dict) == XBPS_TYPE_DICTIONARY);
assert(key != NULL);
array = xbps_dictionary_get(dict, key);
if (xbps_array_count(array) == 0)
return 0;
iter = xbps_array_iter_from_dict(dict, key);
if (iter == NULL)
return ENOMEM;
if (strcmp(key, "files") == 0)
curobj = "file";
else if (strcmp(key, "conf_files") == 0)
curobj = "configuration file";
else if (strcmp(key, "links") == 0)
curobj = "link";
else if (strcmp(key, "dirs") == 0)
curobj = "directory";
xbps_object_iterator_reset(iter);
while ((obj = xbps_object_iterator_next(iter))) {
const char *file, *sha256;
char path[PATH_MAX];
bool found;
xbps_dictionary_get_cstring_nocopy(obj, "file", &file);
snprintf(path, sizeof(path), "%s/%s", xhp->rootdir, file);
if ((strcmp(key, "files") == 0) ||
(strcmp(key, "conf_files") == 0)) {
/*
* Check SHA256 hash in regular files and
* configuration files.
*/
xbps_dictionary_get_cstring_nocopy(obj,
"sha256", &sha256);
rv = xbps_file_hash_check(path, sha256);
if (rv == ENOENT) {
/* missing file, ignore it */
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
rv, pkgver,
"%s: failed to check hash for %s `%s': %s",
pkgver, curobj, file, strerror(rv));
rv = 0;
continue;
} else if (rv == ERANGE) {
rv = 0;
if ((xhp->flags &
XBPS_FLAG_FORCE_REMOVE_FILES) == 0) {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
0, pkgver,
"%s: %s `%s' SHA256 mismatch, "
"preserving file", pkgver,
curobj, file);
continue;
} else {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
0, pkgver,
"%s: %s `%s' SHA256 mismatch, "
"forcing removal", pkgver,
curobj, file);
}
} else if (rv != 0 && rv != ERANGE) {
xbps_set_cb_state(xhp,
XBPS_STATE_REMOVE_FILE_HASH_FAIL,
rv, pkgver,
"%s: [remove] failed to check hash for "
"%s `%s': %s", pkgver, curobj, file,
strerror(rv));
break;
}
}
/*
* Make sure to not remove any symlink of root directory.
*/
found = false;
for (uint8_t i = 0; i < __arraycount(basesymlinks); i++) {
if (strcmp(file, basesymlinks[i]) == 0) {
found = true;
xbps_dbg_printf(xhp, "[remove] %s ignoring "
"%s removal\n", pkgver, file);
break;
}
}
if (found) {
continue;
}
if (strcmp(key, "links") == 0) {
const char *target = NULL;
char *lnk;
xbps_dictionary_get_cstring_nocopy(obj, "target", &target);
assert(target);
lnk = xbps_symlink_target(xhp, path, target);
if (lnk == NULL) {
xbps_dbg_printf(xhp, "[remove] %s "
"symlink_target: %s\n", path, strerror(errno));
continue;
}
if (strcmp(lnk, target)) {
xbps_dbg_printf(xhp, "[remove] %s symlink "
"modified (stored %s current %s)\n", path,
target, lnk);
if ((xhp->flags & XBPS_FLAG_FORCE_REMOVE_FILES) == 0) {
free(lnk);
continue;
}
}
free(lnk);
}
/*
* Remove the object if possible.
*/
if (remove(path) == -1) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FILE_FAIL,
errno, pkgver,
"%s: failed to remove %s `%s': %s", pkgver,
curobj, file, strerror(errno));
} else {
/* success */
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FILE,
0, pkgver, "Removed %s `%s'", curobj, file);
}
}
xbps_object_iterator_release(iter);
return rv;
}
int HIDDEN
xbps_remove_pkg(struct xbps_handle *xhp,
const char *pkgver,
bool update,
bool soft_replace)
{
xbps_dictionary_t pkgd = NULL;
char *pkgname, *buf = NULL;
int rv = 0;
pkg_state_t state = 0;
assert(xhp);
assert(pkgver);
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
if ((rv = xbps_pkg_state_installed(xhp, pkgname, &state)) != 0)
goto out;
xbps_dbg_printf(xhp, "attempting to remove %s state %d\n",
pkgver, state);
if (!update)
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE, 0, pkgver, NULL);
if (chdir(xhp->rootdir) == -1) {
rv = errno;
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: [remove] failed to chdir to rootdir `%s': %s",
pkgver, xhp->rootdir, strerror(rv));
goto out;
}
/* internalize pkg dictionary from metadir */
buf = xbps_xasprintf("%s/.%s.plist", xhp->metadir, pkgname);
pkgd = xbps_dictionary_internalize_from_file(buf);
free(buf);
if (pkgd == NULL)
xbps_dbg_printf(xhp, "WARNING: metaplist for %s "
"doesn't exist!\n", pkgver);
/* If package was "half-removed", remove it fully. */
if (state == XBPS_PKG_STATE_HALF_REMOVED)
goto purge;
/*
* Run the pre remove action.
*/
if (pkgd) {
rv = xbps_pkg_exec_script(xhp, pkgd, "remove-script",
"pre", update);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
errno, pkgver,
"%s: [remove] REMOVE script failed to "
"execute pre ACTION: %s",
pkgver, strerror(rv));
goto out;
}
}
/*
* If updating a package, we just need to execute the current
* pre-remove action target and we are done. Its files will be
* overwritten later in unpack phase.
*/
if (update) {
if (pkgd)
xbps_object_release(pkgd);
free(pkgname);
return 0;
} else if (soft_replace) {
/*
* Soft replace a package. Do not remove its files, but
* execute PURGE action, remove metadata files and unregister
* from pkgdb.
*/
goto softreplace;
}
if (pkgd) {
/* Remove regular files */
if ((rv = xbps_remove_pkg_files(xhp, pkgd, "files", pkgver)) != 0)
goto out;
/* Remove configuration files */
if ((rv = xbps_remove_pkg_files(xhp, pkgd, "conf_files", pkgver)) != 0)
goto out;
/* Remove links */
if ((rv = xbps_remove_pkg_files(xhp, pkgd, "links", pkgver)) != 0)
goto out;
/* Remove dirs */
if ((rv = xbps_remove_pkg_files(xhp, pkgd, "dirs", pkgver)) != 0)
goto out;
/*
* Execute the post REMOVE action if file exists and we aren't
* updating the package.
*/
rv = xbps_pkg_exec_script(xhp, pkgd, "remove-script", "post", false);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: [remove] REMOVE script failed to execute "
"post ACTION: %s", pkgver, strerror(rv));
goto out;
}
}
softreplace:
/*
* Set package state to "half-removed".
*/
rv = xbps_set_pkg_state_installed(xhp, pkgver,
XBPS_PKG_STATE_HALF_REMOVED);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: [remove] failed to set state to half-removed: %s",
pkgver, strerror(rv));
goto out;
}
purge:
/*
* Execute the purge REMOVE action if file exists.
*/
if (pkgd) {
rv = xbps_pkg_exec_script(xhp, pkgd, "remove-script", "purge", false);
if (rv != 0) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: REMOVE script failed to execute "
"purge ACTION: %s", pkgver, strerror(rv));
goto out;
}
xbps_object_release(pkgd);
}
/*
* Remove package metadata plist.
*/
buf = xbps_xasprintf("%s/.%s.plist", xhp->metadir, pkgname);
if (remove(buf) == -1) {
if (errno != ENOENT) {
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_FAIL,
rv, pkgver,
"%s: failed to remove metadata file: %s",
pkgver, strerror(errno));
}
}
free(buf);
/*
* Unregister package from pkgdb.
*/
xbps_dictionary_remove(xhp->pkgdb, pkgname);
if ((rv = xbps_pkgdb_update(xhp, true)) != 0)
goto out;
xbps_dbg_printf(xhp, "[remove] unregister %s returned %d\n", pkgver, rv);
xbps_set_cb_state(xhp, XBPS_STATE_REMOVE_DONE, 0, pkgver, NULL);
out:
if (pkgname != NULL)
free(pkgname);
return rv;
}
int
xbps_repo_key_import(struct xbps_repo *repo)
{
xbps_dictionary_t repokeyd = NULL;
xbps_data_t pubkey = NULL;
uint16_t pubkey_size = 0;
const char *signedby = NULL;
char *hexfp = NULL;
char *p, *dbkeyd, *rkeyfile = NULL;
int import, rv = 0;
assert(repo);
/*
* If repository does not have required metadata plist, ignore it.
*/
if (!xbps_dictionary_count(repo->idxmeta)) {
xbps_dbg_printf(repo->xhp,
"[repo] `%s' unsigned repository!\n", repo->uri);
return 0;
}
/*
* Check for required objects in index-meta:
* - signature-by (string)
* - public-key (data)
* - public-key-size (number)
*/
xbps_dictionary_get_cstring_nocopy(repo->idxmeta, "signature-by", &signedby);
xbps_dictionary_get_uint16(repo->idxmeta, "public-key-size", &pubkey_size);
pubkey = xbps_dictionary_get(repo->idxmeta, "public-key");
if (signedby == NULL || pubkey_size == 0 ||
xbps_object_type(pubkey) != XBPS_TYPE_DATA) {
xbps_dbg_printf(repo->xhp,
"[repo] `%s': incomplete signed repository "
"(missing objs)\n", repo->uri);
rv = EINVAL;
goto out;
}
hexfp = xbps_pubkey2fp(repo->xhp, pubkey);
/*
* Check if the public key is alredy stored.
*/
rkeyfile = xbps_xasprintf("%s/keys/%s.plist", repo->xhp->metadir, hexfp);
repokeyd = xbps_plist_dictionary_from_file(repo->xhp, rkeyfile);
if (xbps_object_type(repokeyd) == XBPS_TYPE_DICTIONARY) {
xbps_dbg_printf(repo->xhp,
"[repo] `%s' public key already stored.\n", repo->uri);
goto out;
}
/*
* Notify the client and take appropiate action to import
* the repository public key. Pass back the public key openssh fingerprint
* to the client.
*/
import = xbps_set_cb_state(repo->xhp, XBPS_STATE_REPO_KEY_IMPORT, 0,
hexfp, "`%s' repository has been RSA signed by \"%s\"",
repo->uri, signedby);
if (import <= 0) {
rv = EAGAIN;
goto out;
}
p = strdup(rkeyfile);
dbkeyd = dirname(p);
assert(dbkeyd);
if (access(dbkeyd, R_OK|W_OK) == -1) {
rv = errno;
if (rv == ENOENT)
rv = xbps_mkpath(dbkeyd, 0755);
if (rv != 0) {
rv = errno;
xbps_dbg_printf(repo->xhp,
"[repo] `%s' cannot create %s: %s\n",
repo->uri, dbkeyd, strerror(errno));
free(p);
goto out;
}
}
free(p);
repokeyd = xbps_dictionary_create();
xbps_dictionary_set(repokeyd, "public-key", pubkey);
xbps_dictionary_set_uint16(repokeyd, "public-key-size", pubkey_size);
xbps_dictionary_set_cstring_nocopy(repokeyd, "signature-by", signedby);
if (!xbps_dictionary_externalize_to_file(repokeyd, rkeyfile)) {
rv = errno;
xbps_dbg_printf(repo->xhp,
"[repo] `%s' failed to externalize %s: %s\n",
repo->uri, rkeyfile, strerror(rv));
}
out:
if (hexfp)
free(hexfp);
if (repokeyd)
xbps_object_release(repokeyd);
if (rkeyfile)
free(rkeyfile);
return rv;
}
/*
* Returns -1 on error, 0 if transfer was not necessary (local/remote
* size and/or mtime match) and 1 if downloaded successfully.
*/
int HIDDEN
xbps_repo_sync(struct xbps_handle *xhp, const char *uri)
{
const char *arch, *fetchstr = NULL;
char *repodata, *lrepodir, *uri_fixedp;
int rv = 0;
assert(uri != NULL);
/* ignore non remote repositories */
if (!xbps_repository_is_remote(uri))
return 0;
uri_fixedp = xbps_get_remote_repo_string(uri);
if (uri_fixedp == NULL)
return -1;
if (xhp->target_arch)
arch = xhp->target_arch;
else
arch = xhp->native_arch;
/*
* Full path to repository directory to store the plist
* index file.
*/
lrepodir = xbps_xasprintf("%s/%s", xhp->metadir, uri_fixedp);
free(uri_fixedp);
/*
* Create repodir in metadir.
*/
if ((rv = xbps_mkpath(lrepodir, 0755)) == -1) {
if (errno != EEXIST) {
xbps_set_cb_state(xhp, XBPS_STATE_REPOSYNC_FAIL,
errno, NULL, "[reposync] failed "
"to create repodir `%s': %s", lrepodir,
strerror(errno));
free(lrepodir);
return rv;
}
}
if (chdir(lrepodir) == -1) {
xbps_set_cb_state(xhp, XBPS_STATE_REPOSYNC_FAIL, errno, NULL,
"[reposync] failed to change dir to repodir `%s': %s",
lrepodir, strerror(errno));
free(lrepodir);
return -1;
}
free(lrepodir);
/*
* Remote repository plist index full URL.
*/
repodata = xbps_xasprintf("%s/%s-repodata", uri, arch);
/* reposync start cb */
xbps_set_cb_state(xhp, XBPS_STATE_REPOSYNC, 0, repodata, NULL);
/*
* Download plist index file from repository.
*/
if ((rv = xbps_fetch_file(xhp, repodata, NULL)) == -1) {
/* reposync error cb */
fetchstr = xbps_fetch_error_string();
xbps_set_cb_state(xhp, XBPS_STATE_REPOSYNC_FAIL,
fetchLastErrCode != 0 ? fetchLastErrCode : errno, NULL,
"[reposync] failed to fetch file `%s': %s",
repodata, fetchstr ? fetchstr : strerror(errno));
} else if (rv == 1)
rv = 0;
free(repodata);
return rv;
}
static int
find_repo_deps(struct xbps_handle *xhp,
xbps_array_t unsorted, /* array of unsorted deps */
xbps_array_t pkg_rdeps_array, /* current pkg rundeps array */
xbps_array_t pkg_provides, /* current pkg provides array */
const char *curpkg, /* current pkgver */
unsigned short *depth) /* max recursion depth */
{
xbps_dictionary_t curpkgd = NULL;
xbps_object_t obj;
xbps_object_iterator_t iter;
xbps_array_t curpkgrdeps = NULL, curpkgprovides = NULL;
pkg_state_t state;
const char *reqpkg, *pkgver_q, *reason = NULL;
char *pkgname, *reqpkgname;
int rv = 0;
bool foundvpkg;
if (*depth >= MAX_DEPTH)
return ELOOP;
/*
* Iterate over the list of required run dependencies for
* current package.
*/
iter = xbps_array_iterator(pkg_rdeps_array);
assert(iter);
while ((obj = xbps_object_iterator_next(iter))) {
foundvpkg = false;
reqpkg = xbps_string_cstring_nocopy(obj);
if (xhp->flags & XBPS_FLAG_DEBUG) {
xbps_dbg_printf(xhp, "%s", "");
for (unsigned short x = 0; x < *depth; x++) {
xbps_dbg_printf_append(xhp, " ");
}
xbps_dbg_printf_append(xhp, "%s: requires dependency '%s': ", curpkg ? curpkg : " ", reqpkg);
}
if (((pkgname = xbps_pkgpattern_name(reqpkg)) == NULL) &&
((pkgname = xbps_pkg_name(reqpkg)) == NULL)) {
xbps_dbg_printf(xhp, "%s: can't guess pkgname for dependency: %s\n", curpkg, reqpkg);
xbps_set_cb_state(xhp, XBPS_STATE_INVALID_DEP, ENXIO, NULL,
"%s: can't guess pkgname for dependency '%s'", curpkg, reqpkg);
rv = ENXIO;
break;
}
/*
* Pass 1: check if required dependency is provided as virtual
* package via "provides", if true ignore dependency.
*/
if (pkg_provides && xbps_match_virtual_pkg_in_array(pkg_provides, reqpkg)) {
xbps_dbg_printf_append(xhp, "%s is a vpkg provided by %s, ignored.\n", pkgname, curpkg);
free(pkgname);
continue;
}
/*
* Pass 2: check if required dependency has been already
* added in the transaction dictionary.
*/
if ((curpkgd = xbps_find_pkg_in_array(unsorted, reqpkg, NULL)) ||
(curpkgd = xbps_find_virtualpkg_in_array(xhp, unsorted, reqpkg, NULL))) {
xbps_dictionary_get_cstring_nocopy(curpkgd, "pkgver", &pkgver_q);
xbps_dbg_printf_append(xhp, " (%s queued)\n", pkgver_q);
free(pkgname);
continue;
}
/*
* Pass 3: check if required dependency is already installed
* and its version is fully matched.
*/
if ((curpkgd = xbps_pkgdb_get_pkg(xhp, pkgname)) == NULL) {
if ((curpkgd = xbps_pkgdb_get_virtualpkg(xhp, pkgname))) {
foundvpkg = true;
}
}
if (curpkgd == NULL) {
if (errno && errno != ENOENT) {
/* error */
rv = errno;
xbps_dbg_printf(xhp, "failed to find installed pkg for `%s': %s\n", reqpkg, strerror(rv));
free(pkgname);
break;
}
free(pkgname);
/* Required dependency not installed */
xbps_dbg_printf_append(xhp, "not installed.\n");
reason = "install";
state = XBPS_PKG_STATE_NOT_INSTALLED;
} else {
/*
* Required dependency is installed, check if its version can
* satisfy the requirements.
*/
xbps_dictionary_get_cstring_nocopy(curpkgd, "pkgver", &pkgver_q);
/* Check its state */
if ((rv = xbps_pkg_state_dictionary(curpkgd, &state)) != 0) {
free(pkgname);
break;
}
if (foundvpkg && xbps_match_virtual_pkg_in_dict(curpkgd, reqpkg)) {
/*
* Check if required dependency is a virtual package and is satisfied
* by an installed package.
*/
xbps_dbg_printf_append(xhp, "[virtual] satisfied by `%s'.\n", pkgver_q);
free(pkgname);
continue;
}
rv = xbps_pkgpattern_match(pkgver_q, reqpkg);
if (rv == 0) {
char *curpkgname;
/*
* The version requirement is not satisfied.
*/
curpkgname = xbps_pkg_name(pkgver_q);
assert(curpkgname);
if (strcmp(pkgname, curpkgname)) {
xbps_dbg_printf_append(xhp, "not installed `%s (vpkg)'", pkgver_q);
if (xbps_dictionary_get(curpkgd, "hold")) {
xbps_dbg_printf_append(xhp, " on hold state! ignoring package.\n");
} else {
xbps_dbg_printf_append(xhp, "\n");
reason = "install";
}
} else {
xbps_dbg_printf_append(xhp, "installed `%s', must be updated", pkgver_q);
if (xbps_dictionary_get(curpkgd, "hold")) {
xbps_dbg_printf_append(xhp, " on hold state! ignoring package.\n");
} else {
xbps_dbg_printf_append(xhp, "\n");
reason = "update";
}
}
free(curpkgname);
free(pkgname);
} else if (rv == 1) {
/*
* The version requirement is satisfied.
*/
free(pkgname);
rv = 0;
if (state == XBPS_PKG_STATE_UNPACKED) {
/*
* Package matches the dependency pattern but was only unpacked,
* configure pkg.
*/
xbps_dbg_printf_append(xhp, "installed `%s', must be configured.\n", pkgver_q);
reason = "configure";
} else if (state == XBPS_PKG_STATE_INSTALLED) {
/*
* Package matches the dependency pattern and is fully installed,
* skip to next one.
*/
xbps_dbg_printf_append(xhp, "installed `%s'.\n", pkgver_q);
continue;
}
} else {
/* error matching pkgpattern */
xbps_dbg_printf(xhp, "failed to match pattern %s with %s\n", reqpkg, pkgver_q);
free(pkgname);
break;
}
}
if (xbps_dictionary_get(curpkgd, "hold")) {
xbps_dbg_printf(xhp, "%s on hold state! ignoring package.\n", curpkg);
continue;
}
/*
* Pass 4: find required dependency in repository pool.
* If dependency does not match add pkg into the missing
* deps array and pass to next one.
*/
if (((curpkgd = xbps_rpool_get_pkg(xhp, reqpkg)) == NULL) &&
((curpkgd = xbps_rpool_get_virtualpkg(xhp, reqpkg)) == NULL)) {
/* pkg not found, there was some error */
if (errno && errno != ENOENT) {
xbps_dbg_printf(xhp, "failed to find pkg for `%s' in rpool: %s\n", reqpkg, strerror(errno));
rv = errno;
break;
}
rv = add_missing_reqdep(xhp, reqpkg);
if (rv != 0 && rv != EEXIST) {
xbps_dbg_printf(xhp, "`%s': add_missing_reqdep failed\n", reqpkg);
break;
} else if (rv == EEXIST) {
xbps_dbg_printf(xhp, "`%s' missing dep already added.\n", reqpkg);
rv = 0;
continue;
} else {
xbps_dbg_printf(xhp, "`%s' added into the missing deps array.\n", reqpkg);
continue;
}
}
xbps_dictionary_get_cstring_nocopy(curpkgd, "pkgver", &pkgver_q);
reqpkgname = xbps_pkg_name(pkgver_q);
assert(reqpkgname);
/*
* Check dependency validity.
*/
pkgname = xbps_pkg_name(curpkg);
assert(pkgname);
if (strcmp(pkgname, reqpkgname) == 0) {
xbps_dbg_printf_append(xhp, "[ignoring wrong dependency %s (depends on itself)]\n", reqpkg);
xbps_remove_string_from_array(pkg_rdeps_array, reqpkg);
free(pkgname);
free(reqpkgname);
continue;
}
free(pkgname);
free(reqpkgname);
/*
* If package doesn't have rundeps, pass to the next one.
*/
curpkgrdeps = xbps_dictionary_get(curpkgd, "run_depends");
if (curpkgrdeps == NULL) {
/*
* Package is on repo, add it into the transaction dictionary.
*/
xbps_dictionary_set_cstring_nocopy(curpkgd, "transaction", reason);
rv = xbps_transaction_store(xhp, unsorted, curpkgd, reason, true);
if (rv != 0) {
xbps_dbg_printf(xhp, "xbps_transaction_store failed for `%s': %s\n", reqpkg, strerror(rv));
break;
}
continue;
}
if (xhp->flags & XBPS_FLAG_DEBUG) {
xbps_dbg_printf(xhp, "%s", "");
for (unsigned short x = 0; x < *depth; x++) {
xbps_dbg_printf_append(xhp, " ");
}
xbps_dbg_printf_append(xhp, "%s: finding dependencies:\n", pkgver_q);
}
/*
* Recursively find rundeps for current pkg dictionary.
*/
(*depth)++;
curpkgprovides = xbps_dictionary_get(curpkgd, "provides");
rv = find_repo_deps(xhp, unsorted, curpkgrdeps, curpkgprovides, pkgver_q, depth);
if (rv != 0) {
xbps_dbg_printf(xhp, "Error checking %s for rundeps: %s\n", reqpkg, strerror(rv));
break;
}
/*
* Package is on repo, add it into the transaction dictionary.
*/
xbps_dictionary_set_cstring_nocopy(curpkgd, "transaction", reason);
rv = xbps_transaction_store(xhp, unsorted, curpkgd, reason, true);
if (rv != 0) {
xbps_dbg_printf(xhp, "xbps_transaction_store failed for `%s': %s\n", reqpkg, strerror(rv));
break;
}
}
xbps_object_iterator_release(iter);
(*depth)--;
return rv;
}
