int
xbps_set_pkg_state_installed(struct xbps_handle *xhp,
const char *pkgver,
pkg_state_t state)
{
xbps_dictionary_t pkgd;
char *pkgname;
int rv = 0;
assert(pkgver != NULL);
pkgd = xbps_pkgdb_get_pkg(xhp, pkgver);
if (pkgd == NULL) {
pkgd = xbps_dictionary_create();
if (pkgd == NULL)
return ENOMEM;
if (!xbps_dictionary_set_cstring_nocopy(pkgd,
"pkgver", pkgver)) {
xbps_object_release(pkgd);
return EINVAL;
}
if ((rv = set_new_state(pkgd, state)) != 0) {
xbps_object_release(pkgd);
return rv;
}
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
if (!xbps_dictionary_set(xhp->pkgdb, pkgname, pkgd)) {
xbps_object_release(pkgd);
free(pkgname);
return EINVAL;
}
free(pkgname);
xbps_object_release(pkgd);
} else {
if ((rv = set_new_state(pkgd, state)) != 0)
return rv;
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
if (!xbps_dictionary_set(xhp->pkgdb, pkgname, pkgd)) {
free(pkgname);
return EINVAL;
}
free(pkgname);
}
return rv;
}
static int
set_new_state(xbps_dictionary_t dict, pkg_state_t state)
{
const struct state *stp;
assert(xbps_object_type(dict) == XBPS_TYPE_DICTIONARY);
for (stp = states; stp->string != NULL; stp++)
if (state == stp->number)
break;
if (stp->string == NULL)
return EINVAL;
if (!xbps_dictionary_set_cstring_nocopy(dict, "state", stp->string))
return EINVAL;
return 0;
}
xbps_dictionary_t
xbps_repo_get_virtualpkg(struct xbps_repo *repo, const char *pkg)
{
xbps_dictionary_t pkgd;
assert(repo);
assert(pkg);
if (repo->idx == NULL)
return NULL;
pkgd = xbps_find_virtualpkg_in_dict(repo->xhp, repo->idx, pkg);
if (pkgd) {
xbps_dictionary_set_cstring_nocopy(pkgd,
"repository", repo->uri);
return pkgd;
}
return NULL;
}
int HIDDEN
xbps_transaction_package_replace(struct xbps_handle *xhp, xbps_array_t pkgs)
{
for (unsigned int i = 0; i < xbps_array_count(pkgs); i++) {
xbps_array_t replaces;
xbps_object_t obj, obj2;
xbps_object_iterator_t iter;
const char *pkgver;
char *pkgname;
obj = xbps_array_get(pkgs, i);
replaces = xbps_dictionary_get(obj, "replaces");
if (replaces == NULL || xbps_array_count(replaces) == 0)
continue;
iter = xbps_array_iterator(replaces);
assert(iter);
xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
while ((obj2 = xbps_object_iterator_next(iter)) != NULL) {
xbps_dictionary_t instd, reppkgd;
const char *tract, *pattern, *curpkgver;
char *curpkgname;
bool instd_auto = false;
pattern = xbps_string_cstring_nocopy(obj2);
/*
* Find the installed package that matches the pattern
* to be replaced.
*/
if (((instd = xbps_pkgdb_get_pkg(xhp, pattern)) == NULL) &&
((instd = xbps_pkgdb_get_virtualpkg(xhp, pattern)) == NULL))
continue;
xbps_dictionary_get_cstring_nocopy(instd,
"pkgver", &curpkgver);
curpkgname = xbps_pkg_name(curpkgver);
assert(curpkgname);
/*
* Check that we are not replacing the same package,
* due to virtual packages.
*/
if (strcmp(pkgname, curpkgname) == 0) {
free(curpkgname);
continue;
}
/*
* Make sure to not add duplicates.
*/
xbps_dictionary_get_bool(instd, "automatic-install", &instd_auto);
reppkgd = xbps_find_pkg_in_array(pkgs, curpkgname, NULL);
if (reppkgd) {
xbps_dictionary_get_cstring_nocopy(reppkgd,
"transaction", &tract);
if (strcmp(tract, "remove") == 0)
continue;
/*
* Package contains replaces="pkgpattern", but the
* package that should be replaced is also in the
* transaction and it's going to be updated.
*/
xbps_dictionary_set_bool(reppkgd,
"automatic-install", instd_auto);
xbps_array_replace_dict_by_name(pkgs,
reppkgd, curpkgname);
continue;
}
/*
* If new package is providing a virtual package to the
* package that we want to replace we should respect
* the automatic-install object.
*/
if (xbps_match_virtual_pkg_in_dict(obj, pattern)) {
xbps_dictionary_set_bool(obj,
"automatic-install", instd_auto);
}
xbps_dbg_printf(xhp,
"Package `%s' will be replaced by `%s', "
"matched with `%s'\n", curpkgver, pkgver, pattern);
/*
* Add package dictionary into the transaction and mark
* it as to be "removed".
*/
xbps_dictionary_set_cstring_nocopy(instd,
"transaction", "remove");
if (!xbps_array_add_first(pkgs, instd))
return EINVAL;
free(curpkgname);
}
xbps_object_iterator_release(iter);
free(pkgname);
}
return 0;
}
int
sign_repo(struct xbps_handle *xhp, const char *repodir,
const char *privkey, const char *signedby)
{
struct stat st;
struct xbps_repo *repo;
xbps_dictionary_t pkgd, meta = NULL;
xbps_data_t data = NULL, rpubkey = NULL;
xbps_object_iterator_t iter = NULL;
xbps_object_t obj;
RSA *rsa = NULL;
unsigned char *sig;
unsigned int siglen;
uint16_t rpubkeysize, pubkeysize;
const char *arch, *pkgver, *rsignedby = NULL;
char *binpkg = NULL, *binpkg_sig = NULL, *buf = NULL, *defprivkey = NULL;
int binpkg_fd, binpkg_sig_fd, rv = 0;
bool flush = false;
if (signedby == NULL) {
fprintf(stderr, "--signedby unset! cannot sign repository\n");
return -1;
}
/*
* Check that repository index exists and not empty, otherwise bail out.
*/
repo = xbps_repo_open(xhp, repodir, true);
if (repo == NULL) {
rv = errno;
fprintf(stderr, "%s: cannot read repository data: %s\n",
_XBPS_RINDEX, strerror(errno));
goto out;
}
if (xbps_dictionary_count(repo->idx) == 0) {
fprintf(stderr, "%s: invalid repository, existing!\n", _XBPS_RINDEX);
rv = EINVAL;
goto out;
}
/*
* If privkey not set, default to ~/.ssh/id_rsa.
*/
if (privkey == NULL)
defprivkey = xbps_xasprintf("%s/.ssh/id_rsa", getenv("HOME"));
else
defprivkey = strdup(privkey);
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
OpenSSL_add_all_ciphers();
OpenSSL_add_all_digests();
if ((rsa = load_rsa_privkey(defprivkey)) == NULL) {
fprintf(stderr, "%s: failed to read the RSA privkey\n", _XBPS_RINDEX);
rv = EINVAL;
goto out;
}
/*
* Iterate over the idx dictionary and then sign all binary
* packages in this repository.
*/
iter = xbps_dictionary_iterator(repo->idx);
assert(iter);
while ((obj = xbps_object_iterator_next(iter))) {
pkgd = xbps_dictionary_get_keysym(repo->idx, obj);
xbps_dictionary_get_cstring_nocopy(pkgd, "architecture", &arch);
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
binpkg = xbps_xasprintf("%s/%s.%s.xbps", repodir, pkgver, arch);
binpkg_sig = xbps_xasprintf("%s.sig", binpkg);
/*
* Skip pkg if file signature exists
*/
if ((binpkg_sig_fd = access(binpkg_sig, R_OK)) == 0) {
if (xhp->flags & XBPS_FLAG_VERBOSE)
fprintf(stderr, "skipping %s, file signature found.\n", pkgver);
free(binpkg);
free(binpkg_sig);
close(binpkg_sig_fd);
continue;
}
/*
* Generate pkg file signature.
*/
if ((binpkg_fd = open(binpkg, O_RDONLY)) == -1) {
fprintf(stderr, "cannot read %s: %s\n", binpkg, strerror(errno));
free(binpkg);
free(binpkg_sig);
continue;
}
fstat(binpkg_fd, &st);
buf = malloc(st.st_size);
assert(buf);
if (read(binpkg_fd, buf, st.st_size) != st.st_size) {
fprintf(stderr, "failed to read %s: %s\n", binpkg, strerror(errno));
close(binpkg_fd);
free(buf);
free(binpkg);
free(binpkg_sig);
continue;
}
close(binpkg_fd);
if (!rsa_sign_buf(rsa, buf, st.st_size, &sig, &siglen)) {
fprintf(stderr, "failed to sign %s: %s\n", binpkg, strerror(errno));
free(buf);
free(binpkg);
free(binpkg_sig);
continue;
}
free(buf);
free(binpkg);
/*
* Write pkg file signature.
*/
binpkg_sig_fd = creat(binpkg_sig, 0644);
if (binpkg_sig_fd == -1) {
fprintf(stderr, "failed to create %s: %s\n", binpkg_sig, strerror(errno));
free(sig);
free(binpkg_sig);
continue;
}
if (write(binpkg_sig_fd, sig, siglen) != (ssize_t)siglen) {
fprintf(stderr, "failed to write %s: %s\n", binpkg_sig, strerror(errno));
free(sig);
free(binpkg_sig);
close(binpkg_sig_fd);
continue;
}
free(sig);
free(binpkg_sig);
close(binpkg_sig_fd);
printf("signed successfully %s\n", pkgver);
}
xbps_object_iterator_release(iter);
/*
* Check if repository index-meta contains changes compared to its
* current state.
*/
if ((buf = pubkey_from_privkey(rsa)) == NULL) {
rv = EINVAL;
goto out;
}
meta = xbps_dictionary_create();
data = xbps_data_create_data(buf, strlen(buf));
rpubkey = xbps_dictionary_get(repo->idxmeta, "public-key");
if (!xbps_data_equals(rpubkey, data))
flush = true;
free(buf);
pubkeysize = RSA_size(rsa) * 8;
xbps_dictionary_get_uint16(repo->idxmeta, "public-key-size", &rpubkeysize);
if (rpubkeysize != pubkeysize)
flush = true;
xbps_dictionary_get_cstring_nocopy(repo->idxmeta, "signature-by", &rsignedby);
if (rsignedby == NULL || strcmp(rsignedby, signedby))
flush = true;
if (!flush)
goto out;
xbps_dictionary_set(meta, "public-key", data);
xbps_dictionary_set_uint16(meta, "public-key-size", pubkeysize);
xbps_dictionary_set_cstring_nocopy(meta, "signature-by", signedby);
xbps_dictionary_set_cstring_nocopy(meta, "signature-type", "rsa");
xbps_object_release(data);
data = NULL;
if (!repodata_flush(xhp, repodir, repo->idx, meta)) {
fprintf(stderr, "failed to write repodata: %s\n", strerror(errno));
goto out;
}
printf("Signed repository (%u package%s)\n",
xbps_dictionary_count(repo->idx),
xbps_dictionary_count(repo->idx) == 1 ? "" : "s");
out:
if (defprivkey) {
free(defprivkey);
}
if (rsa) {
RSA_free(rsa);
rsa = NULL;
}
if (repo) {
xbps_repo_close(repo);
}
return rv ? -1 : 0;
}
int
sign_repo(struct xbps_handle *xhp, const char *repodir,
const char *privkey, const char *signedby)
{
struct xbps_repo *repo = NULL;
xbps_dictionary_t meta = NULL;
xbps_data_t data = NULL, rpubkey = NULL;
RSA *rsa = NULL;
uint16_t rpubkeysize, pubkeysize;
const char *rsignedby = NULL;
char *buf = NULL, *rlockfname = NULL;
int rlockfd = -1, rv = 0;
bool flush_failed = false, flush = false;
if (signedby == NULL) {
fprintf(stderr, "--signedby unset! cannot initialize signed repository\n");
return -1;
}
/*
* Check that repository index exists and not empty, otherwise bail out.
*/
repo = xbps_repo_open(xhp, repodir);
if (repo == NULL) {
rv = errno;
fprintf(stderr, "%s: cannot read repository data: %s\n",
_XBPS_RINDEX, strerror(errno));
goto out;
}
if (xbps_dictionary_count(repo->idx) == 0) {
fprintf(stderr, "%s: invalid repository, existing!\n", _XBPS_RINDEX);
rv = EINVAL;
goto out;
}
rsa = load_rsa_key(privkey);
/*
* Check if repository index-meta contains changes compared to its
* current state.
*/
if ((buf = pubkey_from_privkey(rsa)) == NULL) {
rv = EINVAL;
goto out;
}
meta = xbps_dictionary_create();
data = xbps_data_create_data(buf, strlen(buf));
rpubkey = xbps_dictionary_get(repo->idxmeta, "public-key");
if (!xbps_data_equals(rpubkey, data))
flush = true;
free(buf);
pubkeysize = RSA_size(rsa) * 8;
xbps_dictionary_get_uint16(repo->idxmeta, "public-key-size", &rpubkeysize);
if (rpubkeysize != pubkeysize)
flush = true;
xbps_dictionary_get_cstring_nocopy(repo->idxmeta, "signature-by", &rsignedby);
if (rsignedby == NULL || strcmp(rsignedby, signedby))
flush = true;
if (!flush)
goto out;
xbps_dictionary_set(meta, "public-key", data);
xbps_dictionary_set_uint16(meta, "public-key-size", pubkeysize);
xbps_dictionary_set_cstring_nocopy(meta, "signature-by", signedby);
xbps_dictionary_set_cstring_nocopy(meta, "signature-type", "rsa");
xbps_object_release(data);
data = NULL;
/* lock repository to write repodata file */
if (!xbps_repo_lock(xhp, repodir, &rlockfd, &rlockfname)) {
rv = errno;
fprintf(stderr, "%s: cannot lock repository: %s\n",
_XBPS_RINDEX, strerror(errno));
goto out;
}
flush_failed = repodata_flush(xhp, repodir, repo->idx, meta);
xbps_repo_unlock(rlockfd, rlockfname);
if (!flush_failed) {
fprintf(stderr, "failed to write repodata: %s\n", strerror(errno));
goto out;
}
printf("Initialized signed repository (%u package%s)\n",
xbps_dictionary_count(repo->idx),
xbps_dictionary_count(repo->idx) == 1 ? "" : "s");
out:
if (rsa) {
RSA_free(rsa);
rsa = NULL;
}
if (repo)
xbps_repo_close(repo);
return rv ? -1 : 0;
}
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;
}
int HIDDEN
xbps_transaction_package_replace(struct xbps_handle *xhp)
{
xbps_array_t replaces, unsorted;
xbps_dictionary_t instd, reppkgd, filesd;
xbps_object_t obj, obj2;
xbps_object_iterator_t iter;
const char *pattern, *pkgver, *curpkgver;
char *buf, *pkgname, *curpkgname;
bool instd_auto, sr;
unsigned int i;
unsorted = xbps_dictionary_get(xhp->transd, "unsorted_deps");
for (i = 0; i < xbps_array_count(unsorted); i++) {
obj = xbps_array_get(unsorted, i);
replaces = xbps_dictionary_get(obj, "replaces");
if (replaces == NULL || xbps_array_count(replaces) == 0)
continue;
iter = xbps_array_iterator(replaces);
assert(iter);
while ((obj2 = xbps_object_iterator_next(iter)) != NULL) {
pattern = xbps_string_cstring_nocopy(obj2);
/*
* Find the installed package that matches the pattern
* to be replaced.
*/
if (((instd = xbps_pkgdb_get_pkg(xhp, pattern)) == NULL) &&
((instd = xbps_pkgdb_get_virtualpkg(xhp, pattern)) == NULL))
continue;
xbps_dictionary_get_cstring_nocopy(obj,
"pkgver", &pkgver);
xbps_dictionary_get_cstring_nocopy(instd,
"pkgver", &curpkgver);
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
curpkgname = xbps_pkg_name(curpkgver);
assert(curpkgver);
/*
* Check that we are not replacing the same package,
* due to virtual packages.
*/
if (strcmp(pkgname, curpkgname) == 0) {
free(pkgname);
free(curpkgname);
continue;
}
xbps_dbg_printf(xhp,
"Package `%s' will be replaced by `%s', "
"matched with `%s'\n", curpkgver, pkgver, pattern);
instd_auto = false;
xbps_dictionary_get_bool(instd,
"automatic-install", &instd_auto);
/*
* Package contains replaces="pkgpattern", but the
* package that should be replaced is also in the
* transaction and it's going to be updated.
*/
if ((reppkgd = xbps_find_pkg_in_array(unsorted, curpkgname))) {
xbps_dbg_printf(xhp,
"found replaced pkg "
"in transaction\n");
xbps_dictionary_set_bool(instd,
"remove-and-update", true);
xbps_dictionary_set_bool(reppkgd,
"automatic-install", instd_auto);
xbps_dictionary_set_bool(reppkgd,
"skip-obsoletes", true);
xbps_array_replace_dict_by_name(unsorted,
reppkgd, curpkgname);
}
/*
* If new package is providing a virtual package to the
* package that we want to replace we should respect
* the automatic-install object.
*/
if (xbps_match_virtual_pkg_in_dict(obj,
pattern, true) ||
xbps_match_virtual_pkg_in_dict(instd,
pkgname, false)) {
xbps_dictionary_set_bool(obj,
"automatic-install", instd_auto);
}
sr = false;
xbps_dictionary_get_bool(obj, "softreplace", &sr);
if (sr) {
xbps_dictionary_set_bool(obj,
"automatic-install", instd_auto);
xbps_dictionary_set_bool(instd,
"softreplace", true);
buf = xbps_xasprintf("%s/.%s.plist",
xhp->metadir, curpkgname);
filesd = xbps_dictionary_internalize_from_file(buf);
free(buf);
assert(filesd != NULL);
buf = xbps_xasprintf("%s/.%s.plist",
xhp->metadir, pkgname);
if (!xbps_dictionary_externalize_to_file(filesd, buf)) {
free(buf);
xbps_object_release(filesd);
xbps_object_iterator_release(iter);
free(pkgname);
free(curpkgname);
return errno;
}
xbps_object_release(filesd);
free(buf);
}
/*
* Add package dictionary into the transaction and mark
* it as to be "removed".
*/
xbps_dictionary_set_cstring_nocopy(instd,
"transaction", "remove");
xbps_array_add(unsorted, instd);
free(pkgname);
free(curpkgname);
}
xbps_object_iterator_release(iter);
}
return 0;
}
static xbps_dictionary_t
collect_shlibs(struct xbps_handle *xhp, xbps_array_t pkgs, bool req)
{
xbps_object_t obj;
xbps_object_iterator_t iter;
xbps_dictionary_t d, pd;
const char *pkgver;
d = xbps_dictionary_create();
assert(d);
/* copy pkgdb to out temporary dictionary */
pd = xbps_dictionary_copy(xhp->pkgdb);
assert(pd);
/*
* copy pkgs from transaction to our dictionary, overriding them
* if they were there from pkgdb.
*/
iter = xbps_array_iterator(pkgs);
assert(iter);
while ((obj = xbps_object_iterator_next(iter))) {
char *pkgname;
if (!xbps_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver))
continue;
pkgname = xbps_pkg_name(pkgver);
assert(pkgname);
xbps_dictionary_set(pd, pkgname, obj);
free(pkgname);
}
xbps_object_iterator_release(iter);
/*
* iterate over our dictionary to collect shlib-{requires,provides}.
*/
iter = xbps_dictionary_iterator(pd);
assert(iter);
while ((obj = xbps_object_iterator_next(iter))) {
xbps_array_t shobjs;
xbps_dictionary_t pkgd;
const char *trans;
pkgd = xbps_dictionary_get_keysym(pd, obj);
if (xbps_dictionary_get_cstring_nocopy(pkgd, "transaction", &trans)) {
if (!strcmp(trans, "remove"))
continue;
}
/*
* If pkg does not have the required obj, pass to next one.
*/
xbps_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver);
shobjs = xbps_dictionary_get(pkgd,
req ? "shlib-requires" : "shlib-provides");
if (shobjs == NULL)
continue;
for (unsigned int i = 0; i < xbps_array_count(shobjs); i++) {
const char *shlib;
xbps_array_get_cstring_nocopy(shobjs, i, &shlib);
xbps_dbg_printf(xhp, "%s: registering %s for %s\n",
pkgver, shlib, req ? "shlib-requires" : "shlib-provides");
if (req)
shlib_register(d, shlib, pkgver);
else
xbps_dictionary_set_cstring_nocopy(d, shlib, pkgver);
}
}
xbps_object_iterator_release(iter);
return d;
}
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;
}
