int main(int argc, char *argv[])
{
alpm_list_t *results = NULL, *targets = NULL;
expac_t *expac = NULL;
int r;
r = parse_options(&argc, &argv);
if(r < 0) {
return 1;
}
targets = process_targets(argc, argv);
r = expac_new(&expac, opt_config_file);
if(r < 0) {
return 1;
}
results = expac_search(expac, opt_corpus, targets);
if(results == NULL) {
return 1;
}
for(alpm_list_t *i = results; i; i = i->next) {
print_pkg(i->data, opt_format);
}
alpm_list_free_inner(targets, free);
alpm_list_free(targets);
alpm_list_free(results);
expac_free(expac);
return 0;
}
int config_free(config_t *oldconfig)
{
if(oldconfig == NULL) {
return -1;
}
alpm_list_free(oldconfig->explicit_adds);
alpm_list_free(oldconfig->explicit_removes);
alpm_list_free_inner(config->repos, (alpm_list_fn_free) config_repo_free);
alpm_list_free(config->repos);
FREELIST(oldconfig->holdpkg);
FREELIST(oldconfig->ignorepkg);
FREELIST(oldconfig->ignoregrp);
FREELIST(oldconfig->assumeinstalled);
FREELIST(oldconfig->noupgrade);
FREELIST(oldconfig->noextract);
free(oldconfig->configfile);
free(oldconfig->rootdir);
free(oldconfig->dbpath);
free(oldconfig->logfile);
free(oldconfig->gpgdir);
FREELIST(oldconfig->cachedirs);
free(oldconfig->xfercommand);
free(oldconfig->print_format);
free(oldconfig->arch);
free(oldconfig);
return 0;
}
gboolean
pk_backend_transaction_simulate (PkBackend *self, GError **error)
{
alpm_list_t *data = NULL;
gchar *prefix;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
if (alpm_trans_prepare (alpm, &data) >= 0) {
return TRUE;
}
switch (alpm_errno (alpm)) {
case ALPM_ERR_PKG_INVALID_ARCH:
prefix = alpm_pkg_build_list (data);
alpm_list_free (data);
break;
case ALPM_ERR_UNSATISFIED_DEPS:
prefix = alpm_miss_build_list (data);
alpm_list_free_inner (data, alpm_depmissing_free);
alpm_list_free (data);
break;
case ALPM_ERR_CONFLICTING_DEPS:
prefix = alpm_conflict_build_list (data);
alpm_list_free_inner (data, alpm_conflict_free);
alpm_list_free (data);
break;
case ALPM_ERR_FILE_CONFLICTS:
prefix = alpm_fileconflict_build_list (data);
alpm_list_free_inner (data, alpm_fileconflict_free);
alpm_list_free (data);
break;
default:
prefix = NULL;
if (data != NULL) {
g_warning ("unhandled error %d",
alpm_errno (alpm));
}
break;
}
if (prefix != NULL) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix,
alpm_strerror (errno));
g_free (prefix);
} else {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
}
return FALSE;
}
/** Prepare a transaction. */
int SYMEXPORT alpm_trans_prepare(alpm_handle_t *handle, alpm_list_t **data)
{
alpm_trans_t *trans;
/* Sanity checks */
CHECK_HANDLE(handle, return -1);
ASSERT(data != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
trans = handle->trans;
ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
/* If there's nothing to do, return without complaining */
if(trans->add == NULL && trans->remove == NULL) {
return 0;
}
alpm_list_t *invalid = check_arch(handle, trans->add);
if(invalid) {
if(data) {
*data = invalid;
}
RET_ERR(handle, ALPM_ERR_PKG_INVALID_ARCH, -1);
}
if(trans->add == NULL) {
if(_alpm_remove_prepare(handle, data) == -1) {
/* pm_errno is set by _alpm_remove_prepare() */
return -1;
}
} else {
if(_alpm_sync_prepare(handle, data) == -1) {
/* pm_errno is set by _alpm_sync_prepare() */
return -1;
}
}
if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
_alpm_log(handle, ALPM_LOG_DEBUG, "sorting by dependencies\n");
if(trans->add) {
alpm_list_t *add_orig = trans->add;
trans->add = _alpm_sortbydeps(handle, add_orig, trans->remove, 0);
alpm_list_free(add_orig);
}
if(trans->remove) {
alpm_list_t *rem_orig = trans->remove;
trans->remove = _alpm_sortbydeps(handle, rem_orig, NULL, 1);
alpm_list_free(rem_orig);
}
}
trans->state = STATE_PREPARED;
return 0;
}
gboolean
pk_backend_transaction_commit (PkBackend *self, GError **error)
{
alpm_list_t *data = NULL;
gchar *prefix;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
if (pk_backend_cancelled (self)) {
return TRUE;
}
pk_backend_job_set_allow_cancel (self, FALSE);
pk_backend_job_set_status (self, PK_STATUS_ENUM_RUNNING);
if (alpm_trans_commit (alpm, &data) >= 0) {
return TRUE;
}
switch (alpm_errno (alpm)) {
case ALPM_ERR_FILE_CONFLICTS:
prefix = alpm_fileconflict_build_list (data);
alpm_list_free_inner (data, alpm_fileconflict_free);
alpm_list_free (data);
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_DLT_INVALID:
prefix = alpm_string_build_list (data);
alpm_list_free (data);
break;
default:
prefix = NULL;
if (data != NULL) {
g_warning ("unhandled error %d",
alpm_errno (alpm));
}
break;
}
if (prefix != NULL) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error (error, ALPM_ERROR, errno, "%s: %s", prefix,
alpm_strerror (errno));
g_free (prefix);
} else {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
}
return FALSE;
}
static void target_arg_free (target_arg_t *t)
{
if (t) {
if (t->free_fn) {
alpm_list_free_inner (t->items, (alpm_list_fn_free) t->free_fn);
}
alpm_list_free (t->items);
alpm_list_free (t->args);
FREE (t);
}
}
target_t *target_arg_free (target_arg_t *t)
{
if (t)
{
if (t->free_fn)
alpm_list_free_inner (t->items, (alpm_list_fn_free) t->free_fn);
alpm_list_free (t->items);
alpm_list_free (t->args);
FREE (t);
}
return NULL;
}
static void _alpm_hook_free(struct _alpm_hook_t *hook)
{
if(hook) {
free(hook->name);
free(hook->desc);
_alpm_wordsplit_free(hook->cmd);
alpm_list_free_inner(hook->triggers, (alpm_list_fn_free) _alpm_trigger_free);
alpm_list_free(hook->triggers);
alpm_list_free(hook->matches);
FREELIST(hook->depends);
free(hook);
}
}
static void table_free(alpm_list_t *headers, alpm_list_t *rows)
{
alpm_list_t *i;
alpm_list_free_inner(headers, table_free_cell);
for(i = rows; i; i = alpm_list_next(i)) {
alpm_list_free_inner(i->data, table_free_cell);
alpm_list_free(i->data);
}
alpm_list_free(headers);
alpm_list_free(rows);
}
void package_free(pkg_t *pkg)
{
free(pkg->filename);
free(pkg->name);
free(pkg->version);
free(pkg->desc);
free(pkg->url);
free(pkg->packager);
free(pkg->md5sum);
free(pkg->sha256sum);
free(pkg->base64sig);
free(pkg->arch);
alpm_list_free_inner(pkg->groups, free);
alpm_list_free(pkg->groups);
alpm_list_free_inner(pkg->licenses, free);
alpm_list_free(pkg->licenses);
alpm_list_free_inner(pkg->depends, free);
alpm_list_free(pkg->depends);
alpm_list_free_inner(pkg->conflicts, free);
alpm_list_free(pkg->conflicts);
alpm_list_free_inner(pkg->provides, free);
alpm_list_free(pkg->provides);
alpm_list_free_inner(pkg->optdepends, free);
alpm_list_free(pkg->optdepends);
alpm_list_free_inner(pkg->makedepends, free);
alpm_list_free(pkg->makedepends);
alpm_list_free_inner(pkg->files, free);
alpm_list_free(pkg->files);
free(pkg);
}
void _alpm_trans_free(alpm_trans_t *trans)
{
if(trans == NULL) {
return;
}
alpm_list_free_inner(trans->add, (alpm_list_fn_free)_alpm_pkg_free_trans);
alpm_list_free(trans->add);
alpm_list_free_inner(trans->remove, (alpm_list_fn_free)_alpm_pkg_free);
alpm_list_free(trans->remove);
FREELIST(trans->skip_remove);
FREE(trans);
}
static int process_group(alpm_list_t *dbs, const char *group, int error)
{
int ret = 0;
alpm_list_t *i;
alpm_list_t *pkgs = alpm_find_group_pkgs(dbs, group);
int count = alpm_list_count(pkgs);
if(!count) {
printf("target not found: %s\n", group);
return 1;
}
if(error) {
/* we already know another target errored. there is no reason to prompt the
* user here; we already validated the group name so just move on since we
* won't actually be installing anything anyway. */
goto cleanup;
}
for(i = pkgs; i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
if(process_pkg(pkg) == 1) {
ret = 1;
goto cleanup;
}
}
cleanup:
alpm_list_free(pkgs);
return ret;
}
static void
pk_backend_config_free (PkBackendConfig *config)
{
g_return_if_fail (config != NULL);
g_free (config->arch);
g_free (config->cleanmethod);
g_free (config->dbpath);
g_free (config->gpgdir);
g_free (config->logfile);
g_free (config->root);
g_free (config->xfercmd);
FREELIST (config->cachedirs);
FREELIST (config->holdpkgs);
FREELIST (config->ignoregroups);
FREELIST (config->ignorepkgs);
FREELIST (config->localfilesiglevels);
FREELIST (config->noextracts);
FREELIST (config->noupgrades);
FREELIST (config->remotefilesiglevels);
alpm_list_free_inner (config->sections, pk_backend_config_section_free);
alpm_list_free (config->sections);
g_regex_unref (config->xrepo);
g_regex_unref (config->xarch);
}
void show_results (void)
{
if (!results) {
return;
}
alpm_list_fn_cmp fn_cmp = NULL;
switch (config.sort) {
case S_NAME: fn_cmp = (alpm_list_fn_cmp) results_cmp; break;
case S_VOTE: fn_cmp = (alpm_list_fn_cmp) results_votes_cmp; break;
case S_POP: fn_cmp = (alpm_list_fn_cmp) results_popularity_cmp; break;
case S_IDATE: fn_cmp = (alpm_list_fn_cmp) results_installdate_cmp; break;
case S_ISIZE: fn_cmp = (alpm_list_fn_cmp) results_isize_cmp; break;
case S_REL: fn_cmp = (alpm_list_fn_cmp) results_relevance_cmp; break;
}
if (fn_cmp) {
results = alpm_list_msort (results, alpm_list_count (results), fn_cmp);
}
const alpm_list_nav fn_nav = config.rsort ? alpm_list_previous : alpm_list_next;
const alpm_list_t *i_first = config.rsort ? alpm_list_last (results) : results;
for (const alpm_list_t *i = i_first; i; i = fn_nav (i)) {
const results_t *r = i->data;
if (r && r->type == R_ALPM_PKG) {
print_package ("", r->ele, alpm_pkg_get_str);
} else if (r && r->type == R_AUR_PKG) {
print_package ("", r->ele, aur_get_str);
}
}
alpm_list_free_inner (results, (alpm_list_fn_free) results_free);
alpm_list_free (results);
results = NULL;
}
/**
* call-seq:
* search(*queries, ...) → an_array
*
* Search the database with POSIX regular expressions for packages.
* === Parameters
* [*queries (splat)]
* A list of strings interpreted as POSIX regular expressions.
* For a package to be found, it must match _all_ queries terms,
* not just a single one. Each query is matched against both
* the package name and the package description, where only
* one needs to match for the package to be considered.
*
* Note that the match is not performed by Ruby or even Oniguruma/Onigmo,
* but directly in libalpm via the +regexp+ library in C.
*
* === Return value
* An array of Package instances whose names matched _all_ regular expressions.
*/
static VALUE search(int argc, VALUE argv[], VALUE self)
{
alpm_db_t* p_db = NULL;
alpm_list_t* targets = NULL;
alpm_list_t* packages = NULL;
alpm_list_t* item = NULL;
VALUE result = rb_ary_new();
int i;
Data_Get_Struct(self, alpm_db_t, p_db);
/* Convert our Ruby array to an alpm_list with C strings */
for(i=0; i < argc; i++) {
VALUE term = rb_check_string_type(argv[i]);
if (!RTEST(term)) {
rb_raise(rb_eTypeError, "Argument is not a string (#to_str)");
return Qnil;
}
targets = alpm_list_add(targets, StringValuePtr(term));
}
/* Perform the query */
packages = alpm_db_search(p_db, targets);
if (!packages)
return result;
for(item=packages; item; item = alpm_list_next(item))
rb_ary_push(result, Data_Wrap_Struct(rb_cAlpm_Package, NULL, NULL, item->data));
alpm_list_free(targets);
return result;
}
/**
* @brief Remove needed packages from the removal transaction.
*
* @param handle the context handle
* @param lp list of missing dependencies caused by the removal transaction
*/
static void remove_prepare_keep_needed(alpm_handle_t *handle, alpm_list_t *lp)
{
alpm_trans_t *trans = handle->trans;
/* Remove needed packages (which break dependencies) from target list */
while(lp != NULL) {
alpm_list_t *i;
for(i = lp; i; i = i->next) {
alpm_depmissing_t *miss = i->data;
void *vpkg;
alpm_pkg_t *pkg = alpm_pkg_find(trans->remove, miss->causingpkg);
if(pkg == NULL) {
continue;
}
trans->remove = alpm_list_remove(trans->remove, pkg, _alpm_pkg_cmp,
&vpkg);
pkg = vpkg;
if(pkg) {
_alpm_log(handle, ALPM_LOG_WARNING, _("removing %s from target list\n"),
pkg->name);
_alpm_pkg_free(pkg);
}
}
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
trans->remove, NULL, 1);
}
}
static int validate_deltas(alpm_handle_t *handle, alpm_list_t *deltas)
{
alpm_list_t *i, *errors = NULL;
if(!deltas) {
return 0;
}
/* Check integrity of deltas */
EVENT(handle, ALPM_EVENT_DELTA_INTEGRITY_START, NULL, NULL);
for(i = deltas; i; i = i->next) {
alpm_delta_t *d = i->data;
char *filepath = _alpm_filecache_find(handle, d->delta);
if(_alpm_test_checksum(filepath, d->delta_md5, ALPM_PKG_VALIDATION_MD5SUM)) {
errors = alpm_list_add(errors, filepath);
} else {
FREE(filepath);
}
}
EVENT(handle, ALPM_EVENT_DELTA_INTEGRITY_DONE, NULL, NULL);
if(errors) {
for(i = errors; i; i = i->next) {
char *filepath = i->data;
prompt_to_delete(handle, filepath, ALPM_ERR_DLT_INVALID);
FREE(filepath);
}
alpm_list_free(errors);
handle->pm_errno = ALPM_ERR_DLT_INVALID;
return -1;
}
return 0;
}
/**
* @brief Add dependencies to the removal transaction for cascading.
*
* @param handle the context handle
* @param lp list of missing dependencies caused by the removal transaction
*
* @return 0 on success, -1 on error
*/
static int remove_prepare_cascade(alpm_handle_t *handle, alpm_list_t *lp)
{
alpm_trans_t *trans = handle->trans;
while(lp) {
alpm_list_t *i;
for(i = lp; i; i = i->next) {
alpm_depmissing_t *miss = i->data;
alpm_pkg_t *info = _alpm_db_get_pkgfromcache(handle->db_local, miss->target);
if(info) {
alpm_pkg_t *copy;
if(!alpm_pkg_find(trans->remove, info->name)) {
_alpm_log(handle, ALPM_LOG_DEBUG, "pulling %s in target list\n",
info->name);
if(_alpm_pkg_dup(info, ©) == -1) {
return -1;
}
trans->remove = alpm_list_add(trans->remove, copy);
}
} else {
_alpm_log(handle, ALPM_LOG_ERROR,
_("could not find %s in database -- skipping\n"), miss->target);
}
}
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
trans->remove, NULL, 1);
}
return 0;
}
static void
pk_backend_transaction_process_new_optdepends (PkBackend *self, alpm_pkg_t *pkg,
alpm_pkg_t *old)
{
alpm_list_t *optdepends;
const alpm_list_t *i;
g_return_if_fail (self != NULL);
g_return_if_fail (pkg != NULL);
g_return_if_fail (old != NULL);
optdepends = alpm_list_diff (alpm_pkg_get_optdepends (pkg),
alpm_pkg_get_optdepends (old),
alpm_depend_compare);
if (optdepends == NULL) {
return;
}
pk_backend_output (self, "New optional dependencies:\n");
for (i = optdepends; i != NULL; i = i->next) {
gchar *depend = alpm_dep_compute_string (i->data);
gchar *output = g_strdup_printf ("%s\n", depend);
free (depend);
pk_backend_output (self, output);
g_free (output);
}
alpm_list_free (optdepends);
}
static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota)
{
alpm_list_t *unused = NULL;
alpm_list_t *vertices;
alpm_list_t *i;
vertices = graph_init(deltas, 1);
for(i = vertices; i; i = i->next) {
alpm_graph_t *v = i->data;
alpm_delta_t *vdelta = v->data;
if(strcmp(vdelta->to, to) == 0)
{
v->weight = vdelta->download_size;
}
}
dijkstra(vertices);
for(i = vertices; i; i = i->next) {
alpm_graph_t *v = i->data;
alpm_delta_t *vdelta = v->data;
if(v->weight > quota) {
unused = alpm_list_add(unused, vdelta->delta);
}
}
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
return unused;
}
int pacman_deptest(alpm_list_t *targets)
{
alpm_list_t *i;
alpm_list_t *deps = NULL;
alpm_db_t *localdb = alpm_get_localdb(config->handle);
for(i = targets; i; i = alpm_list_next(i)) {
char *target = i->data;
if(!alpm_find_satisfier(alpm_db_get_pkgcache(localdb), target)) {
deps = alpm_list_add(deps, target);
}
}
if(deps == NULL) {
return 0;
}
for(i = deps; i; i = alpm_list_next(i)) {
const char *dep = i->data;
printf("%s\n", dep);
}
alpm_list_free(deps);
return 127;
}
static off_t shortest_path(alpm_list_t *vertices, const char *to, alpm_list_t **path)
{
alpm_list_t *i;
alpm_graph_t *v = NULL;
off_t bestsize = 0;
alpm_list_t *rpath = NULL;
for(i = vertices; i; i = i->next) {
alpm_graph_t *v_i = i->data;
alpm_delta_t *d_i = v_i->data;
if(strcmp(d_i->to, to) == 0) {
if(v == NULL || v_i->weight < v->weight) {
v = v_i;
bestsize = v->weight;
}
}
}
while(v != NULL) {
alpm_delta_t *vdelta = v->data;
rpath = alpm_list_add(rpath, vdelta);
v = v->parent;
}
*path = alpm_list_reverse(rpath);
alpm_list_free(rpath);
return bestsize;
}
/** Calculates the shortest path from one version to another.
* The shortest path is defined as the path with the smallest combined
* size, not the length of the path.
* @param handle the context handle
* @param deltas the list of alpm_delta_t * objects that a file has
* @param to the file to start the search at
* @param path the pointer to a list location where alpm_delta_t * objects that
* have the smallest size are placed. NULL is set if there is no path
* possible with the files available.
* @return the size of the path stored, or LONG_MAX if path is unfindable
*/
off_t _alpm_shortest_delta_path(alpm_handle_t *handle, alpm_list_t *deltas,
const char *to, alpm_list_t **path)
{
alpm_list_t *bestpath = NULL;
alpm_list_t *vertices;
off_t bestsize = LONG_MAX;
if(deltas == NULL) {
*path = NULL;
return bestsize;
}
_alpm_log(handle, ALPM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
vertices = graph_init(deltas, 0);
graph_init_size(handle, vertices);
dijkstra(vertices);
bestsize = shortest_path(vertices, to, &bestpath);
_alpm_log(handle, ALPM_LOG_DEBUG, "delta shortest-path search complete : '%jd'\n", (intmax_t)bestsize);
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
*path = bestpath;
return bestsize;
}
/** Find group members across a list of databases.
* If a member exists in several databases, only the first database is used.
* IgnorePkg is also handled.
* @param dbs the list of alpm_db_t *
* @pram name the name of the group
* @return the list of alpm_pkg_t * (caller is responsible for alpm_list_free)
*/
alpm_list_t SYMEXPORT *alpm_find_group_pkgs(alpm_list_t *dbs,
const char *name)
{
alpm_list_t *i, *j, *pkgs = NULL, *ignorelist = NULL;
for(i = dbs; i; i = i->next) {
alpm_db_t *db = i->data;
alpm_group_t *grp = alpm_db_readgroup(db, name);
if(!grp)
continue;
for(j = grp->packages; j; j = j->next) {
alpm_pkg_t *pkg = j->data;
if(_alpm_pkg_find(ignorelist, alpm_pkg_get_name(pkg))) {
continue;
}
if(_alpm_pkg_should_ignore(db->handle, pkg)) {
ignorelist = alpm_list_add(ignorelist, pkg);
int install = 0;
QUESTION(db->handle->trans, ALPM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
NULL, NULL, &install);
if(!install)
continue;
}
if(!_alpm_pkg_find(pkgs, alpm_pkg_get_name(pkg))) {
pkgs = alpm_list_add(pkgs, pkg);
}
}
}
alpm_list_free(ignorelist);
return pkgs;
}
/**
* 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);
}
}
/**
* @brief Find the items in list `lhs` that are not present in list `rhs`.
*
* @param lhs the first list
* @param rhs the second list
* @param fn the comparison function
*
* @return a list containing all items in `lhs` not present in `rhs`
*/
alpm_list_t SYMEXPORT *alpm_list_diff(const alpm_list_t *lhs,
const alpm_list_t *rhs, alpm_list_fn_cmp fn)
{
alpm_list_t *left, *right;
alpm_list_t *ret = NULL;
left = alpm_list_copy(lhs);
left = alpm_list_msort(left, alpm_list_count(left), fn);
right = alpm_list_copy(rhs);
right = alpm_list_msort(right, alpm_list_count(right), fn);
alpm_list_diff_sorted(left, right, fn, &ret, NULL);
alpm_list_free(left);
alpm_list_free(right);
return ret;
}
/* Generates the list of packages we are going to install from the AUR, in
* topological order.
*
* @param hashdb hash database
* @param graph graph of package strings
* @param topost stack containing topological order of packages
*/
static alpm_list_t *topo_get_targets(struct pw_hashdb *hashdb, struct graph *graph,
struct stack *topost)
{
int curVertex, cnt = 0;
const char *pkgname;
enum pkgfrom_t *from = NULL;
struct pkgpair pkgpair;
alpm_list_t *final_targets = NULL;
pw_printf(PW_LOG_VDEBUG, "\n%sDependency graph:\n%s", color.bold, color.nocolor);
while (!stack_empty(topost)) {
stack_pop(topost, &curVertex);
pkgname = graph_get_vertex_data(graph, curVertex);
from = hashmap_search(hashdb->pkg_from, (void *) pkgname);
if (!from) {
alpm_list_free(final_targets);
return NULL;
}
if (cnt++) {
pw_printf(PW_LOG_VDEBUG, " -> ");
}
switch (*from) {
case PKG_FROM_LOCAL:
pw_printf(PW_LOG_VDEBUG, "%s%s (installed)%s", color.bgreen, pkgname,
color.nocolor);
break;
case PKG_FROM_SYNC:
pw_printf(PW_LOG_VDEBUG, "%s%s (found in sync)%s", color.bblue, pkgname,
color.nocolor);
break;
case PKG_FROM_AUR:
/* Magic happens here */
if (hash_search(hashdb->aur_outdated, (void *) pkgname)) {
pw_printf(PW_LOG_VDEBUG, "%s%s (AUR target)%s",
color.bred, pkgname, color.nocolor);
final_targets = alpm_list_add(final_targets, (void *) pkgname);
} else {
pkgpair.pkgname = pkgname;
if (hash_search(hashdb->aur, &pkgpair)) {
pw_printf(PW_LOG_VDEBUG, "%s%s (installed AUR)%s", color.bblue,
pkgname, color.nocolor);
} else {
/* New AUR package */
pw_printf(PW_LOG_VDEBUG, "%s%s (AUR dep)%s", color.bmag, pkgname,
color.nocolor);
final_targets = alpm_list_add(final_targets, (void *) pkgname);
}
}
break;
}
}
pw_printf(PW_LOG_VDEBUG, "\n");
print_immediate_deps(hashdb);
return final_targets;
}
/* search the local database for a matching package */
static int query_search(alpm_list_t *targets)
{
alpm_list_t *i, *searchlist;
int freelist;
alpm_db_t *db_local = alpm_option_get_localdb(config->handle);
/* if we have a targets list, search for packages matching it */
if(targets) {
searchlist = alpm_db_search(db_local, targets);
freelist = 1;
} else {
searchlist = alpm_db_get_pkgcache(db_local);
freelist = 0;
}
if(searchlist == NULL) {
return 1;
}
for(i = searchlist; i; i = alpm_list_next(i)) {
alpm_list_t *grp;
alpm_pkg_t *pkg = alpm_list_getdata(i);
if(!config->quiet) {
printf("local/%s %s", alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
} else {
printf("%s", alpm_pkg_get_name(pkg));
}
if(!config->quiet) {
if((grp = alpm_pkg_get_groups(pkg)) != NULL) {
alpm_list_t *k;
printf(" (");
for(k = grp; k; k = alpm_list_next(k)) {
const char *group = alpm_list_getdata(k);
printf("%s", group);
if(alpm_list_next(k)) {
/* only print a spacer if there are more groups */
printf(" ");
}
}
printf(")");
}
/* we need a newline and initial indent first */
printf("\n ");
indentprint(alpm_pkg_get_desc(pkg), 4);
}
printf("\n");
}
/* we only want to free if the list was a search list */
if(freelist) {
alpm_list_free(searchlist);
}
return 0;
}
/* -M (--maintainer) search. */
int powaur_maint(alpm_list_t *targets)
{
if (!targets) {
pw_printf(PW_LOG_ERROR, "argument needed for -M\n");
return -1;
} else if (alpm_list_count(targets) > 1) {
pw_printf(PW_LOG_ERROR, "-M only takes 1 argument\n");
return -1;
}
int ret;
size_t listsz;
alpm_list_t *i, *results;
struct aurpkg_t *pkg;
CURL *curl;
curl = curl_easy_new();
if (!curl) {
return error(PW_ERR_CURL_INIT);
}
/* Clear pwerrno */
CLEAR_ERRNO();
results = query_aur(curl, targets->data, AUR_QUERY_MSEARCH);
if (pwerrno != PW_ERR_OK) {
ret = -1;
goto cleanup;
} else if (!results) {
printf("No packages found.\n");
ret = -1;
goto cleanup;
}
/* Sort by alphabetical order */
listsz = alpm_list_count(results);
results = alpm_list_msort(results, listsz, aurpkg_name_cmp);
if (config->sort_votes) {
results = alpm_list_msort(results, listsz, aurpkg_vote_cmp);
}
for (i = results; i; i = i->next) {
pkg = i->data;
printf("%saur/%s%s%s %s%s %s(%d)%s\n", color.bmag, color.nocolor,
color.bold, pkg->name, color.bgreen, pkg->version,
color.byellow, pkg->votes, color.nocolor);
printf("%s%s\n", TAB, pkg->desc);
}
cleanup:
alpm_list_free_inner(results, (alpm_list_fn_free) aurpkg_free);
alpm_list_free(results);
curl_easy_cleanup(curl);
return 0;
}
int main(int argc, char *argv[]) {
int ret = 1;
alpm_handle_t *alpm;
alpm_list_t *results = NULL, *i;
alpm = alpm_init();
if (!alpm) {
return ret;
}
ret = parse_options(argc, argv, alpm);
if (ret != 0) {
goto finish;
}
/* ensure sane defaults */
if (!dblist && !opt_localpkg) {
opt_local = true;
dblist = alpm_list_add(dblist, db_local);
}
results = gather_packages(alpm, targets);
if (results == NULL) {
ret = 1;
goto finish;
}
for (i = results; i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
ret += print_pkg(pkg, opt_format);
}
ret = !!ret; /* clamp to zero/one */
if(opt_localpkg) {
alpm_list_free_inner(results, (alpm_list_fn_free)alpm_pkg_free);
}
alpm_list_free(results);
finish:
alpm_list_free(dblist);
alpm_list_free(targets);
alpm_release(alpm);
return ret;
}
