/**
* walk dependencies, showing dependencies of the target
*/
static void walk_deps(alpm_list_t *dblist, alpm_pkg_t *pkg, tdepth *depth, int rev)
{
alpm_list_t *deps, *i;
if(!pkg || ((max_depth >= 0) && (depth->level > max_depth))) {
return;
}
walked = alpm_list_add(walked, (void *)alpm_pkg_get_name(pkg));
if(rev) {
deps = alpm_pkg_compute_requiredby(pkg);
} else {
deps = get_pkg_dep_names(pkg);
}
for(i = deps; i; i = alpm_list_next(i)) {
const char *pkgname = i->data;
int last = alpm_list_next(i) ? 0 : 1;
alpm_pkg_t *dep_pkg = alpm_find_dbs_satisfier(handle, dblist, pkgname);
if(alpm_list_find_str(walked, dep_pkg ? alpm_pkg_get_name(dep_pkg) : pkgname)) {
/* if we've already seen this package, don't print in "unique" output
* and don't recurse */
if(!unique) {
print(alpm_pkg_get_name(pkg), alpm_pkg_get_name(dep_pkg), pkgname, depth, last);
}
} else {
print(alpm_pkg_get_name(pkg), alpm_pkg_get_name(dep_pkg), pkgname, depth, last);
if(dep_pkg) {
tdepth d = {
depth,
NULL,
depth->level + 1
};
depth->next = &d;
/* last dep, cut off the limb here */
if(last) {
if(depth->prev) {
depth->prev->next = &d;
d.prev = depth->prev;
depth = &d;
} else {
d.prev = NULL;
}
}
walk_deps(dblist, dep_pkg, &d, rev);
depth->next = NULL;
}
}
}
if(rev) {
FREELIST(deps);
} else {
alpm_list_free(deps);
}
}
static int process_targname(alpm_list_t *dblist, const char *targname,
int error)
{
alpm_pkg_t *pkg = alpm_find_dbs_satisfier(handle, dblist, targname);
/* #FS#23342 - skip ignored packages when user says no */
if(alpm_errno(handle) == ALPM_ERR_PKG_IGNORED) {
printf("skipping target: %s\n", targname);
return 0;
}
if(pkg) {
return process_pkg(pkg);
}
return process_group(dblist, targname, error);
}
static alpm_list_t *
pk_backend_find_provider (PkBackend *self, alpm_list_t *pkgs,
const gchar *depend, GError **error)
{
PkBitfield filters;
gboolean recursive, skip_local, skip_remote;
alpm_pkg_t *provider;
alpm_list_t *pkgcache, *syncdbs;
g_return_val_if_fail (self != NULL, pkgs);
g_return_val_if_fail (depend != NULL, pkgs);
g_return_val_if_fail (alpm != NULL, pkgs);
g_return_val_if_fail (localdb != NULL, pkgs);
recursive = pk_backend_get_bool (self, "recursive");
filters = pk_backend_get_uint (self, "filters");
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
if (alpm_find_satisfier (pkgs, depend) != NULL) {
return pkgs;
}
/* look for local dependencies */
pkgcache = alpm_db_get_pkgcache (localdb);
provider = alpm_find_satisfier (pkgcache, depend);
if (provider != NULL) {
if (!skip_local) {
pk_backend_pkg (self, provider, PK_INFO_ENUM_INSTALLED);
/* assume later dependencies will also be local */
if (recursive) {
pkgs = alpm_list_add (pkgs, provider);
}
}
return pkgs;
}
/* look for remote dependencies */
syncdbs = alpm_get_syncdbs (alpm);
provider = alpm_find_dbs_satisfier (alpm, syncdbs, depend);
if (provider != NULL) {
if (!skip_remote) {
pk_backend_pkg (self, provider, PK_INFO_ENUM_AVAILABLE);
}
/* keep looking for local dependencies */
if (recursive) {
pkgs = alpm_list_add (pkgs, provider);
}
} else {
int code = ALPM_ERR_UNSATISFIED_DEPS;
g_set_error (error, ALPM_ERROR, code, "%s: %s", depend,
alpm_strerror (code));
}
return pkgs;
}
int main(int argc, char *argv[])
{
int freelist = 0, ret = 0;
alpm_errno_t err;
const char *target_name;
alpm_pkg_t *pkg;
alpm_list_t *dblist = NULL;
if(parse_options(argc, argv) != 0) {
usage();
ret = 1;
goto finish;
}
handle = alpm_initialize(ROOTDIR, dbpath, &err);
if(!handle) {
fprintf(stderr, "error: cannot initialize alpm: %s\n",
alpm_strerror(err));
ret = 1;
goto finish;
}
if(searchsyncs) {
if(register_syncs() != 0) {
ret = 1;
goto finish;
}
dblist = alpm_get_syncdbs(handle);
} else {
dblist = alpm_list_add(dblist, alpm_get_localdb(handle));
freelist = 1;
}
/* we only care about the first non option arg for walking */
target_name = argv[optind];
pkg = alpm_find_dbs_satisfier(handle, dblist, target_name);
if(!pkg) {
fprintf(stderr, "error: package '%s' not found\n", target_name);
ret = 1;
goto finish;
}
print_start(alpm_pkg_get_name(pkg), target_name);
tdepth d = {
NULL,
NULL,
1
};
walk_deps(dblist, pkg, &d, reverse);
print_end();
if(freelist) {
alpm_list_free(dblist);
}
finish:
cleanup();
return ret;
}
