static int remove_target(const char *target)
{
alpm_pkg_t *pkg;
alpm_db_t *db_local = alpm_get_localdb(config->handle);
alpm_list_t *p;
if((pkg = alpm_db_get_pkg(db_local, target)) != NULL) {
if(alpm_remove_pkg(config->handle, pkg) == -1) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n", target,
alpm_strerror(alpm_errno(config->handle)));
return -1;
}
config->explicit_removes = alpm_list_add(config->explicit_removes, pkg);
return 0;
}
/* fallback to group */
alpm_group_t *grp = alpm_db_get_group(db_local, target);
if(grp == NULL) {
pm_printf(ALPM_LOG_ERROR, _("target not found: %s\n"), target);
return -1;
}
for(p = grp->packages; p; p = alpm_list_next(p)) {
pkg = p->data;
if(alpm_remove_pkg(config->handle, pkg) == -1) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n", target,
alpm_strerror(alpm_errno(config->handle)));
return -1;
}
config->explicit_removes = alpm_list_add(config->explicit_removes, pkg);
}
return 0;
}
static int register_repo(config_repo_t *repo)
{
alpm_list_t *i;
alpm_db_t *db;
repo->siglevel = merge_siglevel(config->siglevel,
repo->siglevel, repo->siglevel_mask);
db = alpm_register_syncdb(config->handle, repo->name, repo->siglevel);
if(db == NULL) {
pm_printf(ALPM_LOG_ERROR, _("could not register '%s' database (%s)\n"),
repo->name, alpm_strerror(alpm_errno(config->handle)));
return 1;
}
pm_printf(ALPM_LOG_DEBUG,
"setting usage of %d for %s repository\n",
repo->usage == 0 ? ALPM_DB_USAGE_ALL : repo->usage,
repo->name);
alpm_db_set_usage(db, repo->usage == 0 ? ALPM_DB_USAGE_ALL : repo->usage);
for(i = repo->servers; i; i = alpm_list_next(i)) {
char *value = i->data;
if(_add_mirror(db, value) != 0) {
pm_printf(ALPM_LOG_ERROR,
_("could not add mirror '%s' to database '%s' (%s)\n"),
value, repo->name, alpm_strerror(alpm_errno(config->handle)));
return 1;
}
}
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;
}
/**
* @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();
}
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;
}
/** Free the resources.
*
* @param ret the return value
*/
int ipacman_add_server(const char *name, const char *server)
{
alpm_db_t *db;
db = alpm_register_syncdb(handle, name, ALPM_SIG_DATABASE_OPTIONAL);
if(db == NULL) {
printf("could not register '%s' database (%s)\n", name, alpm_strerror(alpm_errno(handle)));
return 1;
}
if(alpm_db_add_server(db, server) != 0) {
printf("could not add server URL to database '%s': %s (%s)\n",
name, server, alpm_strerror(alpm_errno(handle)));
return 1;
}
return 0;
}
static PyObject *_get_string_attr(PyObject *self, const struct _alpm_str_getset *closure) {
alpm_handle_t *handle = ALPM_HANDLE(self);
const char *str = closure->getter(handle);
if(str == NULL)
RET_ERR("failed getting option value", alpm_errno(handle), NULL);
return Py_BuildValue("s", str);
}
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;
}
gboolean
pk_backend_transaction_initialize (PkBackend *self, alpm_transflag_t flags,
GError **error)
{
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
g_return_val_if_fail (cancellable != NULL, FALSE);
if (alpm_trans_init (alpm, flags) < 0) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
return FALSE;
}
alpm_option_set_eventcb (alpm, pk_backend_transaction_event_cb);
alpm_option_set_questioncb (alpm, pk_backend_transaction_conv_cb);
alpm_option_set_progresscb (alpm, pk_backend_transaction_progress_cb);
alpm_option_set_dlcb (alpm, pk_backend_transaction_dlcb);
alpm_option_set_totaldlcb (alpm, pk_backend_transaction_totaldlcb);
g_cancellable_connect (cancellable,
G_CALLBACK (transaction_cancelled_cb),
self, NULL);
return TRUE;
}
gboolean
pk_backend_transaction_end (PkBackend *self, GError **error)
{
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
alpm_option_set_eventcb (alpm, NULL);
alpm_option_set_questioncb (alpm, NULL);
alpm_option_set_progresscb (alpm, NULL);
alpm_option_set_dlcb (alpm, NULL);
alpm_option_set_totaldlcb (alpm, NULL);
if (dpkg != NULL) {
pk_backend_transaction_download_end (self);
}
if (tpkg != NULL) {
pk_backend_output_end (self);
}
if (alpm_trans_release (alpm) < 0) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
return FALSE;
}
return TRUE;
}
static int _add_mirror(alpm_db_t *db, char *value)
{
const char *dbname = alpm_db_get_name(db);
/* let's attempt a replacement for the current repo */
char *temp = strreplace(value, "$repo", dbname);
/* let's attempt a replacement for the arch */
const char *arch = config->arch;
char *server;
if(arch) {
server = strreplace(temp, "$arch", arch);
free(temp);
} else {
if(strstr(temp, "$arch")) {
free(temp);
pm_printf(ALPM_LOG_ERROR,
_("mirror '%s' contains the '%s' variable, but no '%s' is defined.\n"),
value, "$arch", "Architecture");
return 1;
}
server = temp;
}
if(alpm_db_add_server(db, server) != 0) {
/* pm_errno is set by alpm_db_setserver */
pm_printf(ALPM_LOG_ERROR, _("could not add server URL to database '%s': %s (%s)\n"),
dbname, server, alpm_strerror(alpm_errno(config->handle)));
free(server);
return 1;
}
free(server);
return 0;
}
/**
* call-seq:
* errno() → an_integer
*
* Error code of the last encountered error. See libalpm source
* for the exact possible values. See #strerror for getting a
* human-readable description from an error code.
*
* Beware this method returns nonsense if there was no error
* enountered.
*/
static VALUE rberrno(VALUE self)
{
alpm_handle_t* p_alpm = NULL;
Data_Get_Struct(self, alpm_handle_t, p_alpm);
return INT2NUM(alpm_errno(p_alpm));
}
/** Initializes a transaction
* @param self a Handle object
* ...
* @return a Transaction object with the same underlying object
*/
PyObject* pyalpm_trans_init(PyObject *self, PyObject *args, PyObject *kwargs) {
alpm_handle_t *handle = ALPM_HANDLE(self);
PyObject *result;
const char* keywords[] = { INDEX_FLAGS(flagnames), NULL };
char flags[18] = "\0\0\0\0\0" /* 5 */ "\0\0\0\0\0" /* 10 */ "\0\0\0\0\0" /* 15 */ "\0\0\0";
/* check all arguments */
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"|bbbbbbbbbbbbbbbbOOO", (char**)keywords,
INDEX_FLAGS(&flags))) {
return NULL;
}
/* run alpm_trans_init() */
{
alpm_transflag_t flag_int = 0;
int i, ret;
for (i = 0; i < 18; i++) {
if (flags[i]) flag_int |= 1U << i;
}
ret = alpm_trans_init(handle, flag_int);
if (ret == -1) {
RET_ERR("transaction could not be initialized", alpm_errno(handle), NULL);
}
}
result = pyalpm_transaction_from_pmhandle(handle);
return result;
}
static PyObject* pyalpm_trans_commit(PyObject *self, PyObject *args) {
alpm_handle_t *handle = ALPM_HANDLE(self);
alpm_list_t *data = NULL;
int ret;
enum _alpm_errno_t err;
PyObject *err_info = NULL;
ret = alpm_trans_commit(handle, &data);
if (ret == 0) Py_RETURN_NONE;
if (ret != -1) {
PyErr_Format(PyExc_RuntimeError,
"unexpected return value %d from alpm_trans_commit()", ret);
return NULL;
}
err = alpm_errno(handle);
switch(err) {
case ALPM_ERR_FILE_CONFLICTS:
/* return the list of file conflicts in the exception */
err_info = alpmlist_to_pylist(data, pyobject_from_pmfileconflict);
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_PKG_INVALID_CHECKSUM:
case ALPM_ERR_PKG_INVALID_SIG:
case ALPM_ERR_DLT_INVALID:
err_info = alpmlist_to_pylist(data, pyobject_from_string);
break;
default:
break;
}
if (err_info)
RET_ERR_DATA("transaction failed", err, err_info, NULL);
else
RET_ERR("transaction failed", err, NULL);
}
/*
* Return: 0 for success.
*/
int ipacman_sync_packages(alpm_list_t *targets)
{
int ret = 0;
alpm_list_t *i;
alpm_list_t *sync_dbs = alpm_get_syncdbs(handle);
if(sync_dbs == NULL) {
printf("no usable package repositories configured.\n");
return 1;
}
/* ensure all known dbs are valid */
for(i = sync_dbs; i; i = alpm_list_next(i)) {
alpm_db_t *db = i->data;
if(alpm_db_get_valid(db)) {
printf("database '%s' is not valid (%s)\n",
alpm_db_get_name(db), alpm_strerror(alpm_errno(handle)));
ret = 1;
}
}
if (ret)
return ret;
/* Step 1: create a new transaction... */
ret = alpm_trans_init(handle, ALPM_TRANS_FLAG_FORCE);
if(ret == -1) {
trans_init_error(handle);
return 1;
}
/* process targets */
for(i = targets; i; i = alpm_list_next(i)) {
const char *targ = i->data;
if(process_target(targ, ret) == 1) {
ret = 1;
}
}
if(ret) {
if(alpm_trans_release(handle) == -1) {
printf("failed to release transaction (%s)\n", alpm_strerror(alpm_errno(handle)));
}
return ret;
}
return sync_prepare_execute();
}
static int trans_release(alpm_handle_t *handle)
{
if(alpm_trans_release(handle) == -1) {
printf("failed to release transaction (%s)\n", alpm_strerror(alpm_errno(handle)));
return -1;
}
return 0;
}
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;
}
int trans_release(void)
{
if(alpm_trans_release(config->handle) == -1) {
pm_printf(ALPM_LOG_ERROR, _("failed to release transaction (%s)\n"),
alpm_strerror(alpm_errno(config->handle)));
return -1;
}
return 0;
}
static gboolean
disabled_repos_configure (GHashTable *table, gboolean only_trusted,
GError **error)
{
const alpm_list_t *i;
g_return_val_if_fail (table != NULL, FALSE);
g_return_val_if_fail (alpm != NULL, FALSE);
if (alpm_unregister_all_syncdbs (alpm) < 0) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error_literal (error, ALPM_ERROR, errno,
alpm_strerror (errno));
return FALSE;
}
for (i = configured; i != NULL; i = i->next) {
PkBackendRepo *repo = (PkBackendRepo *) i->data;
alpm_siglevel_t level = repo->level;
alpm_db_t *db;
if (g_hash_table_lookup (table, repo->name) != NULL) {
/* repo is disabled */
continue;
} else if (!only_trusted) {
level &= ~ALPM_SIG_PACKAGE;
level &= ~ALPM_SIG_DATABASE;
level &= ~ALPM_SIG_USE_DEFAULT;
}
db = alpm_register_syncdb (alpm, repo->name, level);
if (db == NULL) {
alpm_errno_t errno = alpm_errno (alpm);
g_set_error (error, ALPM_ERROR, errno, "[%s]: %s",
repo->name, alpm_strerror (errno));
return FALSE;
}
alpm_db_set_servers (db, alpm_list_strdup (repo->servers));
}
return TRUE;
}
/**
* Wrap up a section once we have reached the end of it. This should be called
* when a subsequent section is encountered, or when we have reached the end of
* the root config file. Once called, all existing saved config pieces on the
* section struct are freed.
* @param section the current parsed and saved section data
* @param parse_options whether we are parsing options or repo data
* @return 0 on success, 1 on failure
*/
static int finish_section(struct section_t *section, int parse_options)
{
int ret = 0;
alpm_list_t *i;
alpm_db_t *db;
pm_printf(ALPM_LOG_DEBUG, "config: finish section '%s'\n", section->name);
/* parsing options (or nothing)- nothing to do except free the pieces */
if(!section->name || parse_options || section->is_options) {
goto cleanup;
}
/* if we are not looking at options sections only, register a db */
db = alpm_register_syncdb(config->handle, section->name, section->siglevel);
if(db == NULL) {
pm_printf(ALPM_LOG_ERROR, _("could not register '%s' database (%s)\n"),
section->name, alpm_strerror(alpm_errno(config->handle)));
ret = 1;
goto cleanup;
}
for(i = section->servers; i; i = alpm_list_next(i)) {
char *value = i->data;
if(_add_mirror(db, value) != 0) {
pm_printf(ALPM_LOG_ERROR,
_("could not add mirror '%s' to database '%s' (%s)\n"),
value, section->name, alpm_strerror(alpm_errno(config->handle)));
ret = 1;
goto cleanup;
}
free(value);
}
cleanup:
alpm_list_free(section->servers);
section->servers = NULL;
section->siglevel = ALPM_SIG_USE_DEFAULT;
free(section->name);
section->name = NULL;
return ret;
}
static PyObject *pyalpm_trans_get_remove(PyObject *self, void *closure)
{
alpm_handle_t *handle = ALPM_HANDLE(self);
alpm_list_t *to_remove;
/* sanity check */
int flags = alpm_trans_get_flags(handle);
if (flags == -1) RET_ERR("no transaction defined", alpm_errno(handle), NULL);
to_remove = alpm_trans_get_remove(handle);
return alpmlist_to_pylist(to_remove, pyalpm_package_from_pmpkg);
}
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 void trans_init_error(alpm_handle_t *handle)
{
alpm_errno_t err = alpm_errno(handle);
printf("failed to init transaction (%s)\n", alpm_strerror(err));
if(err == ALPM_ERR_HANDLE_LOCK) {
const char *lockfile = alpm_option_get_lockfile(handle);
printf("could not lock database: %s\n", strerror(errno));
if(access(lockfile, F_OK) == 0) {
fprintf(stderr, " if you're sure a package manager is not already\n"
" running, you can remove %s\n", lockfile);
}
}
}
static PyObject* pyalpm_trans_sysupgrade(PyObject *self, PyObject *args, PyObject *kwargs) {
alpm_handle_t *handle = ALPM_HANDLE(self);
char* keyword[] = {"downgrade", NULL};
PyObject *downgrade;
int do_downgrade, ret;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", keyword, &PyBool_Type, &downgrade))
return NULL;
do_downgrade = (downgrade == Py_True) ? 1 : 0;
ret = alpm_sync_sysupgrade(handle, do_downgrade);
if (ret == -1) RET_ERR("unable to update transaction", alpm_errno(handle), NULL);
Py_RETURN_NONE;
}
static PyObject* pyalpm_trans_prepare(PyObject *self, PyObject *args) {
alpm_handle_t *handle = ALPM_HANDLE(self);
alpm_list_t *data;
int ret = alpm_trans_prepare(handle, &data);
if (ret == -1) {
/* return the list of package conflicts in the exception */
PyObject *info = alpmlist_to_pylist(data, pyobject_from_pmdepmissing);
if (!info) return NULL;
RET_ERR_DATA("transaction preparation failed", alpm_errno(handle), info, NULL);
}
Py_RETURN_NONE;
}
static PyObject *pyalpm_trans_get_flags(PyObject *self, void *closure)
{
PyObject *result;
alpm_handle_t *handle = ALPM_HANDLE(self);
int flags = alpm_trans_get_flags(handle);
int i;
if (flags == -1) RET_ERR("no transaction defined", alpm_errno(handle), NULL);
result = PyDict_New();
for (i = 0; i < 18; i++) {
if(flagnames[i])
PyDict_SetItemString(result, flagnames[i], flags & (1 << i) ? Py_True : Py_False);
}
return result;
}
static gboolean
pk_alpm_disabled_repos_configure (PkBackend *backend, gboolean only_trusted, GError **error)
{
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
const alpm_list_t *i;
if (alpm_unregister_all_syncdbs (priv->alpm) < 0) {
alpm_errno_t errno = alpm_errno (priv->alpm);
g_set_error_literal (error, PK_ALPM_ERROR, errno,
alpm_strerror (errno));
return FALSE;
}
for (i = priv->configured_repos; i != NULL; i = i->next) {
PkBackendRepo *repo = (PkBackendRepo *) i->data;
alpm_siglevel_t level = repo->level;
alpm_db_t *db;
if (!only_trusted) {
level &= ~ALPM_SIG_PACKAGE;
level &= ~ALPM_SIG_DATABASE;
level &= ~ALPM_SIG_USE_DEFAULT;
}
db = alpm_register_syncdb (priv->alpm, repo->name, level);
if (db == NULL) {
alpm_errno_t errno = alpm_errno (priv->alpm);
g_set_error (error, PK_ALPM_ERROR, errno, "[%s]: %s",
repo->name, alpm_strerror (errno));
return FALSE;
}
alpm_db_set_servers (db, alpm_list_strdup (repo->servers));
}
return TRUE;
}
/**
* @brief Modify the 'local' package database.
*
* @param targets a list of packages (as strings) to modify
*
* @return 0 on success, 1 on failure
*/
int pacman_database(alpm_list_t *targets)
{
alpm_list_t *i;
alpm_db_t *db_local;
int retval = 0;
alpm_pkgreason_t reason;
if(targets == NULL) {
pm_printf(ALPM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return 1;
}
if(config->flags & ALPM_TRANS_FLAG_ALLDEPS) { /* --asdeps */
reason = ALPM_PKG_REASON_DEPEND;
} else if(config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) { /* --asexplicit */
reason = ALPM_PKG_REASON_EXPLICIT;
} else {
pm_printf(ALPM_LOG_ERROR, _("no install reason specified (use -h for help)\n"));
return 1;
}
/* Lock database */
if(trans_init(0, 0) == -1) {
return 1;
}
db_local = alpm_option_get_localdb(config->handle);
for(i = targets; i; i = alpm_list_next(i)) {
char *pkgname = i->data;
alpm_pkg_t *pkg = alpm_db_get_pkg(db_local, pkgname);
if(!pkg || alpm_db_set_pkgreason(config->handle, pkg, reason)) {
pm_printf(ALPM_LOG_ERROR, _("could not set install reason for package %s (%s)\n"),
pkgname, alpm_strerror(alpm_errno(config->handle)));
retval = 1;
} else {
if(reason == ALPM_PKG_REASON_DEPEND) {
printf(_("%s: install reason has been set to 'installed as dependency'\n"), pkgname);
} else {
printf(_("%s: install reason has been set to 'explicitly installed'\n"), pkgname);
}
}
}
/* Unlock database */
if(trans_release() == -1) {
return 1;
}
return retval;
}
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;
}
static PyObject* pyalpm_trans_remove_pkg(PyObject *self, PyObject *args) {
alpm_handle_t *handle = ALPM_HANDLE(self);
PyObject *pkg;
alpm_pkg_t *pmpkg;
int ret;
if (!PyArg_ParseTuple(args, "O!", &AlpmPackageType, &pkg)) {
return NULL;
}
pmpkg = pmpkg_from_pyalpm_pkg(pkg);
ret = alpm_remove_pkg(handle, pmpkg);
if (ret == -1) RET_ERR("unable to update transaction", alpm_errno(handle), NULL);
Py_RETURN_NONE;
}
