void display_targets(void)
{
alpm_list_t *i, *targets = NULL;
alpm_db_t *db_local = alpm_get_localdb(config->handle);
for(i = alpm_trans_get_add(config->handle); i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
pm_target_t *targ = calloc(1, sizeof(pm_target_t));
if(!targ) return;
targ->install = pkg;
targ->remove = alpm_db_get_pkg(db_local, alpm_pkg_get_name(pkg));
if(alpm_list_find(config->explicit_adds, pkg, pkg_cmp)) {
targ->is_explicit = 1;
}
targets = alpm_list_add(targets, targ);
}
for(i = alpm_trans_get_remove(config->handle); i; i = alpm_list_next(i)) {
alpm_pkg_t *pkg = i->data;
pm_target_t *targ = calloc(1, sizeof(pm_target_t));
if(!targ) return;
targ->remove = pkg;
if(alpm_list_find(config->explicit_removes, pkg, pkg_cmp)) {
targ->is_explicit = 1;
}
targets = alpm_list_add(targets, targ);
}
targets = alpm_list_msort(targets, alpm_list_count(targets), target_cmp);
_display_targets(targets, config->verbosepkglists);
FREELIST(targets);
}
/* alpm_list_t * alpm_trans_get_add(); */
int lalpm_trans_get_add(lua_State *L)
{
alpm_list_t *list = alpm_trans_get_add();
alpm_list_to_any_table(L, list, PMPKG_T);
return 1;
}
static PyObject *pyalpm_trans_get_add(PyObject *self, void *closure)
{
alpm_handle_t *handle = ALPM_HANDLE(self);
alpm_list_t *to_add;
/* sanity check */
int flags = alpm_trans_get_flags(handle);
if (flags == -1) RET_ERR("no transaction defined", alpm_errno(handle), NULL);
to_add = alpm_trans_get_add(handle);
return alpmlist_to_pylist(to_add, pyalpm_package_from_pmpkg);
}
static void
pk_backend_transaction_download_start (PkBackend *self, const gchar *basename)
{
gchar *path;
const alpm_list_t *i;
g_return_if_fail (self != NULL);
g_return_if_fail (basename != NULL);
g_return_if_fail (alpm != NULL);
/* continue or finish downloading the current package */
if (dpkg != NULL) {
if (alpm_pkg_has_basename (dpkg, basename)) {
if (dfiles != NULL) {
path = pk_backend_resolve_path (self, basename);
g_string_append_printf (dfiles, ";%s", path);
g_free (path);
}
return;
} else {
pk_backend_transaction_download_end (self);
dpkg = NULL;
}
}
/* figure out what the next package is */
for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
alpm_pkg_t *pkg = (alpm_pkg_t *) i->data;
if (alpm_pkg_has_basename (pkg, basename)) {
dpkg = pkg;
break;
}
}
if (dpkg == NULL) {
return;
}
pk_backend_pkg (self, dpkg, PK_INFO_ENUM_DOWNLOADING);
/* start collecting files for the new package */
if (pk_backend_job_get_role (self) == PK_ROLE_ENUM_DOWNLOAD_PACKAGES) {
path = pk_backend_resolve_path (self, basename);
dfiles = g_string_new (path);
g_free (path);
}
}
static char *make_optstring(alpm_depend_t *optdep)
{
char *optstring = alpm_dep_compute_string(optdep);
char *status = NULL;
if(alpm_db_get_pkg(alpm_get_localdb(config->handle), optdep->name)) {
status = _(" [installed]");
} else if(alpm_pkg_find(alpm_trans_get_add(config->handle), optdep->name)) {
status = _(" [pending]");
}
if(status) {
optstring = realloc(optstring, strlen(optstring) + strlen(status) + 1);
strcpy(optstring + strlen(optstring), status);
}
return optstring;
}
void
pk_backend_transaction_packages (PkBackend *self)
{
const alpm_list_t *i;
PkInfoEnum info;
g_return_if_fail (self != NULL);
g_return_if_fail (alpm != NULL);
g_return_if_fail (localdb != NULL);
/* emit packages that would have been installed */
for (i = alpm_trans_get_add (alpm); i != NULL; i = i->next) {
if (pk_backend_cancelled (self)) {
break;
} else {
const gchar *name = alpm_pkg_get_name (i->data);
if (alpm_db_get_pkg (localdb, name) != NULL) {
info = PK_INFO_ENUM_UPDATING;
} else {
info = PK_INFO_ENUM_INSTALLING;
}
pk_backend_pkg (self, i->data, info);
}
}
switch (pk_backend_job_get_role (self)) {
case PK_ROLE_ENUM_SIMULATE_UPDATE_PACKAGES:
info = PK_INFO_ENUM_OBSOLETING;
break;
default:
info = PK_INFO_ENUM_REMOVING;
break;
}
/* emit packages that would have been removed */
for (i = alpm_trans_get_remove (alpm); i != NULL; i = i->next) {
if (pk_backend_cancelled (self)) {
break;
} else {
pk_backend_pkg (self, i->data, info);
}
}
}
/**
* @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;
}
static int sync_prepare_execute(void)
{
alpm_list_t *i, *packages, *data = NULL;
int retval = 0;
/* Step 2: "compute" the transaction based on targets and flags */
if(alpm_trans_prepare(handle, &data) == -1) {
alpm_errno_t err = alpm_errno(handle);
printf("failed to prepare transaction (%s)\n", alpm_strerror(err));
switch(err) {
case ALPM_ERR_PKG_INVALID_ARCH:
for(i = data; i; i = alpm_list_next(i)) {
const char *pkg = i->data;
printf("package %s does not have a valid architecture\n", pkg);
}
break;
case ALPM_ERR_UNSATISFIED_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
alpm_depmissing_t *miss = i->data;
char *depstring = alpm_dep_compute_string(miss->depend);
printf("%s: requires %s\n", miss->target, depstring);
free(depstring);
}
break;
case ALPM_ERR_CONFLICTING_DEPS:
for(i = data; i; i = alpm_list_next(i)) {
alpm_conflict_t *conflict = i->data;
/* only print reason if it contains new information */
if(conflict->reason->mod == ALPM_DEP_MOD_ANY) {
printf("%s and %s are in conflict\n",
conflict->package1, conflict->package2);
} else {
char *reason = alpm_dep_compute_string(conflict->reason);
printf("%s and %s are in conflict (%s)\n",
conflict->package1, conflict->package2, reason);
free(reason);
}
}
break;
default:
break;
}
retval = 1;
goto cleanup;
}
packages = alpm_trans_get_add(handle);
if(packages == NULL) {
/* nothing to do: just exit without complaining */
printf(" there is nothing to do\n");
goto cleanup;
}
printf("\n");
if(alpm_trans_commit(handle, &data) == -1) {
alpm_errno_t err = alpm_errno(handle);
printf("failed to commit transaction (%s)\n",
alpm_strerror(err));
switch(err) {
case ALPM_ERR_FILE_CONFLICTS:
printf("unable to %s directory-file conflicts\n", "--force");
for(i = data; i; i = alpm_list_next(i)) {
alpm_fileconflict_t *conflict = i->data;
switch(conflict->type) {
case ALPM_FILECONFLICT_TARGET:
printf("%s exists in both '%s' and '%s'\n",
conflict->file, conflict->target, conflict->ctarget);
break;
case ALPM_FILECONFLICT_FILESYSTEM:
printf("%s: %s exists in filesystem\n",
conflict->target, conflict->file);
break;
}
}
break;
case ALPM_ERR_PKG_INVALID:
case ALPM_ERR_PKG_INVALID_CHECKSUM:
case ALPM_ERR_PKG_INVALID_SIG:
case ALPM_ERR_DLT_INVALID:
for(i = data; i; i = alpm_list_next(i)) {
const char *filename = i->data;
printf("%s is invalid or corrupted\n", filename);
}
break;
default:
break;
}
/* TODO: stderr? */
printf("Errors occurred, no packages were upgraded.\n");
retval = 1;
goto cleanup;
}
/* Step 4: release transaction resources */
cleanup:
if(data) {
FREELIST(data);
}
if(trans_release(handle) == -1) {
retval = 1;
}
return retval;
}
/**
* pacman_transaction_get_installs:
* @transaction: A #PacmanTransaction.
*
* Gets a list of the packages that will be installed when @transaction is committed.
*
* Returns: A list of #PacmanPackage. Do not free.
*/
const PacmanList *pacman_transaction_get_installs (PacmanTransaction *transaction) {
g_return_val_if_fail (transaction != NULL, NULL);
return alpm_trans_get_add ();
}
