2005-03-14 20:51:43 -05:00
|
|
|
/*
|
|
|
|
* add.c
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2011-01-05 23:45:15 -05:00
|
|
|
* Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
|
2009-07-01 03:08:33 -04:00
|
|
|
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2005-03-14 20:51:43 -05:00
|
|
|
* 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
|
2007-12-10 23:55:22 -05:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
2007-03-05 17:13:33 -05:00
|
|
|
|
2005-03-14 20:51:43 -05:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <string.h>
|
2006-03-02 14:06:52 -05:00
|
|
|
#include <limits.h>
|
2007-07-15 21:36:46 -04:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2008-06-01 22:47:31 -04:00
|
|
|
#include <inttypes.h> /* int64_t */
|
|
|
|
#include <stdint.h> /* intmax_t */
|
2007-03-05 17:13:33 -05:00
|
|
|
|
2007-04-29 12:47:02 -04:00
|
|
|
/* libarchive */
|
|
|
|
#include <archive.h>
|
|
|
|
#include <archive_entry.h>
|
|
|
|
|
2007-03-05 17:13:33 -05:00
|
|
|
/* libalpm */
|
|
|
|
#include "add.h"
|
2007-01-19 04:28:44 -05:00
|
|
|
#include "alpm_list.h"
|
2006-10-15 15:31:03 -04:00
|
|
|
#include "trans.h"
|
2005-03-14 20:51:43 -05:00
|
|
|
#include "util.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "backup.h"
|
|
|
|
#include "package.h"
|
|
|
|
#include "db.h"
|
2005-03-23 15:06:58 -05:00
|
|
|
#include "conflict.h"
|
2005-03-14 20:51:43 -05:00
|
|
|
#include "deps.h"
|
|
|
|
#include "remove.h"
|
|
|
|
#include "handle.h"
|
|
|
|
|
2010-10-16 18:57:37 -04:00
|
|
|
/** Add a package to the transaction.
|
|
|
|
* @param pkg the package to add
|
|
|
|
* @return 0 on success, -1 on error (pm_errno is set accordingly)
|
|
|
|
*/
|
|
|
|
int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
|
|
|
|
{
|
|
|
|
const char *pkgname, *pkgver;
|
|
|
|
pmtrans_t *trans;
|
|
|
|
pmdb_t *db_local;
|
|
|
|
pmpkg_t *local;
|
|
|
|
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
|
|
|
|
/* Sanity checks */
|
|
|
|
ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
|
|
|
|
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
|
|
|
|
trans = handle->trans;
|
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(PM_ERR_TRANS_NOT_INITIALIZED, -1));
|
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
db_local = handle->db_local;
|
|
|
|
|
|
|
|
pkgname = alpm_pkg_get_name(pkg);
|
|
|
|
pkgver = alpm_pkg_get_version(pkg);
|
|
|
|
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "adding package '%s'\n", pkgname);
|
|
|
|
|
|
|
|
if(_alpm_pkg_find(trans->add, pkgname)) {
|
|
|
|
RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
local = _alpm_db_get_pkgfromcache(db_local, pkgname);
|
|
|
|
if(local) {
|
|
|
|
const char *localpkgname = alpm_pkg_get_name(local);
|
|
|
|
const char *localpkgver = alpm_pkg_get_version(local);
|
|
|
|
int cmp = _alpm_pkg_compare_versions(pkg, local);
|
|
|
|
|
|
|
|
if(cmp == 0) {
|
|
|
|
if(trans->flags & PM_TRANS_FLAG_NEEDED) {
|
|
|
|
/* with the NEEDED flag, packages up to date are not reinstalled */
|
|
|
|
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
|
|
|
|
localpkgname, localpkgver);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2010-10-16 18:57:37 -04:00
|
|
|
} else {
|
|
|
|
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
|
|
|
|
localpkgname, localpkgver);
|
|
|
|
}
|
|
|
|
} else if(cmp < 0) {
|
|
|
|
/* local version is newer */
|
|
|
|
_alpm_log(PM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
|
|
|
|
localpkgname, localpkgver, pkgver);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add the package to the transaction */
|
|
|
|
pkg->reason = PM_PKG_REASON_EXPLICIT;
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
|
|
|
|
pkgname, pkgver);
|
|
|
|
trans->add = alpm_list_add(trans->add, pkg);
|
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2010-10-16 18:57:37 -04:00
|
|
|
}
|
|
|
|
|
2008-10-31 23:43:55 -04:00
|
|
|
static int perform_extraction(struct archive *archive,
|
|
|
|
struct archive_entry *entry, const char *filename, const char *origname)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
const int archive_flags = ARCHIVE_EXTRACT_OWNER |
|
|
|
|
ARCHIVE_EXTRACT_PERM |
|
|
|
|
ARCHIVE_EXTRACT_TIME;
|
|
|
|
|
|
|
|
archive_entry_set_pathname(entry, filename);
|
|
|
|
|
|
|
|
ret = archive_read_extract(archive, entry, archive_flags);
|
|
|
|
if(ret == ARCHIVE_WARN && archive_errno(archive) != ENOSPC) {
|
|
|
|
/* operation succeeded but a "non-critical" error was encountered */
|
|
|
|
_alpm_log(PM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
|
|
|
|
origname, archive_error_string(archive));
|
|
|
|
} else if(ret != ARCHIVE_OK) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not extract %s (%s)\n"),
|
|
|
|
origname, archive_error_string(archive));
|
|
|
|
alpm_logaction("error: could not extract %s (%s)\n",
|
|
|
|
origname, archive_error_string(archive));
|
2011-03-20 20:45:57 -04:00
|
|
|
return 1;
|
2008-10-31 23:43:55 -04:00
|
|
|
}
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2008-10-31 23:43:55 -04:00
|
|
|
}
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
static int extract_single_file(struct archive *archive,
|
|
|
|
struct archive_entry *entry, pmpkg_t *newpkg, pmpkg_t *oldpkg,
|
|
|
|
pmtrans_t *trans, pmdb_t *db)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2008-05-04 21:51:04 -04:00
|
|
|
const char *entryname;
|
2007-07-15 21:36:46 -04:00
|
|
|
mode_t entrymode;
|
|
|
|
char filename[PATH_MAX]; /* the actual file we're extracting */
|
|
|
|
int needbackup = 0, notouch = 0;
|
|
|
|
char *hash_orig = NULL;
|
2008-05-04 21:51:04 -04:00
|
|
|
char *entryname_orig = NULL;
|
2007-07-15 21:36:46 -04:00
|
|
|
int errors = 0;
|
|
|
|
|
2008-05-04 21:51:04 -04:00
|
|
|
entryname = archive_entry_pathname(entry);
|
2007-07-15 21:36:46 -04:00
|
|
|
entrymode = archive_entry_mode(entry);
|
|
|
|
|
|
|
|
memset(filename, 0, PATH_MAX); /* just to be sure */
|
|
|
|
|
|
|
|
if(strcmp(entryname, ".INSTALL") == 0) {
|
|
|
|
/* the install script goes inside the db */
|
2009-09-14 23:44:51 -04:00
|
|
|
snprintf(filename, PATH_MAX, "%s%s-%s/install",
|
|
|
|
_alpm_db_path(db), newpkg->name, newpkg->version);
|
Use archive_entry_set_perm instead of archive_entry_set_mode
This patch fixes FS#12148 ('unstable' regular file).
I also changed the other archive_entry_set_mode usage in add.c to
archive_entry_set_perm.
Since I cannot find any relevant info in libarchive manual, I quote
Tim Kientzle (the author of libarchive) here, and I say thank you for
his help.
*** Tim Kientzle wrote *************************************
This is the problem in libalpm/util.c:
323 if(S_ISREG(st->st_mode)) {
324 archive_entry_set_mode(entry, 0644);
325 } else if(S_ISDIR(st->st_mode)) {
326 archive_entry_set_mode(entry, 0755);
327 }
Your example unstable.db.tar.gz is not empty. It has
one entry in it, called "./". That entry is marked
as a directory. But, when you call archive_entry_set_mode(),
you are changing the file type! archive_read_extract()
then creates the file /var/unstable as you requested.
(archive_read_extract() will replace an empty directory
with a file.)
You should either set the mode value correctly:
323 if(S_ISREG(st->st_mode)) {
324 archive_entry_set_mode(entry, IFREG | 0644);
325 } else if(S_ISDIR(st->st_mode)) {
326 archive_entry_set_mode(entry, IFDIR | 0755);
327 }
Or use archive_entry_set_perm(), which does not change
the file type:
323 if(S_ISREG(st->st_mode)) {
324 archive_entry_set_perm(entry, 0644);
325 } else if(S_ISDIR(st->st_mode)) {
326 archive_entry_set_perm(entry, 0755);
327 }
************************************************************
Signed-off-by: Nagy Gabor <ngaba@bibl.u-szeged.hu>
Signed-off-by: Dan McGee <dan@archlinux.org>
2009-01-18 14:03:56 -05:00
|
|
|
archive_entry_set_perm(entry, 0644);
|
2007-07-15 21:36:46 -04:00
|
|
|
} else if(strcmp(entryname, ".CHANGELOG") == 0) {
|
|
|
|
/* the changelog goes inside the db */
|
2009-09-14 23:44:51 -04:00
|
|
|
snprintf(filename, PATH_MAX, "%s%s-%s/changelog",
|
|
|
|
_alpm_db_path(db), newpkg->name, newpkg->version);
|
Use archive_entry_set_perm instead of archive_entry_set_mode
This patch fixes FS#12148 ('unstable' regular file).
I also changed the other archive_entry_set_mode usage in add.c to
archive_entry_set_perm.
Since I cannot find any relevant info in libarchive manual, I quote
Tim Kientzle (the author of libarchive) here, and I say thank you for
his help.
*** Tim Kientzle wrote *************************************
This is the problem in libalpm/util.c:
323 if(S_ISREG(st->st_mode)) {
324 archive_entry_set_mode(entry, 0644);
325 } else if(S_ISDIR(st->st_mode)) {
326 archive_entry_set_mode(entry, 0755);
327 }
Your example unstable.db.tar.gz is not empty. It has
one entry in it, called "./". That entry is marked
as a directory. But, when you call archive_entry_set_mode(),
you are changing the file type! archive_read_extract()
then creates the file /var/unstable as you requested.
(archive_read_extract() will replace an empty directory
with a file.)
You should either set the mode value correctly:
323 if(S_ISREG(st->st_mode)) {
324 archive_entry_set_mode(entry, IFREG | 0644);
325 } else if(S_ISDIR(st->st_mode)) {
326 archive_entry_set_mode(entry, IFDIR | 0755);
327 }
Or use archive_entry_set_perm(), which does not change
the file type:
323 if(S_ISREG(st->st_mode)) {
324 archive_entry_set_perm(entry, 0644);
325 } else if(S_ISDIR(st->st_mode)) {
326 archive_entry_set_perm(entry, 0755);
327 }
************************************************************
Signed-off-by: Nagy Gabor <ngaba@bibl.u-szeged.hu>
Signed-off-by: Dan McGee <dan@archlinux.org>
2009-01-18 14:03:56 -05:00
|
|
|
archive_entry_set_perm(entry, 0644);
|
2007-07-15 21:36:46 -04:00
|
|
|
} else if(*entryname == '.') {
|
|
|
|
/* for now, ignore all files starting with '.' that haven't
|
|
|
|
* already been handled (for future possibilities) */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
|
2007-07-15 21:36:46 -04:00
|
|
|
archive_read_data_skip(archive);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2007-07-15 21:36:46 -04:00
|
|
|
} else {
|
|
|
|
/* build the new entryname relative to handle->root */
|
|
|
|
snprintf(filename, PATH_MAX, "%s%s", handle->root, entryname);
|
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* if a file is in NoExtract then we never extract it */
|
|
|
|
if(alpm_list_find_str(handle->noextract, entryname)) {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "%s is in NoExtract, skipping extraction\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
entryname);
|
2007-11-04 14:53:34 -05:00
|
|
|
alpm_logaction("note: %s is in NoExtract, skipping extraction\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
entryname);
|
|
|
|
archive_read_data_skip(archive);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* Check for file existence. This is one of the more crucial parts
|
|
|
|
* to get 'right'. Here are the possibilities, with the filesystem
|
|
|
|
* on the left and the package on the top:
|
|
|
|
* (F=file, N=node, S=symlink, D=dir)
|
|
|
|
* | F/N | S | D
|
|
|
|
* non-existent | 1 | 2 | 3
|
|
|
|
* F/N | 4 | 5 | 6
|
|
|
|
* S | 7 | 8 | 9
|
|
|
|
* D | 10 | 11 | 12
|
|
|
|
*
|
2007-11-04 19:02:25 -05:00
|
|
|
* 1,2,3- extract, no magic necessary. lstat (_alpm_lstat) will fail here.
|
2007-07-15 21:36:46 -04:00
|
|
|
* 4,5,6,7,8- conflict checks should have caught this. either overwrite
|
|
|
|
* or backup the file.
|
|
|
|
* 9- follow the symlink, hopefully it is a directory, check it.
|
|
|
|
* 10- file replacing directory- don't allow it.
|
|
|
|
* 11- don't extract symlink- a dir exists here. we don't want links to
|
|
|
|
* links, etc.
|
|
|
|
* 12- skip extraction, dir already exists.
|
|
|
|
*/
|
2008-02-07 08:58:23 -05:00
|
|
|
|
|
|
|
/* do both a lstat and a stat, so we can see what symlinks point to */
|
|
|
|
struct stat lsbuf, sbuf;
|
|
|
|
if(_alpm_lstat(filename, &lsbuf) != 0 || stat(filename, &sbuf) != 0) {
|
2007-07-15 21:36:46 -04:00
|
|
|
/* cases 1,2,3: couldn't stat an existing file, skip all backup checks */
|
|
|
|
} else {
|
2009-07-17 09:48:57 -04:00
|
|
|
if(S_ISDIR(lsbuf.st_mode)) {
|
|
|
|
if(S_ISDIR(entrymode)) {
|
|
|
|
/* case 12: existing dir, ignore it */
|
|
|
|
if(lsbuf.st_mode != entrymode) {
|
|
|
|
/* if filesystem perms are different than pkg perms, warn user */
|
2009-10-11 15:02:20 -04:00
|
|
|
mode_t mask = 07777;
|
2009-07-17 09:48:57 -04:00
|
|
|
_alpm_log(PM_LOG_WARNING, _("directory permissions differ on %s\n"
|
|
|
|
"filesystem: %o package: %o\n"), entryname, lsbuf.st_mode & mask,
|
|
|
|
entrymode & mask);
|
|
|
|
alpm_logaction("warning: directory permissions differ on %s\n"
|
2007-11-04 14:53:34 -05:00
|
|
|
"filesystem: %o package: %o\n", entryname, lsbuf.st_mode & mask,
|
2009-07-17 09:48:57 -04:00
|
|
|
entrymode & mask);
|
|
|
|
}
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
|
|
|
|
entryname);
|
|
|
|
archive_read_data_skip(archive);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2009-07-17 09:48:57 -04:00
|
|
|
} else {
|
|
|
|
/* case 10/11: trying to overwrite dir with file/symlink, don't allow it */
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
|
|
|
|
entryname);
|
|
|
|
archive_read_data_skip(archive);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 1;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
} else if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(entrymode)) {
|
|
|
|
/* case 9: existing symlink, dir in package */
|
|
|
|
if(S_ISDIR(sbuf.st_mode)) {
|
|
|
|
/* the symlink on FS is to a directory, so we'll use it */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
entryname);
|
|
|
|
archive_read_data_skip(archive);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2007-07-15 21:36:46 -04:00
|
|
|
} else {
|
|
|
|
/* this is BAD. symlink was not to a directory */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
entryname);
|
|
|
|
archive_read_data_skip(archive);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 1;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
} else if(S_ISREG(lsbuf.st_mode) && S_ISDIR(entrymode)) {
|
|
|
|
/* case 6: trying to overwrite file with dir */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
entryname);
|
|
|
|
} else if(S_ISREG(entrymode)) {
|
|
|
|
/* case 4,7: */
|
|
|
|
/* if file is in NoUpgrade, don't touch it */
|
|
|
|
if(alpm_list_find_str(handle->noupgrade, entryname)) {
|
|
|
|
notouch = 1;
|
|
|
|
} else {
|
|
|
|
/* go to the backup array and see if our conflict is there */
|
|
|
|
/* check newpkg first, so that adding backup files is retroactive */
|
2007-12-02 17:48:12 -05:00
|
|
|
if(alpm_list_find_str(alpm_pkg_get_backup(newpkg), entryname) != NULL) {
|
|
|
|
needbackup = 1;
|
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
|
|
|
|
/* check oldpkg for a backup entry, store the hash if available */
|
|
|
|
if(oldpkg) {
|
|
|
|
hash_orig = _alpm_needbackup(entryname, alpm_pkg_get_backup(oldpkg));
|
|
|
|
if(hash_orig) {
|
|
|
|
needbackup = 1;
|
|
|
|
}
|
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* if we force hash_orig to be non-NULL retroactive backup works */
|
|
|
|
if(needbackup && !hash_orig) {
|
2008-04-08 19:54:25 -04:00
|
|
|
STRDUP(hash_orig, "", RET_ERR(PM_ERR_MEMORY, -1));
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
}
|
2006-07-14 19:15:07 -04:00
|
|
|
}
|
2007-12-02 18:24:22 -05:00
|
|
|
/* else if(S_ISLNK(entrymode)) */
|
2007-07-15 21:36:46 -04:00
|
|
|
/* case 5,8: don't need to do anything special */
|
|
|
|
}
|
2006-07-14 19:15:07 -04:00
|
|
|
|
2008-05-04 21:51:04 -04:00
|
|
|
/* we need access to the original entryname later after calls to
|
|
|
|
* archive_entry_set_pathname(), so we need to dupe it and free() later */
|
|
|
|
STRDUP(entryname_orig, entryname, RET_ERR(PM_ERR_MEMORY, -1));
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(needbackup) {
|
2008-04-28 23:19:56 -04:00
|
|
|
char checkfile[PATH_MAX];
|
2007-07-15 21:36:46 -04:00
|
|
|
char *hash_local = NULL, *hash_pkg = NULL;
|
2008-04-08 19:54:25 -04:00
|
|
|
int ret;
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2008-04-28 23:19:56 -04:00
|
|
|
snprintf(checkfile, PATH_MAX, "%s.paccheck", filename);
|
2008-10-31 23:43:55 -04:00
|
|
|
|
|
|
|
ret = perform_extraction(archive, entry, checkfile, entryname_orig);
|
|
|
|
if(ret == 1) {
|
|
|
|
/* error */
|
2007-07-15 21:36:46 -04:00
|
|
|
FREE(hash_orig);
|
2008-05-04 21:51:04 -04:00
|
|
|
FREE(entryname_orig);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 1;
|
2007-02-17 03:55:05 -05:00
|
|
|
}
|
2005-03-26 15:24:57 -05:00
|
|
|
|
2008-08-26 06:57:08 -04:00
|
|
|
hash_local = alpm_compute_md5sum(filename);
|
|
|
|
hash_pkg = alpm_compute_md5sum(checkfile);
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2007-07-25 17:35:29 -04:00
|
|
|
/* append the new md5 hash to it's respective entry
|
2007-07-15 21:36:46 -04:00
|
|
|
* in newpkg's backup (it will be the new orginal) */
|
|
|
|
alpm_list_t *backups;
|
|
|
|
for(backups = alpm_pkg_get_backup(newpkg); backups;
|
|
|
|
backups = alpm_list_next(backups)) {
|
|
|
|
char *oldbackup = alpm_list_getdata(backups);
|
2008-05-04 21:51:04 -04:00
|
|
|
if(!oldbackup || strcmp(oldbackup, entryname_orig) != 0) {
|
2007-08-25 10:26:41 -04:00
|
|
|
continue;
|
2007-02-17 03:55:05 -05:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
char *backup = NULL;
|
2007-07-25 17:49:32 -04:00
|
|
|
/* length is tab char, null byte and MD5 (32 char) */
|
2008-04-14 19:24:45 -04:00
|
|
|
size_t backup_len = strlen(oldbackup) + 34;
|
2008-04-08 19:54:25 -04:00
|
|
|
MALLOC(backup, backup_len, RET_ERR(PM_ERR_MEMORY, -1));
|
2005-03-26 03:50:27 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
sprintf(backup, "%s\t%s", oldbackup, hash_pkg);
|
|
|
|
backup[backup_len-1] = '\0';
|
|
|
|
FREE(oldbackup);
|
|
|
|
backups->data = backup;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2008-05-04 21:51:04 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "checking hashes for %s\n", entryname_orig);
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "current: %s\n", hash_local);
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "new: %s\n", hash_pkg);
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "original: %s\n", hash_orig);
|
2005-03-26 03:50:27 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(!oldpkg) {
|
|
|
|
if(strcmp(hash_local, hash_pkg) != 0) {
|
2009-07-20 11:23:19 -04:00
|
|
|
/* looks like we have a local file that has a different hash as the
|
|
|
|
* file in the package, move it to a .pacorig */
|
2007-07-15 21:36:46 -04:00
|
|
|
char newpath[PATH_MAX];
|
|
|
|
snprintf(newpath, PATH_MAX, "%s.pacorig", filename);
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* move the existing file to the "pacorig" */
|
|
|
|
if(rename(filename, newpath)) {
|
2008-04-28 23:19:56 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
|
|
|
|
filename, newpath, strerror(errno));
|
|
|
|
alpm_logaction("error: could not rename %s to %s (%s)\n",
|
|
|
|
filename, newpath, strerror(errno));
|
2007-07-15 21:36:46 -04:00
|
|
|
errors++;
|
|
|
|
} else {
|
2008-04-28 23:19:56 -04:00
|
|
|
/* rename the file we extracted to the real name */
|
|
|
|
if(rename(checkfile, filename)) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
|
|
|
|
checkfile, filename, strerror(errno));
|
|
|
|
alpm_logaction("error: could not rename %s to %s (%s)\n",
|
|
|
|
checkfile, filename, strerror(errno));
|
2007-07-15 21:36:46 -04:00
|
|
|
errors++;
|
|
|
|
} else {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_WARNING, _("%s saved as %s\n"), filename, newpath);
|
2007-11-04 14:53:34 -05:00
|
|
|
alpm_logaction("warning: %s saved as %s\n", filename, newpath);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
}
|
2009-07-20 11:23:19 -04:00
|
|
|
} else {
|
|
|
|
/* local file is identical to pkg one, so just remove pkg one */
|
|
|
|
unlink(checkfile);
|
2007-02-17 03:55:05 -05:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
} else if(hash_orig) {
|
|
|
|
/* the fun part */
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(strcmp(hash_orig, hash_local) == 0) {
|
|
|
|
/* installed file has NOT been changed by user */
|
|
|
|
if(strcmp(hash_orig, hash_pkg) != 0) {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "action: installing new file: %s\n",
|
2008-05-04 21:51:04 -04:00
|
|
|
entryname_orig);
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2008-04-28 23:19:56 -04:00
|
|
|
if(rename(checkfile, filename)) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
|
|
|
|
checkfile, filename, strerror(errno));
|
|
|
|
alpm_logaction("error: could not rename %s to %s (%s)\n",
|
|
|
|
checkfile, filename, strerror(errno));
|
2007-07-15 21:36:46 -04:00
|
|
|
errors++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* there's no sense in installing the same file twice, install
|
|
|
|
* ONLY is the original and package hashes differ */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
|
2008-04-28 23:19:56 -04:00
|
|
|
unlink(checkfile);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
} else if(strcmp(hash_orig, hash_pkg) == 0) {
|
|
|
|
/* originally installed file and new file are the same - this
|
|
|
|
* implies the case above failed - i.e. the file was changed by a
|
|
|
|
* user */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
|
2008-04-28 23:19:56 -04:00
|
|
|
unlink(checkfile);
|
2007-07-15 21:36:46 -04:00
|
|
|
} else if(strcmp(hash_local, hash_pkg) == 0) {
|
|
|
|
/* this would be magical. The above two cases failed, but the
|
|
|
|
* user changes just so happened to make the new file exactly the
|
|
|
|
* same as the one in the package... skip it */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place\n");
|
2008-04-28 23:19:56 -04:00
|
|
|
unlink(checkfile);
|
2007-07-15 21:36:46 -04:00
|
|
|
} else {
|
|
|
|
char newpath[PATH_MAX];
|
2008-05-04 21:51:04 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "action: keeping current file and installing"
|
|
|
|
" new one with .pacnew ending\n");
|
2007-07-15 21:36:46 -04:00
|
|
|
snprintf(newpath, PATH_MAX, "%s.pacnew", filename);
|
2008-04-28 23:19:56 -04:00
|
|
|
if(rename(checkfile, newpath)) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not install %s as %s (%s)\n"),
|
|
|
|
filename, newpath, strerror(errno));
|
|
|
|
alpm_logaction("error: could not install %s as %s (%s)\n",
|
|
|
|
filename, newpath, strerror(errno));
|
2007-07-15 21:36:46 -04:00
|
|
|
} else {
|
2008-04-28 23:19:56 -04:00
|
|
|
_alpm_log(PM_LOG_WARNING, _("%s installed as %s\n"),
|
|
|
|
filename, newpath);
|
|
|
|
alpm_logaction("warning: %s installed as %s\n",
|
|
|
|
filename, newpath);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
FREE(hash_local);
|
|
|
|
FREE(hash_pkg);
|
|
|
|
FREE(hash_orig);
|
|
|
|
} else {
|
2008-04-28 23:19:56 -04:00
|
|
|
int ret;
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* we didn't need a backup */
|
|
|
|
if(notouch) {
|
|
|
|
/* change the path to a .pacnew extension */
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "%s is in NoUpgrade -- skipping\n", filename);
|
|
|
|
_alpm_log(PM_LOG_WARNING, _("extracting %s as %s.pacnew\n"), filename, filename);
|
2007-11-04 14:53:34 -05:00
|
|
|
alpm_logaction("warning: extracting %s as %s.pacnew\n", filename, filename);
|
2007-07-15 21:36:46 -04:00
|
|
|
strncat(filename, ".pacnew", PATH_MAX - strlen(filename));
|
|
|
|
} else {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "extracting %s\n", filename);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2007-04-26 19:57:09 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(trans->flags & PM_TRANS_FLAG_FORCE) {
|
|
|
|
/* if FORCE was used, unlink() each file (whether it's there
|
|
|
|
* or not) before extracting. This prevents the old "Text file busy"
|
|
|
|
* error that crops up if forcing a glibc or pacman upgrade. */
|
|
|
|
unlink(filename);
|
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2008-10-31 23:43:55 -04:00
|
|
|
ret = perform_extraction(archive, entry, filename, entryname_orig);
|
|
|
|
if(ret == 1) {
|
|
|
|
/* error */
|
2008-05-04 21:51:04 -04:00
|
|
|
FREE(entryname_orig);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 1;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* calculate an hash if this is in newpkg's backup */
|
|
|
|
alpm_list_t *b;
|
|
|
|
for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
|
|
|
|
char *backup = NULL, *hash = NULL;
|
|
|
|
char *oldbackup = alpm_list_getdata(b);
|
2007-07-25 17:49:32 -04:00
|
|
|
/* length is tab char, null byte and MD5 (32 char) */
|
2008-04-14 19:24:45 -04:00
|
|
|
size_t backup_len = strlen(oldbackup) + 34;
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2008-05-04 21:51:04 -04:00
|
|
|
if(!oldbackup || strcmp(oldbackup, entryname_orig) != 0) {
|
2007-09-18 14:46:41 -04:00
|
|
|
continue;
|
2007-02-10 18:44:39 -05:00
|
|
|
}
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "appending backup entry for %s\n", filename);
|
2006-09-28 16:51:33 -04:00
|
|
|
|
2008-08-26 06:57:08 -04:00
|
|
|
hash = alpm_compute_md5sum(filename);
|
2008-04-08 19:54:25 -04:00
|
|
|
MALLOC(backup, backup_len, RET_ERR(PM_ERR_MEMORY, -1));
|
2006-10-15 15:31:03 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
sprintf(backup, "%s\t%s", oldbackup, hash);
|
|
|
|
backup[backup_len-1] = '\0';
|
|
|
|
FREE(hash);
|
|
|
|
FREE(oldbackup);
|
|
|
|
b->data = backup;
|
|
|
|
}
|
|
|
|
}
|
2008-05-04 21:51:04 -04:00
|
|
|
FREE(entryname_orig);
|
2011-03-20 20:45:57 -04:00
|
|
|
return errors;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2011-01-09 21:36:42 -05:00
|
|
|
static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
|
|
|
|
size_t pkg_count, pmtrans_t *trans, pmdb_t *db)
|
2007-07-15 21:36:46 -04:00
|
|
|
{
|
|
|
|
int i, ret = 0, errors = 0;
|
|
|
|
char scriptlet[PATH_MAX+1];
|
|
|
|
int is_upgrade = 0;
|
|
|
|
pmpkg_t *oldpkg = NULL;
|
|
|
|
|
2008-04-08 23:14:21 -04:00
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
|
2009-12-04 19:50:09 -05:00
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
|
2009-09-14 23:44:51 -04:00
|
|
|
snprintf(scriptlet, PATH_MAX, "%s%s-%s/install",
|
|
|
|
_alpm_db_path(db), alpm_pkg_get_name(newpkg),
|
|
|
|
alpm_pkg_get_version(newpkg));
|
2007-07-15 21:36:46 -04:00
|
|
|
|
|
|
|
/* see if this is an upgrade. if so, remove the old package first */
|
|
|
|
pmpkg_t *local = _alpm_db_get_pkgfromcache(db, newpkg->name);
|
|
|
|
if(local) {
|
|
|
|
is_upgrade = 1;
|
|
|
|
|
|
|
|
/* we'll need to save some record for backup checks later */
|
|
|
|
oldpkg = _alpm_pkg_dup(local);
|
2008-08-18 19:02:40 -04:00
|
|
|
/* make sure all infos are loaded because the database entry
|
|
|
|
* will be removed soon */
|
2010-10-09 06:16:15 -04:00
|
|
|
_alpm_local_db_read(oldpkg->origin_data.db, oldpkg, INFRQ_ALL);
|
2008-07-30 17:36:46 -04:00
|
|
|
|
|
|
|
EVENT(trans, PM_TRANS_EVT_UPGRADE_START, newpkg, oldpkg);
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "upgrading package %s-%s\n",
|
|
|
|
newpkg->name, newpkg->version);
|
|
|
|
|
2008-01-13 16:15:10 -05:00
|
|
|
/* copy over the install reason */
|
2008-07-30 17:36:46 -04:00
|
|
|
newpkg->reason = alpm_pkg_get_reason(oldpkg);
|
2005-10-07 19:29:49 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* pre_upgrade scriptlet */
|
|
|
|
if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
|
2007-08-14 10:14:35 -04:00
|
|
|
_alpm_runscriptlet(handle->root, newpkg->origin_data.file,
|
2007-11-04 10:47:21 -05:00
|
|
|
"pre_upgrade", newpkg->version, oldpkg->version, trans);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
is_upgrade = 0;
|
2007-02-19 21:14:27 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
EVENT(trans, PM_TRANS_EVT_ADD_START, newpkg, NULL);
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "adding package %s-%s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name, newpkg->version);
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* pre_install scriptlet */
|
|
|
|
if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
|
2007-08-14 10:14:35 -04:00
|
|
|
_alpm_runscriptlet(handle->root, newpkg->origin_data.file,
|
2007-11-04 10:47:21 -05:00
|
|
|
"pre_install", newpkg->version, NULL, trans);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
}
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2008-01-13 16:15:10 -05:00
|
|
|
/* we override any pre-set reason if we have alldeps or allexplicit set */
|
|
|
|
if(trans->flags & PM_TRANS_FLAG_ALLDEPS) {
|
|
|
|
newpkg->reason = PM_PKG_REASON_DEPEND;
|
|
|
|
} else if(trans->flags & PM_TRANS_FLAG_ALLEXPLICIT) {
|
|
|
|
newpkg->reason = PM_PKG_REASON_EXPLICIT;
|
|
|
|
}
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(oldpkg) {
|
|
|
|
/* set up fake remove transaction */
|
2009-07-15 13:14:01 -04:00
|
|
|
if(_alpm_upgraderemove_package(oldpkg, newpkg, trans) == -1) {
|
|
|
|
pm_errno = PM_ERR_TRANS_ABORT;
|
|
|
|
ret = -1;
|
2008-07-15 07:30:34 -04:00
|
|
|
goto cleanup;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2009-01-02 04:12:22 -05:00
|
|
|
/* prepare directory for database entries so permission are correct after
|
|
|
|
changelog/install script installation (FS#12263) */
|
2010-10-13 04:04:07 -04:00
|
|
|
if(_alpm_local_db_prepare(db, newpkg)) {
|
2009-01-02 04:12:22 -05:00
|
|
|
alpm_logaction("error: could not create database entry %s-%s\n",
|
|
|
|
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
|
|
|
|
pm_errno = PM_ERR_DB_WRITE;
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
|
2008-04-08 23:14:21 -04:00
|
|
|
struct archive *archive;
|
|
|
|
struct archive_entry *entry;
|
|
|
|
char cwd[PATH_MAX] = "";
|
2010-06-27 06:32:11 -04:00
|
|
|
int restore_cwd = 0;
|
2008-04-08 23:14:21 -04:00
|
|
|
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "extracting files\n");
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if ((archive = archive_read_new()) == NULL) {
|
2008-07-15 07:30:34 -04:00
|
|
|
pm_errno = PM_ERR_LIBARCHIVE;
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
archive_read_support_compression_all(archive);
|
|
|
|
archive_read_support_format_all(archive);
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2008-04-08 23:14:21 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "archive: %s\n", newpkg->origin_data.file);
|
2007-08-14 10:14:35 -04:00
|
|
|
if(archive_read_open_filename(archive, newpkg->origin_data.file,
|
|
|
|
ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
|
2008-07-15 07:30:34 -04:00
|
|
|
pm_errno = PM_ERR_PKG_OPEN;
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* save the cwd so we can restore it later */
|
|
|
|
if(getcwd(cwd, PATH_MAX) == NULL) {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not get current working directory\n"));
|
2010-06-27 06:32:11 -04:00
|
|
|
} else {
|
|
|
|
restore_cwd = 1;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* libarchive requires this for extracting hard links */
|
2010-06-27 06:32:11 -04:00
|
|
|
if(chdir(handle->root) != 0) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), handle->root, strerror(errno));
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* call PROGRESS once with 0 percent, as we sort-of skip that here */
|
|
|
|
if(is_upgrade) {
|
|
|
|
PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
|
|
|
|
alpm_pkg_get_name(newpkg), 0, pkg_count, pkg_current);
|
|
|
|
} else {
|
|
|
|
PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
|
|
|
|
alpm_pkg_get_name(newpkg), 0, pkg_count, pkg_current);
|
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
for(i = 0; archive_read_next_header(archive, &entry) == ARCHIVE_OK; i++) {
|
2011-01-09 21:36:42 -05:00
|
|
|
int percent;
|
2008-06-01 22:47:31 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(newpkg->size != 0) {
|
|
|
|
/* Using compressed size for calculations here, as newpkg->isize is not
|
|
|
|
* exact when it comes to comparing to the ACTUAL uncompressed size
|
|
|
|
* (missing metadata sizes) */
|
2008-06-01 22:47:31 -04:00
|
|
|
int64_t pos = archive_position_compressed(archive);
|
2011-01-09 21:36:42 -05:00
|
|
|
percent = (pos * 100) / newpkg->size;
|
2008-06-01 22:47:31 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "decompression progress: "
|
2011-01-09 21:36:42 -05:00
|
|
|
"%d%% (%"PRId64" / %jd)\n",
|
|
|
|
percent, pos, (intmax_t)newpkg->size);
|
|
|
|
if(percent >= 100) {
|
|
|
|
percent = 100;
|
2005-05-04 17:06:03 -04:00
|
|
|
}
|
2008-06-01 22:47:31 -04:00
|
|
|
} else {
|
2011-01-09 21:36:42 -05:00
|
|
|
percent = 0;
|
2005-05-04 17:06:03 -04:00
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(is_upgrade) {
|
|
|
|
PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
|
2011-01-09 21:36:42 -05:00
|
|
|
alpm_pkg_get_name(newpkg), percent, pkg_count,
|
2007-07-15 21:36:46 -04:00
|
|
|
pkg_current);
|
|
|
|
} else {
|
|
|
|
PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
|
2011-01-09 21:36:42 -05:00
|
|
|
alpm_pkg_get_name(newpkg), percent, pkg_count,
|
2007-07-15 21:36:46 -04:00
|
|
|
pkg_current);
|
2006-10-15 15:31:03 -04:00
|
|
|
}
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* extract the next file from the archive */
|
|
|
|
errors += extract_single_file(archive, entry, newpkg, oldpkg,
|
|
|
|
trans, db);
|
2005-05-04 17:06:03 -04:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
archive_read_finish(archive);
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2010-06-27 06:32:11 -04:00
|
|
|
/* restore the old cwd if we have it */
|
|
|
|
if(restore_cwd && chdir(cwd) != 0) {
|
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
|
2007-03-01 02:03:05 -05:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
|
|
|
|
if(errors) {
|
2008-07-15 07:30:34 -04:00
|
|
|
ret = -1;
|
2007-07-15 21:36:46 -04:00
|
|
|
if(is_upgrade) {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
2007-11-04 14:53:34 -05:00
|
|
|
alpm_logaction("error: problem occurred while upgrading %s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
|
|
|
} else {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("problem occurred while installing %s\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
2007-11-04 14:53:34 -05:00
|
|
|
alpm_logaction("error: problem occurred while installing %s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* make an install date (in UTC) */
|
2007-09-19 01:21:56 -04:00
|
|
|
newpkg->installdate = time(NULL);
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_DEBUG, "updating database\n");
|
|
|
|
_alpm_log(PM_LOG_DEBUG, "adding database entry '%s'\n", newpkg->name);
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2010-10-13 04:04:07 -04:00
|
|
|
if(_alpm_local_db_write(db, newpkg, INFRQ_ALL)) {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not update database entry %s-%s\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
|
2007-11-04 14:53:34 -05:00
|
|
|
alpm_logaction("error: could not update database entry %s-%s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
|
2008-07-15 07:30:34 -04:00
|
|
|
pm_errno = PM_ERR_DB_WRITE;
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if(_alpm_db_add_pkgincache(db, newpkg) == -1) {
|
2007-08-23 22:26:55 -04:00
|
|
|
_alpm_log(PM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
alpm_pkg_get_name(newpkg));
|
|
|
|
}
|
|
|
|
|
|
|
|
if(is_upgrade) {
|
|
|
|
PROGRESS(trans, PM_TRANS_PROGRESS_UPGRADE_START,
|
|
|
|
alpm_pkg_get_name(newpkg), 100, pkg_count, pkg_current);
|
|
|
|
} else {
|
|
|
|
PROGRESS(trans, PM_TRANS_PROGRESS_ADD_START,
|
|
|
|
alpm_pkg_get_name(newpkg), 100, pkg_count, pkg_current);
|
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* run the post-install script if it exists */
|
|
|
|
if(alpm_pkg_has_scriptlet(newpkg)
|
|
|
|
&& !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
|
2007-07-14 09:34:39 -04:00
|
|
|
if(is_upgrade) {
|
2007-07-15 21:36:46 -04:00
|
|
|
_alpm_runscriptlet(handle->root, scriptlet, "post_upgrade",
|
|
|
|
alpm_pkg_get_version(newpkg),
|
2007-11-04 10:47:21 -05:00
|
|
|
oldpkg ? alpm_pkg_get_version(oldpkg) : NULL, trans);
|
2007-07-14 09:34:39 -04:00
|
|
|
} else {
|
2007-07-15 21:36:46 -04:00
|
|
|
_alpm_runscriptlet(handle->root, scriptlet, "post_install",
|
2007-11-04 10:47:21 -05:00
|
|
|
alpm_pkg_get_version(newpkg), NULL, trans);
|
2007-07-14 09:34:39 -04:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2006-10-15 15:31:03 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(is_upgrade) {
|
|
|
|
EVENT(trans, PM_TRANS_EVT_UPGRADE_DONE, newpkg, oldpkg);
|
|
|
|
} else {
|
|
|
|
EVENT(trans, PM_TRANS_EVT_ADD_DONE, newpkg, oldpkg);
|
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2008-07-15 07:30:34 -04:00
|
|
|
cleanup:
|
2007-07-15 21:36:46 -04:00
|
|
|
_alpm_pkg_free(oldpkg);
|
2011-03-20 20:45:57 -04:00
|
|
|
return ret;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
|
Use sync.c for upgrade transaction prepare and commit
This patch utilizes the power of sync.c to fix FS#3492 and FS#5798.
Now an upgrade transaction is just a sync transaction internally (in alpm),
so all sync features are available with -U as well:
* conflict resolving
* sync dependencies from sync repos
* remove unresolvable targets
See http://www.archlinux.org/pipermail/pacman-dev/2009-June/008725.html
for the concept.
We use "mixed" target list, where PKG_FROM_FILE origin indicates local
package file, PKG_FROM_CACHE indicates sync package. The front-end can add
only one type of packages (depending on transaction type) atm, but if alpm
resolves dependencies for -U, we may get a real mixed trans->packages list.
_alpm_pkg_free_trans() was modified so that it can handle both target types
_alpm_add_prepare() was removed, we use _alpm_sync_prepare() instead
_alpm_add_commit() was renamed to _alpm_upgrade_targets()
sync.c (and deps.c) was modified slightly to handle mixed target lists,
the modifications are straightforward. There is one notable change here: We
don't create new upgrade trans in sync.c, we replace the pkgcache entries
with the loaded package files in the target list (this is a bit hackish) and
call _alpm_upgrade_targets(). This implies a TODO (pkg->origin_data.db is
not accessible anymore), but it doesn't hurt anything with pacman front-end,
so it will be fixed later (otherwise this patch would be huge).
I updated the documentation of -U and I added a new pactest, upgrade090.py,
to test the syncdeps feature of -U.
Signed-off-by: Nagy Gabor <ngaba@bibl.u-szeged.hu>
Signed-off-by: Dan McGee <dan@archlinux.org>
2009-06-09 11:23:46 -04:00
|
|
|
int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
|
2007-07-15 21:36:46 -04:00
|
|
|
{
|
2010-12-08 00:13:36 -05:00
|
|
|
size_t pkg_count, pkg_current;
|
2008-10-31 23:43:55 -04:00
|
|
|
int skip_ldconfig = 0, ret = 0;
|
2007-07-15 21:36:46 -04:00
|
|
|
alpm_list_t *targ;
|
|
|
|
|
|
|
|
ALPM_LOG_FUNC;
|
|
|
|
|
|
|
|
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
|
|
|
|
ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
|
|
|
|
|
2009-07-15 13:14:01 -04:00
|
|
|
if(trans->add == NULL) {
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
|
2009-07-15 13:14:01 -04:00
|
|
|
pkg_count = alpm_list_count(trans->add);
|
2007-07-15 21:36:46 -04:00
|
|
|
pkg_current = 1;
|
|
|
|
|
|
|
|
/* loop through our package list adding/upgrading one at a time */
|
2009-07-15 13:14:01 -04:00
|
|
|
for(targ = trans->add; targ; targ = targ->next) {
|
2007-07-15 21:36:46 -04:00
|
|
|
if(handle->trans->state == STATE_INTERRUPTED) {
|
2011-03-20 20:45:57 -04:00
|
|
|
return ret;
|
2007-07-14 09:34:39 -04:00
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
pmpkg_t *newpkg = (pmpkg_t *)targ->data;
|
2008-10-31 23:43:55 -04:00
|
|
|
if(commit_single_pkg(newpkg, pkg_current, pkg_count, trans, db)) {
|
|
|
|
/* something screwed up on the commit, abort the trans */
|
|
|
|
trans->state = STATE_INTERRUPTED;
|
|
|
|
pm_errno = PM_ERR_TRANS_ABORT;
|
|
|
|
/* running ldconfig at this point could possibly screw system */
|
|
|
|
skip_ldconfig = 1;
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
pkg_current++;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
2008-10-31 23:43:55 -04:00
|
|
|
if(!skip_ldconfig) {
|
|
|
|
/* run ldconfig if it exists */
|
|
|
|
_alpm_ldconfig(handle->root);
|
|
|
|
}
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2011-03-20 20:45:57 -04:00
|
|
|
return ret;
|
2005-03-14 20:51:43 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* vim: set ts=2 sw=2 noet: */
|