static alpm_list_t *gather_packages(alpm_handle_t *alpm, alpm_list_t *targets) {
alpm_list_t *results = NULL;
if (opt_localpkg) {
alpm_list_t *i;
/* load each target as a package */
for (i = targets; i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg;
int err;
err = alpm_pkg_load(alpm, i->data, 0, 0, &pkg);
if (err) {
fprintf(stderr, "error: %s: %s\n", (const char*)i->data,
alpm_strerror(alpm_errno(alpm)));
continue;
}
results = alpm_list_add(results, pkg);
}
} else {
results = resolve_pkg(targets);
}
return results;
}
int main(int argc, char *argv[])
{
int retval = 1; /* default = false */
alpm_handle_t *handle;
alpm_errno_t err;
alpm_pkg_t *pkg = NULL;
const alpm_siglevel_t level = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL;
if(argc != 2) {
fprintf(stderr, "testpkg (pacman) v" PACKAGE_VERSION "\n\n"
"Test a pacman package for validity.\n\n"
"Usage: testpkg <package file>\n");
return 1;
}
handle = alpm_initialize(ROOTDIR, DBPATH, &err);
if(!handle) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
return 1;
}
/* let us get log messages from libalpm */
alpm_option_set_logcb(handle, output_cb);
/* set gpgdir to default */
alpm_option_set_gpgdir(handle, GPGDIR);
if(alpm_pkg_load(handle, argv[1], 1, level, &pkg) == -1
|| pkg == NULL) {
err = alpm_errno(handle);
switch(err) {
case ALPM_ERR_PKG_NOT_FOUND:
printf("Cannot find the given file.\n");
break;
case ALPM_ERR_PKG_OPEN:
printf("Cannot open the given file.\n");
break;
case ALPM_ERR_LIBARCHIVE:
case ALPM_ERR_PKG_INVALID:
printf("Package is invalid.\n");
break;
default:
printf("libalpm error: %s\n", alpm_strerror(err));
break;
}
retval = 1;
} else {
alpm_pkg_free(pkg);
printf("Package is valid.\n");
retval = 0;
}
if(alpm_release(handle) == -1) {
fprintf(stderr, "error releasing alpm\n");
}
return retval;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
alpm_list_t *i;
alpm_siglevel_t level = alpm_option_get_default_siglevel(config->handle);
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_fprintf(stderr, ALPM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
return 1;
} else {
free(i->data);
i->data = str;
}
}
}
/* Step 1: create a new transaction */
if(trans_init(config->flags, 1) == -1) {
return 1;
}
printf(_("loading packages...\n"));
/* add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *targ = alpm_list_getdata(i);
alpm_pkg_t *pkg;
if(alpm_pkg_load(config->handle, targ, 1, level, &pkg) != 0) {
pm_fprintf(stderr, ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
trans_release();
return 1;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_fprintf(stderr, ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
trans_release();
return 1;
}
config->explicit_adds = alpm_list_add(config->explicit_adds, pkg);
}
/* now that targets are resolved, we can hand it all off to the sync code */
return sync_prepare_execute();
}
int main(int argc, char *argv[])
{
int retval = 1; /* default = false */
pmhandle_t *handle;
enum _pmerrno_t err;
pmpkg_t *pkg = NULL;
if(argc != 2) {
fprintf(stderr, "usage: %s <package file>\n", BASENAME);
return 1;
}
handle = alpm_initialize(ROOTDIR, DBPATH, &err);
if(!handle) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
return 1;
}
/* let us get log messages from libalpm */
alpm_option_set_logcb(handle, output_cb);
if(alpm_pkg_load(handle, argv[1], 1, PM_PGP_VERIFY_OPTIONAL, &pkg) == -1
|| pkg == NULL) {
err = alpm_errno(handle);
switch(err) {
case PM_ERR_PKG_OPEN:
printf("Cannot open the given file.\n");
break;
case PM_ERR_LIBARCHIVE:
case PM_ERR_PKG_INVALID:
printf("Package is invalid.\n");
break;
default:
printf("libalpm error: %s\n", alpm_strerror(err));
break;
}
retval = 1;
} else {
alpm_pkg_free(pkg);
printf("Package is valid.\n");
retval = 0;
}
if(alpm_release(handle) == -1) {
fprintf(stderr, "error releasing alpm\n");
}
return retval;
}
/**
* call-seq:
* load_package( path , siglevel [, full ] ) → a_package
*
* Loads a Package from a file.
*
* === Parameters
* [path]
* The path to the file to load.
* [siglevel]
* The PGP signature level for the package. See #register_syncdb
* for the possible values in this array.
* [full = false]
* If unset (the default), stop loading the package after the
* metadata.
*
* === Return value
* An instance of Alpm::Package.
*/
static VALUE load_package(int argc, VALUE argv[], VALUE self)
{
VALUE rpath, rlevel, rfull;
int full = 0;
alpm_handle_t* p_alpm = NULL;
alpm_pkg_t* p_pkg = NULL;
Data_Get_Struct(self, alpm_handle_t, p_alpm);
rb_scan_args(argc, argv, "21", &rpath, &rlevel, &rfull);
full = RTEST(rfull) ? 1 : 0;
if (alpm_pkg_load(p_alpm, StringValuePtr(rpath), full, siglevel_from_ruby(rlevel), &p_pkg) < 0) {
raise_last_alpm_error(p_alpm);
return Qnil;
}
return Data_Wrap_Struct(rb_cAlpm_Package, NULL, free_loaded_pkg, p_pkg);
}
int main(int argc, char **argv)
{
int retval = 1; /* default = false */
pmpkg_t *pkg = NULL;
if(argc != 2) {
fprintf(stderr, "usage: %s <package file>\n", BASENAME);
return(1);
}
if(alpm_initialize() == -1) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
return(1);
}
/* let us get log messages from libalpm */
alpm_option_set_logcb(output_cb);
if(alpm_pkg_load(argv[1], 1, &pkg) == -1 || pkg == NULL) {
switch(pm_errno) {
case PM_ERR_PKG_OPEN:
printf("Cannot open the given file.\n");
break;
case PM_ERR_LIBARCHIVE:
case PM_ERR_PKG_INVALID:
printf("Package is invalid.\n");
break;
default:
printf("libalpm error: %s\n", alpm_strerrorlast());
break;
}
retval = 1;
} else {
alpm_pkg_free(pkg);
printf("Package is valid.\n");
retval = 0;
}
if(alpm_release() == -1) {
fprintf(stderr, "error releasing alpm: %s\n", alpm_strerrorlast());
}
return(retval);
}
static alpm_list_t *expac_search_files(expac_t *expac, alpm_list_t *targets)
{
alpm_list_t *i, *r = NULL;
for(i = targets; i; i = i->next) {
const char *path = i->data;
alpm_pkg_t *pkg;
if(alpm_pkg_load(expac->alpm, path, 0, 0, &pkg) != 0) {
fprintf(stderr, "error: %s: %s\n", path,
alpm_strerror(alpm_errno(expac->alpm)));
continue;
}
r = alpm_list_add(r, pkg);
}
return r;
}
alpm_pkg_t *pu_find_pkgspec(alpm_handle_t *handle, const char *pkgspec)
{
char *c;
if(strstr(pkgspec, "://")) {
alpm_pkg_t *pkg;
alpm_siglevel_t sl
= strncmp(pkgspec, "file://", 7) == 0
? alpm_option_get_local_file_siglevel(handle)
: alpm_option_get_remote_file_siglevel(handle);
char *path = alpm_fetch_pkgurl(handle, pkgspec);
int err = alpm_pkg_load(handle, path ? path : pkgspec, 1, sl, &pkg);
free(path);
if(!err) {
return pkg;
}
} else if((c = strchr(pkgspec, '/'))) {
alpm_db_t *db = NULL;
size_t dblen = c - pkgspec;
if(dblen == strlen("local") && memcmp(pkgspec, "local", dblen) == 0) {
db = alpm_get_localdb(handle);
} else {
alpm_list_t *i;
for(i = alpm_get_syncdbs(handle); i; i = i->next) {
const char *dbname = alpm_db_get_name(i->data);
if(dblen == strlen(dbname) && strncmp(pkgspec, dbname, dblen) == 0) {
db = i->data;
break;
}
}
}
if(!db) {
return NULL;
} else {
return alpm_db_get_pkg(db, c + 1);
}
}
return NULL;
}
PyObject *pyalpm_package_load(PyObject *self, PyObject *args, PyObject *kwargs) {
alpm_handle_t *handle = ALPM_HANDLE(self);
char *filename;
int check_sig = ALPM_SIG_PACKAGE_OPTIONAL;
char *kws[] = { "path", "check_sig", NULL };
alpm_pkg_t *result;
AlpmPackage *pyresult;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|i:load_pkg", kws, &filename, &check_sig)) {
return NULL;
}
if ((alpm_pkg_load(handle, filename, 1, check_sig, &result) == -1) || !result) {
RET_ERR("loading package failed", alpm_errno(handle), NULL);
}
pyresult = (AlpmPackage*)pyalpm_package_from_pmpkg(result);
if (!pyresult) return NULL;
pyresult->needs_free = 1;
return (PyObject*)pyresult;
}
static gboolean
asb_package_alpm_open (AsbPackage *pkg, const gchar *filename, GError **error)
{
AsbPackageAlpm *pkg_alpm = ASB_PACKAGE_ALPM (pkg);
AsbPackageAlpmPrivate *priv = GET_PRIVATE (pkg_alpm);
alpm_errno_t alpm_error;
/* initialize the alpm library */
priv->handle = alpm_initialize ("/", "/tmp", &alpm_error);
if (priv->handle == NULL) {
g_set_error (error,
ASB_PLUGIN_ERROR,
ASB_PLUGIN_ERROR_FAILED,
"libalpm initialization failed %s (%u) for %s",
alpm_strerror (alpm_error),
alpm_error,
filename);
return FALSE;
}
/* open the package */
if (alpm_pkg_load (priv->handle, filename, TRUE, 0, &priv->package) == -1) {
g_set_error (error,
ASB_PLUGIN_ERROR,
ASB_PLUGIN_ERROR_FAILED,
"Failed to load package %s : %s (%u)",
filename,
alpm_strerror (alpm_errno (priv->handle)),
alpm_errno (priv->handle));
alpm_release (priv->handle);
return FALSE;
}
asb_package_set_name (pkg, alpm_pkg_get_name (priv->package));
asb_package_set_url (pkg, alpm_pkg_get_url (priv->package));
asb_package_set_arch (pkg, alpm_pkg_get_arch (priv->package));
asb_package_alpm_ensure_version (pkg, error);
return TRUE;
}
static gint
alpm_add_file (const gchar *filename)
{
alpm_pkg_t *pkg;
alpm_siglevel_t level;
g_return_val_if_fail (filename != NULL, -1);
g_return_val_if_fail (alpm != NULL, -1);
level = alpm_option_get_local_file_siglevel (alpm);
if (alpm_pkg_load (alpm, filename, 1, level, &pkg) < 0) {
return -1;
}
if (alpm_add_pkg (alpm, pkg) < 0) {
alpm_pkg_free (pkg);
return -1;
}
return 0;
}
int pacman_query(alpm_list_t *targets)
{
int ret = 0;
int match = 0;
alpm_list_t *i;
alpm_pkg_t *pkg = NULL;
alpm_db_t *db_local;
/* First: operations that do not require targets */
/* search for a package */
if(config->op_q_search) {
ret = query_search(targets);
return ret;
}
/* looking for groups */
if(config->group) {
ret = query_group(targets);
return ret;
}
if(config->op_q_foreign || config->op_q_upgrade) {
if(check_syncdbs(1, 1)) {
return 1;
}
}
db_local = alpm_option_get_localdb(config->handle);
/* operations on all packages in the local DB
* valid: no-op (plain -Q), list, info, check
* invalid: isfile, owns */
if(targets == NULL) {
if(config->op_q_isfile || config->op_q_owns) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
for(i = alpm_db_get_pkgcache(db_local); i; i = alpm_list_next(i)) {
pkg = alpm_list_getdata(i);
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
}
if(!match) {
ret = 1;
}
return ret;
}
/* Second: operations that require target(s) */
/* determine the owner of a file */
if(config->op_q_owns) {
ret = query_fileowner(targets);
return ret;
}
/* operations on named packages in the local DB
* valid: no-op (plain -Q), list, info, check */
for(i = targets; i; i = alpm_list_next(i)) {
char *strname = alpm_list_getdata(i);
if(config->op_q_isfile) {
alpm_pkg_load(config->handle, strname, 1, 0, &pkg);
} else {
pkg = alpm_db_get_pkg(db_local, strname);
}
if(pkg == NULL) {
pm_fprintf(stderr, ALPM_LOG_ERROR, _("package \"%s\" not found\n"), strname);
ret = 1;
continue;
}
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
if(config->op_q_isfile) {
alpm_pkg_free(pkg);
pkg = NULL;
}
}
if(!match) {
ret = 1;
}
return ret;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
alpm_list_t *i, *data = NULL;
pgp_verify_t check_sig = alpm_option_get_default_sigverify(config->handle);
int retval = 0;
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
return 1;
} else {
free(i->data);
i->data = str;
}
}
}
/* Step 1: create a new transaction */
if(trans_init(config->flags) == -1) {
return 1;
}
/* add targets to the created transaction */
for(i = targets; i; i = alpm_list_next(i)) {
char *targ = alpm_list_getdata(i);
pmpkg_t *pkg;
if(alpm_pkg_load(config->handle, targ, 1, check_sig, &pkg) != 0) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
trans_release();
return 1;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
trans_release();
return 1;
}
}
/* Step 2: "compute" the transaction based on targets and flags */
/* TODO: No, compute nothing. This is stupid. */
if(alpm_trans_prepare(config->handle, &data) == -1) {
enum _pmerrno_t err = alpm_errno(config->handle);
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case PM_ERR_PKG_INVALID_ARCH:
for(i = data; i; i = alpm_list_next(i)) {
char *pkg = alpm_list_getdata(i);
printf(_(":: package %s does not have a valid architecture\n"), pkg);
}
break;
case PM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmdepmissing_t *miss = alpm_list_getdata(i);
char *depstring = alpm_dep_compute_string(miss->depend);
/* TODO indicate if the error was a virtual package or not:
* :: %s: requires %s, provided by %s
*/
printf(_(":: %s: requires %s\n"), miss->target, depstring);
free(depstring);
}
break;
case PM_ERR_CONFLICTING_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
pmconflict_t *conflict = alpm_list_getdata(i);
if(strcmp(conflict->package1, conflict->reason) == 0 ||
strcmp(conflict->package2, conflict->reason) == 0) {
printf(_(":: %s and %s are in conflict\n"),
conflict->package1, conflict->package2);
} else {
printf(_(":: %s and %s are in conflict (%s)\n"),
conflict->package1, conflict->package2, conflict->reason);
}
}
break;
default:
break;
}
trans_release();
FREELIST(data);
return 1;
}
/* Step 3: perform the installation */
alpm_list_t *packages = alpm_trans_get_add(config->handle);
if(config->print) {
print_packages(packages);
trans_release();
return 0;
}
/* print targets and ask user confirmation */
if(packages == NULL) { /* we are done */
printf(_(" there is nothing to do\n"));
trans_release();
return retval;
}
display_targets(alpm_trans_get_remove(config->handle), 0);
display_targets(alpm_trans_get_add(config->handle), 1);
printf("\n");
int confirm = yesno(_("Proceed with installation?"));
if(!confirm) {
trans_release();
return retval;
}
if(alpm_trans_commit(config->handle, &data) == -1) {
enum _pmerrno_t err = alpm_errno(config->handle);
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
alpm_strerror(err));
switch(err) {
case PM_ERR_FILE_CONFLICTS:
for(i = data; i; i = alpm_list_next(i)) {
pmfileconflict_t *conflict = alpm_list_getdata(i);
switch(conflict->type) {
case PM_FILECONFLICT_TARGET:
printf(_("%s exists in both '%s' and '%s'\n"),
conflict->file, conflict->target, conflict->ctarget);
break;
case PM_FILECONFLICT_FILESYSTEM:
printf(_("%s: %s exists in filesystem\n"),
conflict->target, conflict->file);
break;
}
}
break;
case PM_ERR_PKG_INVALID:
case PM_ERR_DLT_INVALID:
for(i = data; i; i = alpm_list_next(i)) {
char *filename = alpm_list_getdata(i);
printf(_("%s is invalid or corrupted\n"), filename);
}
break;
default:
break;
}
FREELIST(data);
trans_release();
return 1;
}
if(trans_release() == -1) {
retval = 1;
}
return retval;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
int retval = 0;
alpm_list_t *i, *j, *remote = NULL;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
/* Check for URL targets and process them
*/
for(i = targets; i; i = alpm_list_next(i)) {
int *r = malloc(sizeof(int));
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
} else {
free(i->data);
i->data = str;
*r = 1;
}
} else {
*r = 0;
}
remote = alpm_list_add(remote, r);
}
if(retval) {
return retval;
}
/* Step 1: create a new transaction */
if(trans_init(config->flags, 1) == -1) {
return 1;
}
printf(_("loading packages...\n"));
/* add targets to the created transaction */
for(i = targets, j = remote; i; i = alpm_list_next(i), j = alpm_list_next(j)) {
const char *targ = i->data;
alpm_pkg_t *pkg;
alpm_siglevel_t level;
if(*(int *)j->data) {
level = alpm_option_get_remote_file_siglevel(config->handle);
} else {
level = alpm_option_get_local_file_siglevel(config->handle);
}
if(alpm_pkg_load(config->handle, targ, 1, level, &pkg) != 0) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
continue;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
retval = 1;
continue;
}
config->explicit_adds = alpm_list_add(config->explicit_adds, pkg);
}
FREELIST(remote);
if(retval) {
trans_release();
return retval;
}
/* now that targets are resolved, we can hand it all off to the sync code */
return sync_prepare_execute();
}
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;
}
alpm_pkg_t* alpm_pkg_load_file (alpm_handle_t *handle, const char *filename, int full, alpm_siglevel_t level) {
alpm_pkg_t *p;
int err = alpm_pkg_load(handle, filename, full, level, &p);
if (err == -1) return NULL;
else return p;
}
int pacman_query(alpm_list_t *targets)
{
int ret = 0;
int match = 0;
alpm_list_t *i;
alpm_pkg_t *pkg = NULL;
alpm_db_t *db_local;
/* First: operations that do not require targets */
/* search for a package */
if(config->op_q_search) {
ret = query_search(targets);
return ret;
}
/* looking for groups */
if(config->group) {
ret = query_group(targets);
return ret;
}
if(config->op_q_foreign || config->op_q_upgrade) {
if(check_syncdbs(1, 1)) {
return 1;
}
}
db_local = alpm_option_get_localdb(config->handle);
/* operations on all packages in the local DB
* valid: no-op (plain -Q), list, info, check
* invalid: isfile, owns */
if(targets == NULL) {
if(config->op_q_isfile || config->op_q_owns) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
for(i = alpm_db_get_pkgcache(db_local); i; i = alpm_list_next(i)) {
pkg = alpm_list_getdata(i);
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
}
if(!match) {
ret = 1;
}
return ret;
}
/* Second: operations that require target(s) */
/* determine the owner of a file */
if(config->op_q_owns) {
ret = query_fileowner(targets);
return ret;
}
/* operations on named packages in the local DB
* valid: no-op (plain -Q), list, info, check */
for(i = targets; i; i = alpm_list_next(i)) {
char *strname = alpm_list_getdata(i);
if(config->op_q_isfile) {
alpm_pkg_load(config->handle, strname, 1, 0, &pkg);
} else {
pkg = alpm_db_get_pkg(db_local, strname);
}
if(pkg == NULL) {
switch(alpm_errno(config->handle)) {
case ALPM_ERR_PKG_NOT_FOUND:
pm_fprintf(stderr, ALPM_LOG_ERROR,
_("package '%s' was not found\n"), strname);
if(!config->op_q_isfile && access(strname, R_OK) == 0) {
pm_fprintf(stderr, ALPM_LOG_WARNING,
_("'%s' is a file, you might want to use %s.\n"),
strname, "-p/--file");
}
break;
default:
pm_fprintf(stderr, ALPM_LOG_ERROR,
_("could not load package '%s': %s\n"), strname,
alpm_strerror(alpm_errno(config->handle)));
break;
}
ret = 1;
continue;
}
if(filter(pkg)) {
int value = display(pkg);
if(value != 0) {
ret = 1;
}
match = 1;
}
if(config->op_q_isfile) {
alpm_pkg_free(pkg);
pkg = NULL;
}
}
if(!match) {
ret = 1;
}
return ret;
}
/**
* @brief Upgrade a specified list of packages.
*
* @param targets a list of packages (as strings) to upgrade
*
* @return 0 on success, 1 on failure
*/
int pacman_upgrade(alpm_list_t *targets)
{
int retval = 0, *file_is_remote;
alpm_list_t *i;
unsigned int n, num_targets;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
num_targets = alpm_list_count(targets);
/* Check for URL targets and process them */
file_is_remote = malloc(num_targets * sizeof(int));
if(file_is_remote == NULL) {
pm_printf(ALPM_LOG_ERROR, _("memory exhausted\n"));
return 1;
}
for(i = targets, n = 0; i; i = alpm_list_next(i), n++) {
if(strstr(i->data, "://")) {
char *str = alpm_fetch_pkgurl(config->handle, i->data);
if(str == NULL) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
} else {
free(i->data);
i->data = str;
file_is_remote[n] = 1;
}
} else {
file_is_remote[n] = 0;
}
}
if(retval) {
goto fail_free;
}
/* Step 1: create a new transaction */
if(trans_init(config->flags, 1) == -1) {
retval = 1;
goto fail_free;
}
printf(_("loading packages...\n"));
/* add targets to the created transaction */
for(i = targets, n = 0; i; i = alpm_list_next(i), n++) {
const char *targ = i->data;
alpm_pkg_t *pkg;
int siglevel;
if(file_is_remote[n]) {
siglevel = alpm_option_get_remote_file_siglevel(config->handle);
} else {
siglevel = alpm_option_get_local_file_siglevel(config->handle);
}
if(alpm_pkg_load(config->handle, targ, 1, siglevel, &pkg) != 0) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
continue;
}
if(alpm_add_pkg(config->handle, pkg) == -1) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
alpm_pkg_free(pkg);
retval = 1;
continue;
}
config->explicit_adds = alpm_list_add(config->explicit_adds, pkg);
}
if(retval) {
goto fail_release;
}
free(file_is_remote);
/* now that targets are resolved, we can hand it all off to the sync code */
return sync_prepare_execute();
fail_release:
trans_release();
fail_free:
free(file_is_remote);
return retval;
}
