summaryrefslogtreecommitdiffstats
path: root/lib/libalpm/remove.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libalpm/remove.c')
-rw-r--r--lib/libalpm/remove.c486
1 files changed, 254 insertions, 232 deletions
diff --git a/lib/libalpm/remove.c b/lib/libalpm/remove.c
index 22ae2bb8..3c19c90a 100644
--- a/lib/libalpm/remove.c
+++ b/lib/libalpm/remove.c
@@ -26,8 +26,6 @@
#include <stdlib.h>
#include <errno.h>
-#include <time.h>
-#include <fcntl.h>
#include <string.h>
#include <limits.h>
#include <unistd.h>
@@ -36,6 +34,7 @@
/* libalpm */
#include "remove.h"
#include "alpm_list.h"
+#include "alpm.h"
#include "trans.h"
#include "util.h"
#include "log.h"
@@ -44,73 +43,72 @@
#include "db.h"
#include "deps.h"
#include "handle.h"
-#include "alpm.h"
+#include "conflict.h"
-int SYMEXPORT alpm_remove_pkg(pmpkg_t *pkg)
+int SYMEXPORT alpm_remove_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
{
- pmtrans_t *trans;
const char *pkgname;
-
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans;
/* Sanity checks */
- ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ CHECK_HANDLE(handle, return -1);
+ ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+ ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
trans = handle->trans;
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
ASSERT(trans->state == STATE_INITIALIZED,
- RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
+ RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
- pkgname = alpm_pkg_get_name(pkg);
+ pkgname = pkg->name;
if(_alpm_pkg_find(trans->remove, pkgname)) {
- RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
+ RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1);
}
- _alpm_log(PM_LOG_DEBUG, "adding %s in the target list\n", pkgname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s to the transaction remove list\n",
+ pkgname);
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(pkg));
- return(0);
+ return 0;
}
-static void remove_prepare_cascade(pmtrans_t *trans, pmdb_t *db,
- alpm_list_t *lp)
+static void remove_prepare_cascade(alpm_handle_t *handle, alpm_list_t *lp)
{
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans = handle->trans;
while(lp) {
alpm_list_t *i;
for(i = lp; i; i = i->next) {
- pmdepmissing_t *miss = (pmdepmissing_t *)i->data;
- pmpkg_t *info = _alpm_db_get_pkgfromcache(db, miss->target);
+ alpm_depmissing_t *miss = i->data;
+ alpm_pkg_t *info = _alpm_db_get_pkgfromcache(handle->db_local, miss->target);
if(info) {
if(!_alpm_pkg_find(trans->remove, alpm_pkg_get_name(info))) {
- _alpm_log(PM_LOG_DEBUG, "pulling %s in target list\n",
+ _alpm_log(handle, ALPM_LOG_DEBUG, "pulling %s in target list\n",
alpm_pkg_get_name(info));
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(info));
}
} else {
- _alpm_log(PM_LOG_ERROR, _("could not find %s in database -- skipping\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not find %s in database -- skipping\n"),
miss->target);
}
}
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
- lp = alpm_checkdeps(_alpm_db_get_pkgcache(db), 1, trans->remove, NULL);
+ lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
+ trans->remove, NULL, 1);
}
}
-static void remove_prepare_keep_needed(pmtrans_t *trans, pmdb_t *db,
- alpm_list_t *lp)
+static void remove_prepare_keep_needed(alpm_handle_t *handle, alpm_list_t *lp)
{
- ALPM_LOG_FUNC;
+ alpm_trans_t *trans = handle->trans;
/* Remove needed packages (which break dependencies) from target list */
while(lp != NULL) {
alpm_list_t *i;
for(i = lp; i; i = i->next) {
- pmdepmissing_t *miss = (pmdepmissing_t *)i->data;
+ alpm_depmissing_t *miss = i->data;
void *vpkg;
- pmpkg_t *pkg = _alpm_pkg_find(trans->remove, miss->causingpkg);
+ alpm_pkg_t *pkg = _alpm_pkg_find(trans->remove, miss->causingpkg);
if(pkg == NULL) {
continue;
}
@@ -118,52 +116,50 @@ static void remove_prepare_keep_needed(pmtrans_t *trans, pmdb_t *db,
&vpkg);
pkg = vpkg;
if(pkg) {
- _alpm_log(PM_LOG_WARNING, _("removing %s from target list\n"),
+ _alpm_log(handle, ALPM_LOG_WARNING, _("removing %s from target list\n"),
alpm_pkg_get_name(pkg));
_alpm_pkg_free(pkg);
}
}
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
- lp = alpm_checkdeps(_alpm_db_get_pkgcache(db), 1, trans->remove, NULL);
+ lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
+ trans->remove, NULL, 1);
}
}
/** Transaction preparation for remove actions.
* This functions takes a pointer to a alpm_list_t which will be
- * filled with a list of pmdepmissing_t* objects representing
+ * filled with a list of alpm_depmissing_t* objects representing
* the packages blocking the transaction.
- * @param trans the transaction object
- * @param db the database of local packages
+ * @param handle the context handle
* @param data a pointer to an alpm_list_t* to fill
*/
-int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
+int _alpm_remove_prepare(alpm_handle_t *handle, alpm_list_t **data)
{
alpm_list_t *lp;
+ alpm_trans_t *trans = handle->trans;
+ alpm_db_t *db = handle->db_local;
- ALPM_LOG_FUNC;
-
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
-
- if((trans->flags & PM_TRANS_FLAG_RECURSE) && !(trans->flags & PM_TRANS_FLAG_CASCADE)) {
- _alpm_log(PM_LOG_DEBUG, "finding removable dependencies\n");
- _alpm_recursedeps(db, trans->remove, trans->flags & PM_TRANS_FLAG_RECURSEALL);
+ if((trans->flags & ALPM_TRANS_FLAG_RECURSE) && !(trans->flags & ALPM_TRANS_FLAG_CASCADE)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "finding removable dependencies\n");
+ _alpm_recursedeps(db, trans->remove,
+ trans->flags & ALPM_TRANS_FLAG_RECURSEALL);
}
- if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
- EVENT(trans, PM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
+ if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+ EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
- lp = alpm_checkdeps(_alpm_db_get_pkgcache(db), 1, trans->remove, NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "looking for unsatisfied dependencies\n");
+ lp = alpm_checkdeps(handle, _alpm_db_get_pkgcache(db), trans->remove, NULL, 1);
if(lp != NULL) {
- if(trans->flags & PM_TRANS_FLAG_CASCADE) {
- remove_prepare_cascade(trans, db, lp);
- } else if (trans->flags & PM_TRANS_FLAG_UNNEEDED) {
+ if(trans->flags & ALPM_TRANS_FLAG_CASCADE) {
+ remove_prepare_cascade(handle, lp);
+ } else if(trans->flags & ALPM_TRANS_FLAG_UNNEEDED) {
/* Remove needed packages (which would break dependencies)
* from target list */
- remove_prepare_keep_needed(trans, db, lp);
+ remove_prepare_keep_needed(handle, lp);
} else {
if(data) {
*data = lp;
@@ -171,74 +167,74 @@ int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
alpm_list_free_inner(lp, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(lp);
}
- RET_ERR(PM_ERR_UNSATISFIED_DEPS, -1);
+ RET_ERR(handle, ALPM_ERR_UNSATISFIED_DEPS, -1);
}
}
}
/* re-order w.r.t. dependencies */
- _alpm_log(PM_LOG_DEBUG, "sorting by dependencies\n");
- lp = _alpm_sortbydeps(trans->remove, 1);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "sorting by dependencies\n");
+ lp = _alpm_sortbydeps(handle, trans->remove, 1);
/* free the old alltargs */
alpm_list_free(trans->remove);
trans->remove = lp;
/* -Rcs == -Rc then -Rs */
- if((trans->flags & PM_TRANS_FLAG_CASCADE) && (trans->flags & PM_TRANS_FLAG_RECURSE)) {
- _alpm_log(PM_LOG_DEBUG, "finding removable dependencies\n");
- _alpm_recursedeps(db, trans->remove, trans->flags & PM_TRANS_FLAG_RECURSEALL);
+ if((trans->flags & ALPM_TRANS_FLAG_CASCADE) && (trans->flags & ALPM_TRANS_FLAG_RECURSE)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "finding removable dependencies\n");
+ _alpm_recursedeps(db, trans->remove, trans->flags & ALPM_TRANS_FLAG_RECURSEALL);
}
- if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
- EVENT(trans, PM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
+ if(!(trans->flags & ALPM_TRANS_FLAG_NODEPS)) {
+ EVENT(trans, ALPM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
}
- return(0);
+ return 0;
}
-static int can_remove_file(const char *path, alpm_list_t *skip)
+static int can_remove_file(alpm_handle_t *handle, const alpm_file_t *file,
+ alpm_list_t *skip_remove)
{
- char file[PATH_MAX+1];
+ char filepath[PATH_MAX];
- snprintf(file, PATH_MAX, "%s%s", handle->root, path);
+ snprintf(filepath, PATH_MAX, "%s%s", handle->root, file->name);
- if(alpm_list_find_str(skip, file)) {
+ if(alpm_list_find_str(skip_remove, filepath)) {
/* return success because we will never actually remove this file */
- return(1);
+ return 1;
}
/* If we fail write permissions due to a read-only filesystem, abort.
* Assume all other possible failures are covered somewhere else */
- if(access(file, W_OK) == -1) {
- if(errno != EACCES && errno != ETXTBSY && access(file, F_OK) == 0) {
+ if(_alpm_access(handle, NULL, filepath, W_OK) == -1) {
+ if(errno != EACCES && errno != ETXTBSY && access(filepath, F_OK) == 0) {
/* only return failure if the file ACTUALLY exists and we can't write to
* it - ignore "chmod -w" simple permission failures */
- _alpm_log(PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
- file, strerror(errno));
- return(0);
+ _alpm_log(handle, ALPM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
+ filepath, strerror(errno));
+ return 0;
}
}
- return(1);
+ return 1;
}
/* Helper function for iterating through a package's file and deleting them
* Used by _alpm_remove_commit. */
-static void unlink_file(pmpkg_t *info, char *filename, alpm_list_t *skip_remove, int nosave)
+static int unlink_file(alpm_handle_t *handle, alpm_pkg_t *info,
+ const alpm_file_t *fileobj, alpm_list_t *skip_remove, int nosave)
{
struct stat buf;
- char file[PATH_MAX+1];
-
- ALPM_LOG_FUNC;
+ char file[PATH_MAX];
- snprintf(file, PATH_MAX, "%s%s", handle->root, filename);
+ snprintf(file, PATH_MAX, "%s%s", handle->root, fileobj->name);
/* check the remove skip list before removing the file.
* see the big comment block in db_find_fileconflicts() for an
* explanation. */
- if(alpm_list_find_str(skip_remove, filename)) {
- _alpm_log(PM_LOG_DEBUG, "%s is in skip_remove, skipping removal\n",
- file);
- return;
+ if(alpm_list_find_str(skip_remove, fileobj->name)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "%s is in skip_remove, skipping removal\n", file);
+ return 1;
}
/* we want to do a lstat here, and not a _alpm_lstat.
@@ -246,226 +242,252 @@ static void unlink_file(pmpkg_t *info, char *filename, alpm_list_t *skip_remove,
* filesystem, we want to work with the linked directory instead of the
* actual symlink */
if(lstat(file, &buf)) {
- _alpm_log(PM_LOG_DEBUG, "file %s does not exist\n", file);
- return;
+ _alpm_log(handle, ALPM_LOG_DEBUG, "file %s does not exist\n", file);
+ return 1;
}
if(S_ISDIR(buf.st_mode)) {
- if(rmdir(file)) {
- /* this is okay, other packages are probably using it (like /usr) */
- _alpm_log(PM_LOG_DEBUG, "keeping directory %s\n", file);
+ ssize_t files = _alpm_files_in_directory(handle, file, 0);
+ /* if we have files, no need to remove the directory */
+ if(files > 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "keeping directory %s (contains files)\n",
+ file);
+ } else if(files < 0) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "keeping directory %s (could not count files)\n", file);
} else {
- _alpm_log(PM_LOG_DEBUG, "removing directory %s\n", file);
+ /* one last check- does any other package own this file? */
+ alpm_list_t *local, *local_pkgs;
+ int found = 0;
+ local_pkgs = _alpm_db_get_pkgcache(handle->db_local);
+ for(local = local_pkgs; local && !found; local = local->next) {
+ alpm_pkg_t *local_pkg = local->data;
+ alpm_filelist_t *filelist;
+
+ /* we duplicated the package when we put it in the removal list, so we
+ * so we can't use direct pointer comparison here. */
+ if(_alpm_pkg_cmp(info, local_pkg) == 0) {
+ continue;
+ }
+ filelist = alpm_pkg_get_files(local_pkg);
+ if(_alpm_filelist_contains(filelist, fileobj->name)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "keeping directory %s (owned by %s)\n", file, local_pkg->name);
+ found = 1;
+ }
+ }
+ if(!found) {
+ if(rmdir(file)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "directory removal of %s failed: %s\n", file, strerror(errno));
+ return -1;
+ } else {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "removed directory %s (no remaining owners)\n", file);
+ }
+ }
}
} else {
/* if the file needs backup and has been modified, back it up to .pacsave */
- char *pkghash = _alpm_needbackup(filename, alpm_pkg_get_backup(info));
- if(pkghash) {
+ alpm_backup_t *backup = _alpm_needbackup(fileobj->name, info);
+ if(backup) {
if(nosave) {
- _alpm_log(PM_LOG_DEBUG, "transaction is set to NOSAVE, not backing up '%s'\n", file);
- FREE(pkghash);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "transaction is set to NOSAVE, not backing up '%s'\n", file);
} else {
char *filehash = alpm_compute_md5sum(file);
- int cmp = filehash ? strcmp(filehash, pkghash) : 0;
+ int cmp = filehash ? strcmp(filehash, backup->hash) : 0;
FREE(filehash);
- FREE(pkghash);
if(cmp != 0) {
char newpath[PATH_MAX];
snprintf(newpath, PATH_MAX, "%s.pacsave", file);
- rename(file, newpath);
- _alpm_log(PM_LOG_WARNING, _("%s saved as %s\n"), file, newpath);
- alpm_logaction("warning: %s saved as %s\n", file, newpath);
- return;
+ if(rename(file, newpath)) {
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
+ file, newpath, strerror(errno));
+ alpm_logaction(handle, "error: could not rename %s to %s (%s)\n",
+ file, newpath, strerror(errno));
+ return -1;
+ }
+ _alpm_log(handle, ALPM_LOG_WARNING, _("%s saved as %s\n"), file, newpath);
+ alpm_logaction(handle, "warning: %s saved as %s\n", file, newpath);
+ return 0;
}
}
}
- _alpm_log(PM_LOG_DEBUG, "unlinking %s\n", file);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "unlinking %s\n", file);
if(unlink(file) == -1) {
- _alpm_log(PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
- filename, strerror(errno));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("cannot remove %s (%s)\n"),
+ file, strerror(errno));
+ alpm_logaction(handle, "error: cannot remove %s (%s)\n",
+ file, strerror(errno));
+ return -1;
}
}
+ return 0;
}
-int _alpm_upgraderemove_package(pmpkg_t *oldpkg, pmpkg_t *newpkg,
- pmtrans_t *trans)
+int _alpm_remove_single_package(alpm_handle_t *handle,
+ alpm_pkg_t *oldpkg, alpm_pkg_t *newpkg,
+ size_t targ_count, size_t pkg_count)
{
- alpm_list_t *skip_remove, *b;
- alpm_list_t *newfiles, *lp;
- size_t filenum;
- alpm_list_t *files = alpm_pkg_get_files(oldpkg);
- const char *pkgname = alpm_pkg_get_name(oldpkg);
+ alpm_list_t *skip_remove;
+ size_t filenum = 0, position = 0;
+ const char *pkgname = oldpkg->name;
+ const char *pkgver = oldpkg->version;
+ alpm_filelist_t *filelist;
+ char scriptlet[PATH_MAX];
+ size_t i;
+
+ if(newpkg) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing old package first (%s-%s)\n",
+ pkgname, pkgver);
+ } else {
+ EVENT(handle->trans, ALPM_TRANS_EVT_REMOVE_START, oldpkg, NULL);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing package %s-%s\n",
+ pkgname, pkgver);
- ALPM_LOG_FUNC;
+ snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
+ _alpm_db_path(handle->db_local), pkgname, pkgver);
- _alpm_log(PM_LOG_DEBUG, "removing old package first (%s-%s)\n",
- oldpkg->name, oldpkg->version);
+ /* run the pre-remove scriptlet if it exists */
+ if(alpm_pkg_has_scriptlet(oldpkg) &&
+ !(handle->trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
+ _alpm_runscriptlet(handle, scriptlet, "pre_remove", pkgver, NULL);
+ }
+ }
- if(trans->flags & PM_TRANS_FLAG_DBONLY) {
+ if(handle->trans->flags & ALPM_TRANS_FLAG_DBONLY) {
goto db;
}
- /* copy the remove skiplist over */
- skip_remove = alpm_list_join(
- alpm_list_strdup(trans->skip_remove),
- alpm_list_strdup(handle->noupgrade));
- /* Add files in the NEW backup array to the skip_remove array
- * so this removal operation doesn't kill them */
- /* old package backup list */
- alpm_list_t *filelist = alpm_pkg_get_files(newpkg);
- for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
- char *backup = _alpm_backup_file(b->data);
- /* safety check (fix the upgrade026 pactest) */
- if(!alpm_list_find_str(filelist, backup)) {
- FREE(backup);
- continue;
+ if(newpkg) {
+ alpm_filelist_t *newfiles;
+ alpm_list_t *b;
+ skip_remove = alpm_list_join(
+ alpm_list_strdup(handle->trans->skip_remove),
+ alpm_list_strdup(handle->noupgrade));
+ /* Add files in the NEW backup array to the skip_remove array
+ * so this removal operation doesn't kill them */
+ /* old package backup list */
+ newfiles = alpm_pkg_get_files(newpkg);
+ for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
+ const alpm_backup_t *backup = b->data;
+ /* safety check (fix the upgrade026 pactest) */
+ if(!_alpm_filelist_contains(newfiles, backup->name)) {
+ continue;
+ }
+ _alpm_log(handle, ALPM_LOG_DEBUG, "adding %s to the skip_remove array\n",
+ backup->name);
+ skip_remove = alpm_list_add(skip_remove, strdup(backup->name));
}
- _alpm_log(PM_LOG_DEBUG, "adding %s to the skip_remove array\n", backup);
- skip_remove = alpm_list_add(skip_remove, backup);
+ } else {
+ skip_remove = alpm_list_strdup(handle->trans->skip_remove);
}
- for(lp = files; lp; lp = lp->next) {
- if(!can_remove_file(lp->data, skip_remove)) {
- _alpm_log(PM_LOG_DEBUG, "not removing package '%s', can't remove all files\n",
- pkgname);
- RET_ERR(PM_ERR_PKG_CANT_REMOVE, -1);
+ filelist = alpm_pkg_get_files(oldpkg);
+ for(i = 0; i < filelist->count; i++) {
+ alpm_file_t *file = filelist->files + i;
+ if(!can_remove_file(handle, file, skip_remove)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG,
+ "not removing package '%s', can't remove all files\n", pkgname);
+ RET_ERR(handle, ALPM_ERR_PKG_CANT_REMOVE, -1);
}
+ filenum++;
}
- filenum = alpm_list_count(files);
- _alpm_log(PM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
+
+ if(!newpkg) {
+ /* init progress bar, but only on true remove transactions */
+ PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 0,
+ pkg_count, targ_count);
+ }
/* iterate through the list backwards, unlinking files */
- newfiles = alpm_list_reverse(files);
- for(lp = newfiles; lp; lp = alpm_list_next(lp)) {
- unlink_file(oldpkg, lp->data, skip_remove, 0);
+ for(i = filelist->count; i > 0; i--) {
+ alpm_file_t *file = filelist->files + i - 1;
+ int percent;
+ /* TODO: check return code and handle accordingly */
+ unlink_file(handle, oldpkg, file, skip_remove,
+ handle->trans->flags & ALPM_TRANS_FLAG_NOSAVE);
+
+ if(!newpkg) {
+ /* update progress bar after each file */
+ percent = (position * 100) / filenum;
+ PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname,
+ percent, pkg_count, targ_count);
+ }
+ position++;
}
- alpm_list_free(newfiles);
FREELIST(skip_remove);
+ if(!newpkg) {
+ /* set progress to 100% after we finish unlinking files */
+ PROGRESS(handle->trans, ALPM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
+ pkg_count, targ_count);
+
+ /* run the post-remove script if it exists */
+ if(alpm_pkg_has_scriptlet(oldpkg) &&
+ !(handle->trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
+ _alpm_runscriptlet(handle, scriptlet, "post_remove", pkgver, NULL);
+ }
+ }
+
db:
/* remove the package from the database */
- _alpm_log(PM_LOG_DEBUG, "updating database\n");
- _alpm_log(PM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
+ _alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
+ _alpm_log(handle, ALPM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
if(_alpm_local_db_remove(handle->db_local, oldpkg) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
- pkgname, alpm_pkg_get_version(oldpkg));
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
+ pkgname, pkgver);
}
/* remove the package from the cache */
if(_alpm_db_remove_pkgfromcache(handle->db_local, oldpkg) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
+ _alpm_log(handle, ALPM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
pkgname);
}
- return(0);
+ if(!newpkg) {
+ /* TODO: awesome! we're passing invalid pointers. */
+ EVENT(handle->trans, ALPM_TRANS_EVT_REMOVE_DONE, oldpkg, NULL);
+ }
+
+ return 0;
}
-int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
+int _alpm_remove_packages(alpm_handle_t *handle)
{
- pmpkg_t *info;
- alpm_list_t *targ, *lp;
- size_t pkg_count;
-
- ALPM_LOG_FUNC;
-
- ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ alpm_list_t *targ;
+ size_t pkg_count, targ_count;
+ alpm_trans_t *trans = handle->trans;
+ int ret = 0;
pkg_count = alpm_list_count(trans->remove);
+ targ_count = 1;
for(targ = trans->remove; targ; targ = targ->next) {
- int position = 0;
- char scriptlet[PATH_MAX];
- info = (pmpkg_t*)targ->data;
- const char *pkgname = NULL;
- size_t targcount = alpm_list_count(targ);
-
- if(handle->trans->state == STATE_INTERRUPTED) {
- return(0);
- }
+ alpm_pkg_t *pkg = targ->data;
- /* get the name now so we can use it after package is removed */
- pkgname = alpm_pkg_get_name(info);
- snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
- _alpm_db_path(db), pkgname, alpm_pkg_get_version(info));
-
- EVENT(trans, PM_TRANS_EVT_REMOVE_START, info, NULL);
- _alpm_log(PM_LOG_DEBUG, "removing package %s-%s\n",
- pkgname, alpm_pkg_get_version(info));
-
- /* run the pre-remove scriptlet if it exists */
- if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
- _alpm_runscriptlet(handle->root, scriptlet, "pre_remove",
- alpm_pkg_get_version(info), NULL, trans);
+ if(trans->state == STATE_INTERRUPTED) {
+ return 0;
}
- if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
- alpm_list_t *files = alpm_pkg_get_files(info);
- alpm_list_t *newfiles;
- size_t filenum;
-
- for(lp = files; lp; lp = lp->next) {
- if(!can_remove_file(lp->data, NULL)) {
- _alpm_log(PM_LOG_DEBUG, "not removing package '%s', can't remove all files\n",
- pkgname);
- RET_ERR(PM_ERR_PKG_CANT_REMOVE, -1);
- }
- }
-
- filenum = alpm_list_count(files);
- _alpm_log(PM_LOG_DEBUG, "removing %ld files\n", (unsigned long)filenum);
-
- /* init progress bar */
- PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name, 0,
- pkg_count, (pkg_count - targcount + 1));
-
- /* iterate through the list backwards, unlinking files */
- newfiles = alpm_list_reverse(files);
- for(lp = newfiles; lp; lp = alpm_list_next(lp)) {
- int percent;
- unlink_file(info, lp->data, NULL, trans->flags & PM_TRANS_FLAG_NOSAVE);
-
- /* update progress bar after each file */
- percent = (position * 100) / filenum;
- PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name,
- percent, pkg_count, (pkg_count - targcount + 1));
- position++;
- }
- alpm_list_free(newfiles);
- }
-
- /* set progress to 100% after we finish unlinking files */
- PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, pkgname, 100,
- pkg_count, (pkg_count - targcount + 1));
-
- /* run the post-remove script if it exists */
- if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
- _alpm_runscriptlet(handle->root, scriptlet, "post_remove",
- alpm_pkg_get_version(info), NULL, trans);
- }
-
- /* remove the package from the database */
- _alpm_log(PM_LOG_DEBUG, "updating database\n");
- _alpm_log(PM_LOG_DEBUG, "removing database entry '%s'\n", pkgname);
- if(_alpm_local_db_remove(db, info) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove database entry %s-%s\n"),
- pkgname, alpm_pkg_get_version(info));
- }
- /* remove the package from the cache */
- if(_alpm_db_remove_pkgfromcache(db, info) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not remove entry '%s' from cache\n"),
- pkgname);
+ if(_alpm_remove_single_package(handle, pkg, NULL,
+ targ_count, pkg_count) == -1) {
+ handle->pm_errno = ALPM_ERR_TRANS_ABORT;
+ ret = -1;
+ goto cleanup;
}
- EVENT(trans, PM_TRANS_EVT_REMOVE_DONE, info, NULL);
+ targ_count++;
}
/* run ldconfig if it exists */
- _alpm_ldconfig(handle->root);
+ _alpm_ldconfig(handle);
- return(0);
+cleanup:
+ return ret;
}
/* vim: set ts=2 sw=2 noet: */
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-10 04:27:38 +0000