pmlist_t *_pacman_db_find_conflicts(pmdb_t *db, pmtrans_t *trans, char *root, pmlist_t **skip_list) { pmlist_t *i, *j, *k; char *filestr = NULL; char path[PATH_MAX+1]; struct stat buf; pmlist_t *conflicts = NULL; pmlist_t *targets = trans->packages; pmpkg_t *p, *dbpkg; double percent; int howmany, remain; if(db == NULL || targets == NULL || root == NULL) { return(NULL); } howmany = _pacman_list_count(targets); /* CHECK 1: check every target against every target */ for(i = targets; i; i = i->next) { pmpkg_t *p1 = (pmpkg_t*)i->data; remain = _pacman_list_count(i); percent = (double)(howmany - remain + 1) / howmany; PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", (percent * 100), howmany, howmany - remain + 1); for(j = i; j; j = j->next) { pmpkg_t *p2 = (pmpkg_t*)j->data; if(strcmp(p1->name, p2->name)) { pmlist_t *ret = chk_fileconflicts(p1->files, p2->files); for(k = ret; k; k = k->next) { pmconflict_t *conflict = _pacman_malloc(sizeof(pmconflict_t)); if(conflict == NULL) { continue; } conflict->type = PM_CONFLICT_TYPE_TARGET; STRNCPY(conflict->target, p1->name, PKG_NAME_LEN); STRNCPY(conflict->file, k->data, CONFLICT_FILE_LEN); STRNCPY(conflict->ctarget, p2->name, PKG_NAME_LEN); conflicts = _pacman_list_add(conflicts, conflict); } FREELIST(ret); } } /* CHECK 2: check every target against the filesystem */ p = (pmpkg_t*)i->data; dbpkg = NULL; for(j = p->files; j; j = j->next) { filestr = (char*)j->data; snprintf(path, PATH_MAX, "%s%s", root, filestr); /* is this target a file or directory? */ if(path[strlen(path)-1] == '/') { path[strlen(path)-1] = '\0'; } if(!lstat(path, &buf)) { int ok = 0; /* re-fetch with stat() instead of lstat() */ stat(path, &buf); if(S_ISDIR(buf.st_mode)) { /* if it's a directory, then we have no conflict */ ok = 1; } else { if(dbpkg == NULL) { dbpkg = _pacman_db_get_pkgfromcache(db, p->name); } if(dbpkg && !(dbpkg->infolevel & INFRQ_FILES)) { _pacman_log(PM_LOG_DEBUG, _("loading FILES info for '%s'"), dbpkg->name); _pacman_db_read(db, INFRQ_FILES, dbpkg); } if(dbpkg && _pacman_list_is_strin(j->data, dbpkg->files)) { ok = 1; } /* Check if the conflicting file has been moved to another package/target */ if(!ok) { /* Look at all the targets */ for(k = targets; k && !ok; k = k->next) { pmpkg_t *p2 = (pmpkg_t *)k->data; /* As long as they're not the current package */ if(strcmp(p2->name, p->name)) { pmpkg_t *dbpkg2 = NULL; dbpkg2 = _pacman_db_get_pkgfromcache(db, p2->name); if(dbpkg2 && !(dbpkg2->infolevel & INFRQ_FILES)) { _pacman_log(PM_LOG_DEBUG, _("loading FILES info for '%s'"), dbpkg2->name); _pacman_db_read(db, INFRQ_FILES, dbpkg2); } /* If it used to exist in there, but doesn't anymore */ if(dbpkg2 && !_pacman_list_is_strin(filestr, p2->files) && _pacman_list_is_strin(filestr, dbpkg2->files)) { ok = 1; /* Add to the "skip list" of files that we shouldn't remove during an upgrade. * * This is a workaround for the following scenario: * * - the old package A provides file X * - the new package A does not * - the new package B provides file X * - package A depends on B, so B is upgraded first * * Package B is upgraded, so file X is installed. Then package A * is upgraded, and it *removes* file X, since it no longer exists * in package A. * * Our workaround is to scan through all "old" packages and all "new" * ones, looking for files that jump to different packages. */ *skip_list = _pacman_list_add(*skip_list, strdup(filestr)); } } } } } if(!ok) { pmconflict_t *conflict = _pacman_malloc(sizeof(pmconflict_t)); if(conflict == NULL) { continue; } conflict->type = PM_CONFLICT_TYPE_FILE; STRNCPY(conflict->target, p->name, PKG_NAME_LEN); STRNCPY(conflict->file, filestr, CONFLICT_FILE_LEN); conflict->ctarget[0] = 0; conflicts = _pacman_list_add(conflicts, conflict); } } } } return(conflicts); }
/* 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); }