1
0
mirror of https://github.com/moparisthebest/pacman synced 2024-12-23 08:18:51 -05:00
pacman/lib/libalpm/conflict.c

640 lines
19 KiB
C
Raw Normal View History

/*
* conflict.c
*
* Copyright (c) 2006-2014 Pacman Development Team <pacman-dev@archlinux.org>
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
* Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
* Copyright (c) 2006 by David Kimpe <dnaku@frugalware.org>
* Copyright (c) 2006 by Miklos Vajna <vmiklos@frugalware.org>
2006-10-15 20:05:10 -04:00
* Copyright (c) 2006 by Christian Hamar <krics@linuxforum.hu>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
2006-03-02 14:04:40 -05:00
#include <limits.h>
#include <sys/stat.h>
#include <dirent.h>
/* libalpm */
#include "conflict.h"
#include "alpm_list.h"
#include "alpm.h"
#include "handle.h"
#include "trans.h"
#include "util.h"
#include "log.h"
#include "deps.h"
#include "filelist.h"
/**
* @brief Creates a new conflict.
*/
static alpm_conflict_t *conflict_new(alpm_pkg_t *pkg1, alpm_pkg_t *pkg2,
alpm_depend_t *reason)
{
alpm_conflict_t *conflict;
MALLOC(conflict, sizeof(alpm_conflict_t), return NULL);
conflict->package1_hash = pkg1->name_hash;
conflict->package2_hash = pkg2->name_hash;
STRDUP(conflict->package1, pkg1->name, return NULL);
STRDUP(conflict->package2, pkg2->name, return NULL);
conflict->reason = reason;
return conflict;
}
/**
* @brief Free a conflict and its members.
*/
void _alpm_conflict_free(alpm_conflict_t *conflict)
{
FREE(conflict->package2);
FREE(conflict->package1);
FREE(conflict);
}
/**
* @brief Creates a copy of a conflict.
*/
alpm_conflict_t *_alpm_conflict_dup(const alpm_conflict_t *conflict)
{
alpm_conflict_t *newconflict;
CALLOC(newconflict, 1, sizeof(alpm_conflict_t), return NULL);
newconflict->package1_hash = conflict->package1_hash;
newconflict->package2_hash = conflict->package2_hash;
STRDUP(newconflict->package1, conflict->package1, return NULL);
STRDUP(newconflict->package2, conflict->package2, return NULL);
newconflict->reason = conflict->reason;
return newconflict;
}
/**
* @brief Searches for a conflict in a list.
*
* @param needle conflict to search for
* @param haystack list of conflicts to search
*
* @return 1 if needle is in haystack, 0 otherwise
*/
static int conflict_isin(alpm_conflict_t *needle, alpm_list_t *haystack)
{
alpm_list_t *i;
for(i = haystack; i; i = i->next) {
alpm_conflict_t *conflict = i->data;
if(needle->package1_hash == conflict->package1_hash
&& needle->package2_hash == conflict->package2_hash
&& strcmp(needle->package1, conflict->package1) == 0
&& strcmp(needle->package2, conflict->package2) == 0) {
return 1;
}
}
return 0;
}
/**
* @brief Adds the pkg1/pkg2 conflict to the baddeps list.
*
* @param handle the context handle
* @param baddeps list to add conflict to
* @param pkg1 first package
* @param pkg2 package causing conflict
* @param reason reason for this conflict
*
* @return 0 on success, -1 on error
*/
static int add_conflict(alpm_handle_t *handle, alpm_list_t **baddeps,
alpm_pkg_t *pkg1, alpm_pkg_t *pkg2, alpm_depend_t *reason)
{
alpm_conflict_t *conflict = conflict_new(pkg1, pkg2, reason);
if(!conflict) {
return -1;
}
if(!conflict_isin(conflict, *baddeps)) {
char *conflict_str = alpm_dep_compute_string(reason);
*baddeps = alpm_list_add(*baddeps, conflict);
_alpm_log(handle, ALPM_LOG_DEBUG, "package %s conflicts with %s (by %s)\n",
pkg1->name, pkg2->name, conflict_str);
free(conflict_str);
} else {
_alpm_conflict_free(conflict);
}
return 0;
}
/**
* @brief Check if packages from list1 conflict with packages from list2.
*
* @details This looks at the conflicts fields of all packages from list1, and
* sees if they match packages from list2. If a conflict (pkg1, pkg2) is found,
* it is added to the baddeps list in this order if order >= 0, or reverse
* order (pkg2,pkg1) otherwise.
*
* @param handle the context handle
* @param list1 first list of packages
* @param list2 second list of packages
* @param baddeps list to store conflicts
* @param order if >= 0 the conflict order is preserved, if < 0 it's reversed
*/
static void check_conflict(alpm_handle_t *handle,
alpm_list_t *list1, alpm_list_t *list2,
alpm_list_t **baddeps, int order)
{
alpm_list_t *i;
if(!baddeps) {
return;
}
for(i = list1; i; i = i->next) {
alpm_pkg_t *pkg1 = i->data;
alpm_list_t *j;
for(j = alpm_pkg_get_conflicts(pkg1); j; j = j->next) {
alpm_depend_t *conflict = j->data;
alpm_list_t *k;
for(k = list2; k; k = k->next) {
alpm_pkg_t *pkg2 = k->data;
if(pkg1->name_hash == pkg2->name_hash
&& strcmp(pkg1->name, pkg2->name) == 0) {
/* skip the package we're currently processing */
continue;
}
if(_alpm_depcmp(pkg2, conflict)) {
if(order >= 0) {
add_conflict(handle, baddeps, pkg1, pkg2, conflict);
} else {
add_conflict(handle, baddeps, pkg2, pkg1, conflict);
}
}
}
}
}
}
/**
* @brief Check for inter-conflicts in a list of packages.
*
* @param handle the context handle
* @param packages list of packages to check
*
* @return list of conflicts
*/
alpm_list_t *_alpm_innerconflicts(alpm_handle_t *handle, alpm_list_t *packages)
{
alpm_list_t *baddeps = NULL;
_alpm_log(handle, ALPM_LOG_DEBUG, "check targets vs targets\n");
check_conflict(handle, packages, packages, &baddeps, 0);
return baddeps;
}
/**
* @brief Returns a list of conflicts between a db and a list of packages.
*/
alpm_list_t *_alpm_outerconflicts(alpm_db_t *db, alpm_list_t *packages)
{
alpm_list_t *baddeps = NULL;
if(db == NULL) {
return NULL;
}
alpm_list_t *dblist = alpm_list_diff(_alpm_db_get_pkgcache(db),
packages, _alpm_pkg_cmp);
/* two checks to be done here for conflicts */
_alpm_log(db->handle, ALPM_LOG_DEBUG, "check targets vs db\n");
check_conflict(db->handle, packages, dblist, &baddeps, 1);
_alpm_log(db->handle, ALPM_LOG_DEBUG, "check db vs targets\n");
check_conflict(db->handle, dblist, packages, &baddeps, -1);
alpm_list_free(dblist);
return baddeps;
}
/**
* @brief Check the package conflicts in a database
*
* @param handle the context handle
* @param pkglist the list of packages to check
*
* @return an alpm_list_t of alpm_conflict_t
*/
alpm_list_t SYMEXPORT *alpm_checkconflicts(alpm_handle_t *handle,
alpm_list_t *pkglist)
{
CHECK_HANDLE(handle, return NULL);
return _alpm_innerconflicts(handle, pkglist);
}
/**
* @brief Creates and adds a file conflict to a conflict list.
*
* @param handle the context handle
* @param conflicts the list of conflicts to append to
* @param filestr the conflicting file path
* @param pkg1 package that wishes to install the file
* @param pkg2 package that currently owns the file, or NULL if unowned
*
* @return the updated conflict list
*/
static alpm_list_t *add_fileconflict(alpm_handle_t *handle,
alpm_list_t *conflicts, const char *filestr,
alpm_pkg_t *pkg1, alpm_pkg_t *pkg2)
{
alpm_fileconflict_t *conflict;
MALLOC(conflict, sizeof(alpm_fileconflict_t), goto error);
STRDUP(conflict->target, pkg1->name, goto error);
STRDUP(conflict->file, filestr, goto error);
if(pkg2) {
conflict->type = ALPM_FILECONFLICT_TARGET;
STRDUP(conflict->ctarget, pkg2->name, goto error);
} else {
conflict->type = ALPM_FILECONFLICT_FILESYSTEM;
STRDUP(conflict->ctarget, "", goto error);
}
conflicts = alpm_list_add(conflicts, conflict);
_alpm_log(handle, ALPM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
filestr, pkg1->name, pkg2 ? pkg2->name : "(filesystem)");
return conflicts;
error:
RET_ERR(handle, ALPM_ERR_MEMORY, conflicts);
}
/**
* @brief Frees a conflict and its members.
*/
void _alpm_fileconflict_free(alpm_fileconflict_t *conflict)
{
FREE(conflict->ctarget);
FREE(conflict->file);
FREE(conflict->target);
FREE(conflict);
}
/**
* @brief Recursively checks if a set of packages own all subdirectories and
* files in a directory.
*
* @param handle the context handle
* @param dirpath path of the directory to check
* @param pkgs packages being checked against
*
* @return 1 if a package owns all subdirectories and files, 0 otherwise
*/
static int dir_belongsto_pkgs(alpm_handle_t *handle, const char *dirpath,
alpm_list_t *pkgs)
{
char path[PATH_MAX], full_path[PATH_MAX];
DIR *dir;
struct dirent *ent = NULL;
snprintf(full_path, PATH_MAX, "%s%s", handle->root, dirpath);
dir = opendir(full_path);
if(dir == NULL) {
return 0;
}
while((ent = readdir(dir)) != NULL) {
const char *name = ent->d_name;
int owned = 0, is_dir = 0;
alpm_list_t *i;
struct stat sbuf;
if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
continue;
}
snprintf(full_path, PATH_MAX, "%s%s%s", handle->root, dirpath, name);
if(lstat(full_path, &sbuf) != 0) {
_alpm_log(handle, ALPM_LOG_DEBUG, "could not stat %s\n", full_path);
closedir(dir);
return 0;
}
is_dir = S_ISDIR(sbuf.st_mode);
snprintf(path, PATH_MAX, "%s%s%s", dirpath, name, is_dir ? "/" : "");
for(i = pkgs; i && !owned; i = i->next) {
if(alpm_filelist_contains(alpm_pkg_get_files(i->data), path)) {
owned = 1;
}
}
if(owned && is_dir) {
owned = dir_belongsto_pkgs(handle, path, pkgs);
}
if(!owned) {
closedir(dir);
_alpm_log(handle, ALPM_LOG_DEBUG,
"unowned file %s found in directory\n", path);
return 0;
}
}
closedir(dir);
return 1;
}
static alpm_list_t *alpm_db_find_file_owners(alpm_db_t* db, const char *path)
{
alpm_list_t *i, *owners = NULL;
for(i = alpm_db_get_pkgcache(db); i; i = i->next) {
if(alpm_filelist_contains(alpm_pkg_get_files(i->data), path)) {
owners = alpm_list_add(owners, i->data);
}
}
return owners;
}
/**
* @brief Find file conflicts that may occur during the transaction.
*
* @details Performs two checks:
* 1. check every target against every target
* 2. check every target against the filesystem
*
* @param handle the context handle
* @param upgrade list of packages being installed
* @param rem list of packages being removed
*
* @return list of file conflicts
*/
alpm_list_t *_alpm_db_find_fileconflicts(alpm_handle_t *handle,
alpm_list_t *upgrade, alpm_list_t *rem)
{
alpm_list_t *i, *conflicts = NULL;
size_t numtargs = alpm_list_count(upgrade);
size_t current;
size_t rootlen;
if(!upgrade) {
return NULL;
}
rootlen = strlen(handle->root);
/* TODO this whole function needs a huge change, which hopefully will
* be possible with real transactions. Right now we only do half as much
* here as we do when we actually extract files in add.c with our 12
* different cases. */
for(current = 0, i = upgrade; i; i = i->next, current++) {
alpm_pkg_t *p1 = i->data;
alpm_list_t *j;
alpm_list_t *tmpfiles = NULL;
alpm_pkg_t *dbpkg;
int percent = (current * 100) / numtargs;
PROGRESS(handle, ALPM_PROGRESS_CONFLICTS_START, "", percent,
numtargs, current);
/* CHECK 1: check every target against every target */
_alpm_log(handle, ALPM_LOG_DEBUG, "searching for file conflicts: %s\n",
p1->name);
for(j = i->next; j; j = j->next) {
alpm_list_t *common_files;
alpm_pkg_t *p2 = j->data;
alpm_filelist_t *p1_files = alpm_pkg_get_files(p1);
alpm_filelist_t *p2_files = alpm_pkg_get_files(p2);
common_files = _alpm_filelist_intersection(p1_files, p2_files);
if(common_files) {
alpm_list_t *k;
char path[PATH_MAX];
for(k = common_files; k; k = k->next) {
char *filename = k->data;
snprintf(path, PATH_MAX, "%s%s", handle->root, filename);
/* can skip file-file conflicts when forced *
* checking presence in p2_files detects dir-file or file-dir
* conflicts as the path from p1 is returned */
if((handle->trans->flags & ALPM_TRANS_FLAG_FORCE) &&
alpm_filelist_contains(p2_files, filename)) {
_alpm_log(handle, ALPM_LOG_DEBUG,
"%s exists in both '%s' and '%s'\n", filename,
p1->name, p2->name);
_alpm_log(handle, ALPM_LOG_DEBUG,
"file-file conflict being forced\n");
continue;
}
conflicts = add_fileconflict(handle, conflicts, path, p1, p2);
if(handle->pm_errno == ALPM_ERR_MEMORY) {
FREELIST(conflicts);
alpm_list_free(common_files);
return NULL;
}
}
alpm_list_free(common_files);
}
}
/* CHECK 2: check every target against the filesystem */
_alpm_log(handle, ALPM_LOG_DEBUG, "searching for filesystem conflicts: %s\n",
p1->name);
dbpkg = _alpm_db_get_pkgfromcache(handle->db_local, p1->name);
/* Do two different checks here. If the package is currently installed,
* then only check files that are new in the new package. If the package
* is not currently installed, then simply stat the whole filelist. Note
* that the former list needs to be freed while the latter list should NOT
* be freed. */
if(dbpkg) {
/* older ver of package currently installed */
tmpfiles = _alpm_filelist_difference(alpm_pkg_get_files(p1),
alpm_pkg_get_files(dbpkg));
} else {
/* no version of package currently installed */
alpm_filelist_t *fl = alpm_pkg_get_files(p1);
size_t filenum;
for(filenum = 0; filenum < fl->count; filenum++) {
tmpfiles = alpm_list_add(tmpfiles, fl->files[filenum].name);
}
}
for(j = tmpfiles; j; j = j->next) {
const char *filestr = j->data;
const char *relative_path;
alpm_list_t *k;
/* have we acted on this conflict? */
int resolved_conflict = 0;
struct stat lsbuf;
char path[PATH_MAX];
size_t pathlen;
pathlen = snprintf(path, PATH_MAX, "%s%s", handle->root, filestr);
relative_path = path + rootlen;
/* stat the file - if it exists, do some checks */
if(_alpm_lstat(path, &lsbuf) != 0) {
continue;
}
_alpm_log(handle, ALPM_LOG_DEBUG, "checking possible conflict: %s\n", path);
if(path[pathlen - 1] == '/') {
if(S_ISDIR(lsbuf.st_mode)) {
_alpm_log(handle, ALPM_LOG_DEBUG, "file is a directory, not a conflict\n");
continue;
}
/* if we made it to here, we want all subsequent path comparisons to
* not include the trailing slash. This allows things like file ->
* directory replacements. */
path[pathlen - 1] = '\0';
/* Check if the directory was a file in dbpkg */
if(alpm_filelist_contains(alpm_pkg_get_files(dbpkg), relative_path)) {
size_t fslen = strlen(filestr);
_alpm_log(handle, ALPM_LOG_DEBUG,
"replacing package file with a directory, not a conflict\n");
resolved_conflict = 1;
/* go ahead and skip any files inside filestr as they will
* necessarily be resolved by replacing the file with a dir
* NOTE: afterward, j will point to the last file inside filestr */
for( ; j->next; j = j->next) {
const char *filestr2 = j->next->data;
if(strncmp(filestr, filestr2, fslen) != 0) {
break;
}
}
}
}
/* Check remove list (will we remove the conflicting local file?) */
for(k = rem; k && !resolved_conflict; k = k->next) {
alpm_pkg_t *rempkg = k->data;
if(rempkg && alpm_filelist_contains(alpm_pkg_get_files(rempkg),
relative_path)) {
_alpm_log(handle, ALPM_LOG_DEBUG,
"local file will be removed, not a conflict\n");
resolved_conflict = 1;
}
}
/* Look at all the targets to see if file has changed hands */
for(k = upgrade; k && !resolved_conflict; k = k->next) {
alpm_pkg_t *localp2, *p2 = k->data;
if(!p2 || p1 == p2) {
/* skip p1; both p1 and p2 come directly from the upgrade list
* so they can be compared directly */
continue;
}
localp2 = _alpm_db_get_pkgfromcache(handle->db_local, p2->name);
/* localp2->files will be removed (target conflicts are handled by CHECK 1) */
if(localp2 && alpm_filelist_contains(alpm_pkg_get_files(localp2), relative_path)) {
/* skip removal of file, but not add. this will prevent a second
* package from removing the file when it was already installed
* by its new owner (whether the file is in backup array or not */
handle->trans->skip_remove =
alpm_list_add(handle->trans->skip_remove, strdup(relative_path));
_alpm_log(handle, ALPM_LOG_DEBUG,
"file changed packages, adding to remove skiplist\n");
resolved_conflict = 1;
}
}
/* check if all files of the dir belong to the installed pkg */
if(!resolved_conflict && S_ISDIR(lsbuf.st_mode)) {
alpm_list_t *owners;
char *dir = malloc(strlen(relative_path) + 2);
sprintf(dir, "%s/", relative_path);
owners = alpm_db_find_file_owners(handle->db_local, dir);
if(owners) {
alpm_list_t *pkgs = NULL, *diff;
if(dbpkg) {
pkgs = alpm_list_add(pkgs, dbpkg);
}
pkgs = alpm_list_join(pkgs, alpm_list_copy(rem));
if((diff = alpm_list_diff(owners, pkgs, _alpm_pkg_cmp))) {
/* dir is owned by files we aren't removing */
/* TODO: with better commit ordering, we may be able to check
* against upgrades as well */
alpm_list_free(diff);
} else {
_alpm_log(handle, ALPM_LOG_DEBUG,
"checking if all files in %s belong to removed packages\n",
dir);
resolved_conflict = dir_belongsto_pkgs(handle, dir, owners);
}
alpm_list_free(pkgs);
alpm_list_free(owners);
}
free(dir);
}
/* is the file unowned and in the backup list of the new package? */
if(!resolved_conflict && _alpm_needbackup(relative_path, p1)) {
alpm_list_t *local_pkgs = _alpm_db_get_pkgcache(handle->db_local);
int found = 0;
for(k = local_pkgs; k && !found; k = k->next) {
if(alpm_filelist_contains(alpm_pkg_get_files(k->data), relative_path)) {
found = 1;
}
}
if(!found) {
_alpm_log(handle, ALPM_LOG_DEBUG,
"file was unowned but in new backup list\n");
resolved_conflict = 1;
}
}
/* skip file-file conflicts when being forced */
if((handle->trans->flags & ALPM_TRANS_FLAG_FORCE) &&
!S_ISDIR(lsbuf.st_mode)) {
_alpm_log(handle, ALPM_LOG_DEBUG,
"conflict with file on filesystem being forced\n");
resolved_conflict = 1;
}
if(!resolved_conflict) {
conflicts = add_fileconflict(handle, conflicts, path, p1, NULL);
if(handle->pm_errno == ALPM_ERR_MEMORY) {
FREELIST(conflicts);
alpm_list_free(tmpfiles);
return NULL;
}
}
}
alpm_list_free(tmpfiles);
}
PROGRESS(handle, ALPM_PROGRESS_CONFLICTS_START, "", 100,
numtargs, current);
return conflicts;
}
/* vim: set noet: */