/**
* @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();
}
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;
}
/**
* @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();
}
/**
* @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;
}
static gboolean pacman_install_prepare (PacmanTransaction *transaction, const PacmanList *targets, GError **error) {
const PacmanList *i;
PacmanList *data = NULL;
g_return_val_if_fail (transaction != NULL, FALSE);
g_return_val_if_fail (targets != NULL, FALSE);
if (pacman_transaction_get_installs (transaction) != NULL) {
/* reinitialize so transaction can be prepared multiple times */
if (!pacman_transaction_restart (transaction, error)) {
return FALSE;
}
}
for (i = targets; i != NULL; i = pacman_list_next (i)) {
int result;
gchar *target = (gchar *) pacman_list_get (i);
if (strstr (target, "://") != NULL) {
target = alpm_fetch_pkgurl (target);
if (target == NULL) {
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not download package with url '%s': %s"), (gchar *) pacman_list_get (i), alpm_strerrorlast ());
return FALSE;
}
result = alpm_add_target (target);
free (target);
} else {
result = alpm_add_target (target);
}
if (result < 0) {
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not mark the file '%s' for installation: %s"), target, alpm_strerrorlast ());
return FALSE;
}
}
if (alpm_trans_prepare (&data) < 0) {
if (pm_errno == PACMAN_ERROR_PACKAGE_WRONG_ARCHITECTURE) {
gchar *packages = pacman_package_make_list (data);
pacman_transaction_set_marked_packages (transaction, data);
g_set_error (error, PACMAN_ERROR, pm_errno, _("The following packages have the wrong architecture: %s"), packages);
g_free (packages);
return FALSE;
} else if (pm_errno == PACMAN_ERROR_DEPENDENCY_UNSATISFIED) {
gchar *missing = pacman_missing_dependency_make_list (data);
pacman_transaction_set_missing_dependencies (transaction, data);
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not prepare transaction: %s"), missing);
g_free (missing);
return FALSE;
} else if (pm_errno == PACMAN_ERROR_CONFLICT) {
gchar *conflict = pacman_conflict_make_list (data);
pacman_transaction_set_conflicts (transaction, data);
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not prepare transaction: %s"), conflict);
g_free (conflict);
return FALSE;
} else if (pm_errno == PACMAN_ERROR_FILE_CONFLICT) {
gchar *conflict = pacman_file_conflict_make_list (data);
pacman_transaction_set_file_conflicts (transaction, data);
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not prepare transaction: %s"), conflict);
g_free (conflict);
return FALSE;
} else if (data != NULL) {
g_debug ("Possible memory leak for install error: %s\n", alpm_strerrorlast ());
}
g_set_error (error, PACMAN_ERROR, pm_errno, _("Could not prepare transaction: %s"), alpm_strerrorlast ());
return FALSE;
}
return TRUE;
}
