void
pk_backend_add_database (const gchar *name, alpm_list_t *servers,
alpm_siglevel_t level)
{
PkBackendRepo *repo = g_new (PkBackendRepo, 1);
g_return_if_fail (name != NULL);
repo->name = g_strdup (name);
repo->servers = alpm_list_strdup (servers);
repo->level = level;
configured = alpm_list_add (configured, repo);
}
void
pk_alpm_add_database (PkBackend *backend, const gchar *name, alpm_list_t *servers,
alpm_siglevel_t level)
{
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
PkBackendRepo *repo = g_new (PkBackendRepo, 1);
g_return_if_fail (name != NULL);
repo->name = g_strdup (name);
repo->servers = alpm_list_strdup (servers);
repo->level = level;
priv->configured_repos = alpm_list_add (priv->configured_repos, repo);
}
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;
}
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 Remove a package's files, optionally skipping its replacement's
* files.
*
* @param handle the context handle
* @param oldpkg package to remove
* @param newpkg package to replace \a oldpkg (optional)
* @param targ_count current index within the transaction (1-based)
* @param pkg_count the number of packages affected by the transaction
*
* @return 0 on success, -1 if alpm lacks permission to delete some of the
* files, >0 the number of files alpm was unable to delete
*/
static int remove_package_files(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;
alpm_filelist_t *filelist;
size_t i;
int err = 0;
int nosave = handle->trans->flags & ALPM_TRANS_FLAG_NOSAVE;
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));
}
} else {
skip_remove = alpm_list_strdup(handle->trans->skip_remove);
}
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",
oldpkg->name);
FREELIST(skip_remove);
RET_ERR(handle, ALPM_ERR_PKG_CANT_REMOVE, -1);
}
}
_alpm_log(handle, ALPM_LOG_DEBUG, "removing %zd files\n", filelist->count);
if(!newpkg) {
/* init progress bar, but only on true remove transactions */
PROGRESS(handle, ALPM_PROGRESS_REMOVE_START, oldpkg->name, 0,
pkg_count, targ_count);
}
/* iterate through the list backwards, unlinking files */
for(i = filelist->count; i > 0; i--) {
alpm_file_t *file = filelist->files + i - 1;
if(unlink_file(handle, oldpkg, newpkg, file, skip_remove, nosave) < 0) {
err++;
}
if(!newpkg) {
/* update progress bar after each file */
int percent = ((filelist->count - i) * 100) / filelist->count;
PROGRESS(handle, ALPM_PROGRESS_REMOVE_START, oldpkg->name,
percent, pkg_count, targ_count);
}
}
FREELIST(skip_remove);
if(!newpkg) {
/* set progress to 100% after we finish unlinking files */
PROGRESS(handle, ALPM_PROGRESS_REMOVE_START, oldpkg->name, 100,
pkg_count, targ_count);
}
return err;
}
/**
* pacman_manager_set_ignore_packages:
* @manager: A #PacmanManager.
* @packages: A list of package names.
*
* Sets the list of IgnorePkgs to @packages. See pacman_manager_get_ignore_packages().
*/
void pacman_manager_set_ignore_packages (PacmanManager *manager, PacmanList *packages) {
g_return_if_fail (manager != NULL);
alpm_option_set_ignorepkgs (alpm_list_strdup (packages));
}
/**
* pacman_manager_set_ignore_groups:
* @manager: A #PacmanManager.
* @groups: A list of group names.
*
* Sets the list of IgnoreGroups to @groups. See pacman_manager_get_ignore_groups().
*/
void pacman_manager_set_ignore_groups (PacmanManager *manager, PacmanList *groups) {
g_return_if_fail (manager != NULL);
alpm_option_set_ignoregrps (alpm_list_strdup (groups));
}
/**
* pacman_manager_set_cache_paths:
* @manager: A #PacmanManager.
* @paths: A list of directory names.
*
* Sets the list of CacheDirs to @paths. See pacman_manager_get_cache_paths().
*/
void pacman_manager_set_cache_paths (PacmanManager *manager, PacmanList *paths) {
g_return_if_fail (manager != NULL);
g_return_if_fail (paths != NULL);
alpm_option_set_cachedirs (alpm_list_strdup (paths));
}
/**
* pacman_manager_set_no_upgrades:
* @manager: A #PacmanManager.
* @filenames: A list of file names (without a leading slash).
*
* Sets the list of NoUpgrades to @filenames. See pacman_manager_get_no_upgrades().
*/
void pacman_manager_set_no_upgrades (PacmanManager *manager, PacmanList *filenames) {
g_return_if_fail (manager != NULL);
alpm_option_set_noupgrades (alpm_list_strdup (filenames));
}
/* Find file conflicts that may occur during the transaction with two checks:
* 1: check every target against every target
* 2: check every target against the filesystem */
alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans, char *root)
{
alpm_list_t *i, *conflicts = NULL;
alpm_list_t *targets = trans->packages;
int numtargs = alpm_list_count(targets);
int current;
ALPM_LOG_FUNC;
if(db == NULL || targets == NULL || root == NULL) {
return(NULL);
}
/* 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 = 1, i = targets; i; i = i->next, current++) {
alpm_list_t *j, *k, *tmpfiles = NULL;
pmpkg_t *p1, *p2, *dbpkg;
char path[PATH_MAX+1];
p1 = i->data;
if(!p1) {
continue;
}
double percent = (double)current / numtargs;
PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", (percent * 100),
numtargs, current);
/* CHECK 1: check every target against every target */
_alpm_log(PM_LOG_DEBUG, "searching for file conflicts: %s\n",
alpm_pkg_get_name(p1));
for(j = i->next; j; j = j->next) {
p2 = j->data;
if(!p2) {
continue;
}
tmpfiles = chk_fileconflicts(alpm_pkg_get_files(p1), alpm_pkg_get_files(p2));
if(tmpfiles) {
for(k = tmpfiles; k; k = k->next) {
snprintf(path, PATH_MAX, "%s%s", root, (char *)k->data);
conflicts = add_fileconflict(conflicts, PM_FILECONFLICT_TARGET, path,
alpm_pkg_get_name(p1), alpm_pkg_get_name(p2));
}
FREELIST(tmpfiles);
}
}
/* declarations for second check */
struct stat lsbuf, sbuf;
char *filestr = NULL;
/* CHECK 2: check every target against the filesystem */
_alpm_log(PM_LOG_DEBUG, "searching for filesystem conflicts: %s\n", p1->name);
dbpkg = _alpm_db_get_pkgfromcache(db, p1->name);
/* Do two different checks here. f 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 */
if(dbpkg) {
/* older ver of package currently installed */
tmpfiles = chk_filedifference(alpm_pkg_get_files(p1),
alpm_pkg_get_files(dbpkg));
} else {
/* no version of package currently installed */
tmpfiles = alpm_list_strdup(alpm_pkg_get_files(p1));
}
/* loop over each file to be installed */
for(j = tmpfiles; j; j = j->next) {
int skip_conflict = 0;
filestr = j->data;
snprintf(path, PATH_MAX, "%s%s", root, filestr);
/* stat the file - if it exists, do some checks */
if(_alpm_lstat(path, &lsbuf) != 0) {
continue;
}
stat(path, &sbuf);
if(path[strlen(path)-1] == '/') {
if(S_ISDIR(lsbuf.st_mode)) {
_alpm_log(PM_LOG_DEBUG, "%s is a directory, not a conflict\n", path);
skip_conflict = 1;
} else if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(sbuf.st_mode)) {
_alpm_log(PM_LOG_DEBUG,
"%s is a symlink to a dir, hopefully not a conflict\n", path);
skip_conflict = 1;
}
}
if(!skip_conflict) {
_alpm_log(PM_LOG_DEBUG, "checking possible conflict: %s\n", path);
/* Look at all the targets to see if file has changed hands */
int resolved_conflict = 0; /* have we acted on this conflict? */
for(k = targets; k; k = k->next) {
p2 = k->data;
if(!p2 || strcmp(p1->name, p2->name) == 0) {
continue;
}
pmpkg_t *localp2 = _alpm_db_get_pkgfromcache(db, p2->name);
/* Check if it used to exist in a package, but doesn't anymore */
alpm_list_t *pkgfiles, *localfiles; /* added for readability */
pkgfiles = alpm_pkg_get_files(p2);
localfiles = alpm_pkg_get_files(localp2);
if(localp2 && !alpm_list_find_str(pkgfiles, filestr)
&& alpm_list_find_str(localfiles, filestr)) {
/* 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 */
trans->skip_remove = alpm_list_add(trans->skip_remove, strdup(path));
_alpm_log(PM_LOG_DEBUG, "file changed packages, adding to remove skiplist: %s\n", filestr);
resolved_conflict = 1;
break;
}
}
if(!resolved_conflict) {
_alpm_log(PM_LOG_DEBUG, "file found in conflict: %s\n", path);
conflicts = add_fileconflict(conflicts, PM_FILECONFLICT_FILESYSTEM,
path, p1->name, NULL);
}
}
}
FREELIST(tmpfiles);
}
return(conflicts);
}
