static alpm_list_t *expac_search_sync(expac_t *expac, alpm_list_t *targets)
{
return resolve_targets(alpm_get_syncdbs(expac->alpm), targets);
}
static int parse_options(int argc, char *argv[], alpm_handle_t *alpm) {
int opt, option_index = 0;
const char *i;
static struct option opts[] = {
{"readone", no_argument, 0, '1'},
{"delim", required_argument, 0, 'd'},
{"listdelim", required_argument, 0, 'l'},
{"group", required_argument, 0, 'g'},
{"help", no_argument, 0, 'h'},
{"file", no_argument, 0, 'p'},
{"humansize", required_argument, 0, 'H'},
{"query", no_argument, 0, 'Q'},
{"sync", no_argument, 0, 'S'},
{"search", no_argument, 0, 's'},
{"timefmt", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
while (-1 != (opt = getopt_long(argc, argv, "1l:d:gH:hf:pQSst:v", opts, &option_index))) {
switch (opt) {
case 'S':
if (dblist) {
fprintf(stderr, "error: can only select one repo option (use -h for help)\n");
return 1;
}
dblist = alpm_list_copy(alpm_get_syncdbs(alpm));
break;
case 'Q':
if (dblist) {
fprintf(stderr, "error: can only select one repo option (use -h for help)\n");
return 1;
}
dblist = alpm_list_add(dblist, db_local);
opt_local = true;
break;
case '1':
opt_readone = true;
break;
case 'd':
opt_delim = optarg;
break;
case 'g':
opt_groups = true;
break;
case 'l':
opt_listdelim = optarg;
break;
case 'H':
for(i = SIZE_TOKENS; *i; i++) {
if(*i == *optarg) {
opt_humansize = *optarg;
break;
}
}
if(*i == '\0') {
fprintf(stderr, "error: invalid SI size formatter: %c\n", *optarg);
return 1;
}
break;
case 'h':
usage();
return 1;
case 'p':
opt_localpkg = true;
break;
case 's':
opt_search = true;
break;
case 't':
opt_timefmt = optarg;
break;
case 'v':
opt_verbose = true;
break;
case '?':
return 1;
default:
return 1;
}
}
if (optind < argc) {
opt_format = argv[optind++];
} else {
fprintf(stderr, "error: missing format string (use -h for help)\n");
return 1;
}
while (optind < argc) {
targets = alpm_list_add(targets, argv[optind++]);
}
return 0;
}
int main (int argc, char **argv)
{
int ret=0, i;
int need=0, given=0, cycle_db=0, db_order=0;
alpm_list_t *t;
struct sigaction a;
init_config (argv[0]);
a.sa_handler = handler;
sigemptyset(&a.sa_mask);
a.sa_flags = 0;
sigaction(SIGINT, &a, NULL);
sigaction(SIGTERM, &a, NULL);
int opt;
int opt_index=0;
static struct option opts[] =
{
{"query", no_argument, 0, 'Q'},
{"sync", no_argument, 0, 'S'},
{"dbpath", required_argument, 0, 'b'},
{"deps", no_argument, 0, 'd'},
{"explicit", no_argument, 0, 'e'},
{"groups", no_argument, 0, 'g'},
{"help", no_argument, 0, 'h'},
{"info", no_argument, 0, 'i'},
{"list", no_argument, 0, 'l'},
{"foreign", no_argument, 0, 'm'},
{"file", no_argument, 0, 'p'},
{"quiet", no_argument, 0, 'q'},
{"root", required_argument, 0, 'r'},
{"search", no_argument, 0, 's'},
{"unrequired", no_argument, 0, 't'},
{"upgrades", no_argument, 0, 'u'},
{"config", required_argument, 0, 'c'},
{"just-one", no_argument, 0, '1'},
{"aur", no_argument, 0, 'A'},
{"escape", no_argument, 0, 'x'},
{"format", required_argument, 0, 'f'},
{"list-repo", required_argument, 0, 'L'},
{"query-type", required_argument, 0, 1000},
{"csep", required_argument, 0, 1001},
{"delimiter", required_argument, 0, 1001},
{"sort", required_argument, 0, 1002},
{"nocolor", no_argument, 0, 1003},
{"number", no_argument, 0, 1004},
{"get-res", no_argument, 0, 1005},
{"show-size", no_argument, 0, 1006},
{"aur-url", required_argument, 0, 1007},
{"insecure", no_argument, 0, 1008},
{"qdepends", no_argument, 0, 1009},
{"qconflicts", no_argument, 0, 1010},
{"qprovides", no_argument, 0, 1011},
{"qreplaces", no_argument, 0, 1012},
{"qrequires", no_argument, 0, 1013},
{"color", no_argument, 0, 1014},
{"version", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
while ((opt = getopt_long (argc, argv, "1Ac:b:def:ghiLlmpQqr:Sstuvx", opts, &opt_index)) != -1)
{
switch (opt)
{
case '1':
config.just_one = 1;
break;
case 'A':
if (config.aur) break;
config.aur = ++db_order;
given |= N_DB;
break;
case 'c':
FREE (config.configfile);
config.configfile = strndup (optarg, PATH_MAX);
break;
case 'b':
FREE (config.dbpath);
config.dbpath = strndup (optarg, PATH_MAX);
break;
case 'd':
config.filter |= F_DEPS;
break;
case 'e':
config.filter |= F_EXPLICIT;
break;
case 'x':
config.escape = 1;
break;
case 'f':
config.custom_out = 1;
strncpy (config.format_out, optarg, PATH_MAX);
format_str (config.format_out);
break;
case 'g':
if (config.op) break;
config.op = OP_LIST_GROUP;
config.filter |= F_GROUP;
cycle_db = 1;
break;
case 'i':
if (config.op)
{
if (config.op == OP_INFO) config.op = OP_INFO_P;
break;
}
config.op = OP_INFO;
need |= N_TARGET | N_DB;
break;
case 'L':
config.list = 1;
break;
case 'l':
if (config.op) break;
config.op = OP_LIST_REPO;
need |= N_DB;
cycle_db = 1;
break;
case 'm':
config.filter |= F_FOREIGN;
break;
case 'p':
config.is_file = 1;
need |= N_TARGET;
break;
case 'Q':
if (config.db_local) break;
config.db_local = ++db_order;
given |= N_DB;
break;
case 'q':
config.quiet = 1;
break;
case 'r':
FREE (config.rootdir);
config.rootdir = strndup (optarg, PATH_MAX);
break;
case 's':
if (config.op) break;
config.op = OP_SEARCH;
need |= N_DB;
cycle_db = 1;
break;
case 'S':
if (config.db_sync) break;
config.db_sync = ++db_order;
given |= N_DB;
break;
case 't':
config.filter |= F_UNREQUIRED;
break;
case 1000: /* --query-type */
if (config.op) break;
config.op = OP_QUERY;
if (strcmp (optarg, "depends")==0)
config.query = OP_Q_DEPENDS;
else if (strcmp (optarg, "conflicts")==0)
config.query = OP_Q_CONFLICTS;
else if (strcmp (optarg, "provides")==0)
config.query = OP_Q_PROVIDES;
else if (strcmp (optarg, "replaces")==0)
config.query = OP_Q_REPLACES;
need |= N_TARGET | N_DB;
break;
case 1009: /* --qdepends */
SETQUERY (OP_Q_DEPENDS); break;
case 1010: /* --qconflicts */
SETQUERY (OP_Q_CONFLICTS); break;
case 1011: /* --qprovides */
SETQUERY (OP_Q_PROVIDES); break;
case 1012: /* --qreplaces */
SETQUERY (OP_Q_REPLACES); break;
case 1013: /* --qrequires */
SETQUERY (OP_Q_REQUIRES); break;
case 1001: /* --delimiter */
strncpy (config.delimiter, optarg, SEP_LEN);
format_str (config.delimiter);
break;
case 1002: /* --sort */
config.sort = optarg[0];
break;
case 1003: /* --nocolor */
config.colors=0;
break;
case 1004: /* --number */
config.numbering = 1;
break;
case 1005: /* --get-res */
if (dup2(FD_RES, FD_RES) == FD_RES)
config.get_res = 1;
break;
case 1006: /* --show-size */
config.show_size = 1;
break;
case 1007: /* --aur-url */
FREE (config.aur_url);
config.aur_url = strdup (optarg);
break;
case 1008: /* --insecure */
config.insecure = 1;
break;
case 1014: /* --color */
config.colors=1;
break;
case 'u':
config.filter |= F_UPGRADES;
break;
case 'v':
version(); break;
case 'h': usage (0); break;
default: /* '?' */
usage (1);
}
}
if (config.list)
{
/* -L displays respository list and exits. */
alpm_list_t *dbs = get_db_sync ();
if (dbs)
{
for(t = dbs; t; t = alpm_list_next(t))
printf ("%s\n", (char *)t->data);
FREELIST (dbs);
}
cleanup (0);
}
if (!config.custom_out)
{
if (config.colors)
color_init();
#if defined(HAVE_GETTEXT) && defined(ENABLE_NLS)
/* TODO: specific package-query locale ? */
setlocale (LC_ALL, "");
bindtextdomain ("yaourt", LOCALEDIR);
textdomain ("yaourt");
#endif
}
if ((need & N_DB) && !(given & N_DB))
{
fprintf(stderr, "search or information must have database target (-{Q,S,A}).\n");
exit(1);
}
for (i = optind; i < argc; i++)
{
if (!config.just_one ||
!alpm_list_find_str (targets, argv[i]))
targets = alpm_list_add(targets, strdup(argv[i]));
}
if (i!=optind)
{
given |= N_TARGET;
}
if ((need & N_TARGET) && !(given & N_TARGET))
{
fprintf(stderr, "no targets specified.\n");
usage(1);
}
if (targets == NULL)
{
if (config.op == OP_SEARCH) config.op = OP_LIST_REPO_S;
}
else if (!config.op && (given & N_DB)) /* Show info by default */
config.op = OP_INFO;
// init_db_sync initializes alpm after parsing [options]
if (!init_db_sync ()) cleanup(1);
if (config.is_file)
{
for(t = targets; t; t = alpm_list_next(t))
{
alpm_pkg_t *pkg=NULL;
const char *filename = t->data;
if (alpm_pkg_load (config.handle, filename, 0, ALPM_SIG_USE_DEFAULT, &pkg)!=0 || pkg==NULL)
{
fprintf(stderr, "unable to read %s.\n", filename);
continue;
}
print_package (filename, pkg, alpm_pkg_get_str);
ret++;
}
cleanup(!ret);
}
if (cycle_db || targets)
{
for (i=1; i<=db_order && (cycle_db || targets); i++)
{
/*printf ("%d, aur %d, local %d, sync %d\n", i, config.aur, config.db_local, config.db_sync);*/
if (config.db_sync == i)
{
for(t = alpm_get_syncdbs(config.handle); t; t = alpm_list_next(t))
ret += deal_db (t->data);
if (!ret && config.op == OP_INFO_P)
{
config.op = OP_QUERY;
config.query = OP_Q_PROVIDES;
for(t = alpm_get_syncdbs(config.handle); t; t = alpm_list_next(t))
ret += deal_db (t->data);
config.op = OP_INFO_P;
}
}
else if (config.db_local == i)
ret += deal_db (alpm_get_localdb(config.handle));
else if (config.aur == i)
switch (config.op)
{
case OP_INFO:
case OP_INFO_P: ret += aur_info (&targets); break;
case OP_SEARCH: ret += aur_search (targets); break;
default: break;
}
}
}
else if (!config.aur && config.db_local)
ret += alpm_search_local (config.filter, NULL, NULL);
else if (config.aur && !(given & N_TARGET))
{
if (config.filter & F_FOREIGN)
{
/* -Am */
config.aur_foreign = 1;
config.just_one = 1;
alpm_search_local (config.filter, "%n", &targets);
ret += aur_info (&targets);
if (config.db_local)
/* -AQm */
ret += search_pkg_by_name (alpm_get_localdb(config.handle), &targets);
}
else if (config.filter & F_UPGRADES)
{
/* -Au */
config.aur_upgrades = 1;
if (config.db_local)
/* -AQu */
ret += alpm_search_local (config.filter, NULL, NULL);
alpm_search_local (F_FOREIGN | (config.filter & ~F_UPGRADES), "%n>%v", &targets);
ret += aur_info (&targets);
}
}
show_results();
/* Some cleanups */
cleanup(!ret);
return 0;
}
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;
}
static PyObject* pyalpm_get_syncdbs(PyObject *self, PyObject *dummy) {
alpm_handle_t *handle = ALPM_HANDLE(self);
return alpmlist_to_pylist(alpm_get_syncdbs(handle),
pyalpm_db_from_pmdb);
}
static void
pk_backend_search_thread (PkBackendJob *job, GVariant* params, gpointer p)
{
PkBackend *backend = pk_backend_job_get_backend (job);
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
gchar **needles = NULL;
SearchType type;
PatternFunc pattern_func;
GDestroyNotify pattern_free;
MatchFunc match_func;
PkRoleEnum role;
PkBitfield filters = 0;
gboolean skip_local, skip_remote;
const alpm_list_t *i;
alpm_list_t *patterns = NULL;
_cleanup_error_free_ GError *error = NULL;
g_return_if_fail (p == NULL);
role = pk_backend_job_get_role(job);
switch(role) {
case PK_ROLE_ENUM_GET_PACKAGES:
type = SEARCH_TYPE_ALL;
g_variant_get (params, "(t)", &filters);
break;
case PK_ROLE_ENUM_GET_DETAILS:
type = SEARCH_TYPE_DETAILS;
g_variant_get (params, "(^a&s)", &needles);
break;
case PK_ROLE_ENUM_SEARCH_FILE:
type = SEARCH_TYPE_FILES;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_GROUP:
type = SEARCH_TYPE_GROUP;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_NAME:
type = SEARCH_TYPE_NAME;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_WHAT_PROVIDES:
type = SEARCH_TYPE_PROVIDES;
g_variant_get (params, "(t^a&s)", &filters, &needles);
break;
case PK_ROLE_ENUM_SEARCH_DETAILS:
type = SEARCH_TYPE_DETAILS;
g_variant_get (params, "(t^a&s)",
&filters,
&needles);
break;
default:
g_assert_not_reached ();
break;
}
g_return_if_fail (type < SEARCH_TYPE_LAST);
pattern_func = pattern_funcs[type];
pattern_free = pattern_frees[type];
match_func = match_funcs[type];
g_return_if_fail (pattern_func != NULL);
g_return_if_fail (match_func != NULL);
skip_local = pk_bitfield_contain (filters,
PK_FILTER_ENUM_NOT_INSTALLED);
skip_remote = pk_bitfield_contain (filters, PK_FILTER_ENUM_INSTALLED);
/* convert search terms to the pattern requested */
if (needles) {
for (; *needles != NULL; ++needles) {
gpointer pattern = pattern_func (backend, *needles, &error);
if (pattern == NULL)
goto out;
patterns = alpm_list_add (patterns, pattern);
}
}
/* find installed packages first */
if (!skip_local)
pk_backend_search_db (job, priv->localdb, match_func, patterns);
if (skip_remote)
goto out;
for (i = alpm_get_syncdbs (priv->alpm); i != NULL; i = i->next) {
if (pk_backend_job_is_cancelled (job))
break;
pk_backend_search_db (job, i->data, match_func, patterns);
}
out:
if (pattern_free != NULL)
alpm_list_free_inner (patterns, pattern_free);
alpm_list_free (patterns);
pk_alpm_finish (job, error);
}
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;
}
