2005-03-14 20:51:43 -05:00
|
|
|
/*
|
|
|
|
* add.c
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2015-01-21 01:31:20 -05:00
|
|
|
* Copyright (c) 2006-2015 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 <stdlib.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
2006-03-02 14:06:52 -05:00
|
|
|
#include <limits.h>
|
2011-09-19 15:08:14 -04:00
|
|
|
#include <fcntl.h>
|
2007-07-15 21:36:46 -04:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2012-01-06 17:09:19 -05:00
|
|
|
#include <stdint.h> /* int64_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"
|
2011-06-07 17:06:16 -04:00
|
|
|
#include "alpm.h"
|
2007-01-19 04:28:44 -05:00
|
|
|
#include "alpm_list.h"
|
2011-06-07 17:06:16 -04:00
|
|
|
#include "handle.h"
|
2013-01-28 20:23:25 -05:00
|
|
|
#include "libarchive-compat.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"
|
|
|
|
#include "remove.h"
|
|
|
|
#include "handle.h"
|
|
|
|
|
2011-04-17 03:45:52 -04:00
|
|
|
/** Add a package to the transaction. */
|
2011-06-28 09:26:39 -04:00
|
|
|
int SYMEXPORT alpm_add_pkg(alpm_handle_t *handle, alpm_pkg_t *pkg)
|
2010-10-16 18:57:37 -04:00
|
|
|
{
|
|
|
|
const char *pkgname, *pkgver;
|
2011-06-28 09:27:16 -04:00
|
|
|
alpm_trans_t *trans;
|
2011-06-28 09:26:39 -04:00
|
|
|
alpm_pkg_t *local;
|
2010-10-16 18:57:37 -04:00
|
|
|
|
|
|
|
/* Sanity checks */
|
2011-06-14 11:01:08 -04:00
|
|
|
CHECK_HANDLE(handle, return -1);
|
2011-07-01 12:01:39 -04:00
|
|
|
ASSERT(pkg != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
|
2014-02-07 13:04:58 -05:00
|
|
|
ASSERT(pkg->origin != ALPM_PKG_FROM_LOCALDB,
|
|
|
|
RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
|
2011-07-01 12:01:39 -04:00
|
|
|
ASSERT(handle == pkg->handle, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
|
2011-06-09 17:00:55 -04:00
|
|
|
trans = handle->trans;
|
2011-07-01 12:01:39 -04:00
|
|
|
ASSERT(trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
|
2011-06-09 17:00:55 -04:00
|
|
|
ASSERT(trans->state == STATE_INITIALIZED,
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
|
2010-10-16 18:57:37 -04:00
|
|
|
|
2011-04-21 23:09:57 -04:00
|
|
|
pkgname = pkg->name;
|
|
|
|
pkgver = pkg->version;
|
2010-10-16 18:57:37 -04:00
|
|
|
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "adding package '%s'\n", pkgname);
|
2010-10-16 18:57:37 -04:00
|
|
|
|
2012-08-12 06:48:53 -04:00
|
|
|
if(alpm_pkg_find(trans->add, pkgname)) {
|
2011-07-01 12:01:39 -04:00
|
|
|
RET_ERR(handle, ALPM_ERR_TRANS_DUP_TARGET, -1);
|
2010-10-16 18:57:37 -04:00
|
|
|
}
|
|
|
|
|
2011-06-09 17:00:55 -04:00
|
|
|
local = _alpm_db_get_pkgfromcache(handle->db_local, pkgname);
|
2010-10-16 18:57:37 -04:00
|
|
|
if(local) {
|
2011-08-18 00:25:19 -04:00
|
|
|
const char *localpkgname = local->name;
|
|
|
|
const char *localpkgver = local->version;
|
2010-10-16 18:57:37 -04:00
|
|
|
int cmp = _alpm_pkg_compare_versions(pkg, local);
|
|
|
|
|
|
|
|
if(cmp == 0) {
|
2011-07-01 12:01:39 -04:00
|
|
|
if(trans->flags & ALPM_TRANS_FLAG_NEEDED) {
|
2010-10-16 18:57:37 -04:00
|
|
|
/* with the NEEDED flag, packages up to date are not reinstalled */
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
|
2010-10-16 18:57:37 -04:00
|
|
|
localpkgname, localpkgver);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2011-07-01 12:01:39 -04:00
|
|
|
} else if(!(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY)) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
|
2010-10-16 18:57:37 -04:00
|
|
|
localpkgname, localpkgver);
|
|
|
|
}
|
|
|
|
} else if(cmp < 0) {
|
|
|
|
/* local version is newer */
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING, _("downgrading package %s (%s => %s)\n"),
|
2010-10-16 18:57:37 -04:00
|
|
|
localpkgname, localpkgver, pkgver);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add the package to the transaction */
|
2011-07-01 12:01:38 -04:00
|
|
|
pkg->reason = ALPM_PKG_REASON_EXPLICIT;
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "adding package %s-%s to the transaction add list\n",
|
2010-10-16 18:57:37 -04:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2011-06-28 00:04:00 -04:00
|
|
|
static int perform_extraction(alpm_handle_t *handle, struct archive *archive,
|
2014-10-01 01:45:40 -04:00
|
|
|
struct archive_entry *entry, const char *filename)
|
2008-10-31 23:43:55 -04:00
|
|
|
{
|
|
|
|
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 */
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING, _("warning given when extracting %s (%s)\n"),
|
2014-10-01 01:45:40 -04:00
|
|
|
filename, archive_error_string(archive));
|
2008-10-31 23:43:55 -04:00
|
|
|
} else if(ret != ARCHIVE_OK) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("could not extract %s (%s)\n"),
|
2014-10-01 01:45:40 -04:00
|
|
|
filename, archive_error_string(archive));
|
2013-01-18 20:42:21 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"error: could not extract %s (%s)\n",
|
2014-10-01 01:45:40 -04:00
|
|
|
filename, 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
|
|
|
}
|
|
|
|
|
2011-09-30 12:38:36 -04:00
|
|
|
static int try_rename(alpm_handle_t *handle, const char *src, const char *dest)
|
|
|
|
{
|
|
|
|
if(rename(src, dest)) {
|
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("could not rename %s to %s (%s)\n"),
|
|
|
|
src, dest, strerror(errno));
|
2013-01-18 20:42:21 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"error: could not rename %s to %s (%s)\n", src, dest, strerror(errno));
|
2011-09-30 12:38:36 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-10-01 01:35:31 -04:00
|
|
|
static int extract_db_file(alpm_handle_t *handle, struct archive *archive,
|
|
|
|
struct archive_entry *entry, alpm_pkg_t *newpkg, const char *entryname)
|
|
|
|
{
|
|
|
|
char filename[PATH_MAX]; /* the actual file we're extracting */
|
2015-04-23 02:01:16 -04:00
|
|
|
const char *dbfile = NULL;
|
2014-10-01 01:35:31 -04:00
|
|
|
if(strcmp(entryname, ".INSTALL") == 0) {
|
|
|
|
dbfile = "install";
|
|
|
|
} else if(strcmp(entryname, ".CHANGELOG") == 0) {
|
|
|
|
dbfile = "changelog";
|
|
|
|
} else if(strcmp(entryname, ".MTREE") == 0) {
|
|
|
|
dbfile = "mtree";
|
|
|
|
} else if(*entryname == '.') {
|
|
|
|
/* reserve all files starting with '.' for future possibilities */
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
|
|
|
|
archive_read_data_skip(archive);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
archive_entry_set_perm(entry, 0644);
|
|
|
|
snprintf(filename, PATH_MAX, "%s%s-%s/%s",
|
|
|
|
_alpm_db_path(handle->db_local), newpkg->name, newpkg->version, dbfile);
|
2014-10-01 01:45:40 -04:00
|
|
|
return perform_extraction(handle, archive, entry, filename);
|
2014-10-01 01:35:31 -04:00
|
|
|
}
|
|
|
|
|
2011-06-28 00:04:00 -04:00
|
|
|
static int extract_single_file(alpm_handle_t *handle, struct archive *archive,
|
2011-06-28 09:26:39 -04:00
|
|
|
struct archive_entry *entry, alpm_pkg_t *newpkg, alpm_pkg_t *oldpkg)
|
2005-03-14 20:51:43 -05:00
|
|
|
{
|
2014-10-01 01:14:57 -04:00
|
|
|
const char *entryname = archive_entry_pathname(entry);
|
|
|
|
mode_t entrymode = archive_entry_mode(entry);
|
|
|
|
alpm_backup_t *backup = _alpm_needbackup(entryname, newpkg);
|
2007-07-15 21:36:46 -04:00
|
|
|
char filename[PATH_MAX]; /* the actual file we're extracting */
|
|
|
|
int needbackup = 0, notouch = 0;
|
2011-06-16 14:15:11 -04:00
|
|
|
const char *hash_orig = NULL;
|
2007-07-15 21:36:46 -04:00
|
|
|
int errors = 0;
|
2014-10-01 01:14:57 -04:00
|
|
|
struct stat lsbuf;
|
2014-10-01 02:26:14 -04:00
|
|
|
size_t filename_len;
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2014-10-01 01:35:31 -04:00
|
|
|
if(*entryname == '.') {
|
|
|
|
return extract_db_file(handle, archive, entry, newpkg, entryname);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!alpm_filelist_contains(&newpkg->files, entryname)) {
|
2014-10-01 01:45:40 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING,
|
|
|
|
_("file not found in file list for package %s. skipping extraction of %s\n"),
|
2014-10-01 01:35:31 -04:00
|
|
|
newpkg->name, entryname);
|
2011-03-20 20:45:57 -04:00
|
|
|
return 0;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2014-10-01 01:45:40 -04:00
|
|
|
|
2014-10-01 01:35:31 -04:00
|
|
|
/* build the new entryname relative to handle->root */
|
2014-10-01 02:26:14 -04:00
|
|
|
filename_len = snprintf(filename, PATH_MAX, "%s%s", handle->root, entryname);
|
|
|
|
if(filename_len >= PATH_MAX) {
|
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR,
|
|
|
|
_("unable to extract %s%s: path too long"), handle->root, entryname);
|
|
|
|
return 1;
|
|
|
|
}
|
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 */
|
2013-06-18 11:44:15 -04:00
|
|
|
if(_alpm_fnmatch_patterns(handle->noextract, entryname) == 0) {
|
2013-02-15 22:59:57 -05:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "%s is in NoExtract,"
|
|
|
|
" skipping extraction of %s\n",
|
|
|
|
entryname, filename);
|
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
|
|
|
}
|
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)
|
2013-03-10 15:34:52 -04:00
|
|
|
* | F/N | D
|
|
|
|
* non-existent | 1 | 2
|
|
|
|
* F/N | 3 | 4
|
|
|
|
* D | 5 | 6
|
2007-07-15 21:36:46 -04:00
|
|
|
*
|
2014-06-26 11:50:34 -04:00
|
|
|
* 1,2- extract, no magic necessary. lstat (llstat) will fail here.
|
2013-03-10 15:34:52 -04:00
|
|
|
* 3,4- conflict checks should have caught this. either overwrite
|
2007-07-15 21:36:46 -04:00
|
|
|
* or backup the file.
|
2013-03-10 15:34:52 -04:00
|
|
|
* 5- file replacing directory- don't allow it.
|
|
|
|
* 6- skip extraction, dir already exists.
|
2007-07-15 21:36:46 -04:00
|
|
|
*/
|
2008-02-07 08:58:23 -05:00
|
|
|
|
2014-06-26 11:50:34 -04:00
|
|
|
if(llstat(filename, &lsbuf) != 0) {
|
2013-03-10 15:34:52 -04:00
|
|
|
/* cases 1,2: file doesn't exist, skip all backup checks */
|
2014-10-01 01:26:33 -04:00
|
|
|
} else if(S_ISDIR(lsbuf.st_mode) && S_ISDIR(entrymode)) {
|
2015-02-03 23:48:31 -05:00
|
|
|
#if 0
|
2014-10-01 01:26:33 -04:00
|
|
|
uid_t entryuid = archive_entry_uid(entry);
|
|
|
|
gid_t entrygid = archive_entry_gid(entry);
|
2015-02-03 23:48:31 -05:00
|
|
|
#endif
|
2013-07-21 02:10:25 -04:00
|
|
|
|
2014-10-01 01:26:33 -04:00
|
|
|
/* case 6: existing dir, ignore it */
|
|
|
|
if(lsbuf.st_mode != entrymode) {
|
|
|
|
/* if filesystem perms are different than pkg perms, warn user */
|
|
|
|
mode_t mask = 07777;
|
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING, _("directory permissions differ on %s\n"
|
|
|
|
"filesystem: %o package: %o\n"), filename, lsbuf.st_mode & mask,
|
|
|
|
entrymode & mask);
|
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"warning: directory permissions differ on %s\n"
|
|
|
|
"filesystem: %o package: %o\n", filename, lsbuf.st_mode & mask,
|
|
|
|
entrymode & mask);
|
|
|
|
}
|
2013-07-21 02:10:25 -04:00
|
|
|
|
2015-02-03 23:48:31 -05:00
|
|
|
#if 0
|
2015-02-11 22:33:20 -05:00
|
|
|
/* Disable this warning until our user management in packages has improved.
|
|
|
|
Currently many packages have to create users in post_install and chown the
|
|
|
|
directories. These all resulted in "false-positive" warnings. */
|
|
|
|
|
2014-10-01 01:26:33 -04:00
|
|
|
if((entryuid != lsbuf.st_uid) || (entrygid != lsbuf.st_gid)) {
|
|
|
|
_alpm_log(handle, ALPM_LOG_WARNING, _("directory ownership differs on %s\n"
|
|
|
|
"filesystem: %u:%u package: %u:%u\n"), filename,
|
|
|
|
lsbuf.st_uid, lsbuf.st_gid, entryuid, entrygid);
|
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"warning: directory ownership differs on %s\n"
|
|
|
|
"filesystem: %u:%u package: %u:%u\n", filename,
|
|
|
|
lsbuf.st_uid, lsbuf.st_gid, entryuid, entrygid);
|
|
|
|
}
|
2015-02-03 23:48:31 -05:00
|
|
|
#endif
|
2013-07-21 02:10:25 -04:00
|
|
|
|
2014-10-01 01:26:33 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
|
|
|
|
filename);
|
|
|
|
archive_read_data_skip(archive);
|
|
|
|
return 0;
|
|
|
|
} else if(S_ISDIR(lsbuf.st_mode)) {
|
|
|
|
/* case 5: trying to overwrite dir with file, don't allow it */
|
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
|
|
|
|
filename);
|
|
|
|
archive_read_data_skip(archive);
|
|
|
|
return 1;
|
|
|
|
} else if(S_ISDIR(entrymode)) {
|
|
|
|
/* case 4: trying to overwrite file with dir */
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "extract: overwriting file with dir %s\n",
|
|
|
|
filename);
|
|
|
|
} else {
|
|
|
|
/* case 3: trying to overwrite file with file */
|
|
|
|
/* if file is in NoUpgrade, don't touch it */
|
|
|
|
if(_alpm_fnmatch_patterns(handle->noupgrade, entryname) == 0) {
|
|
|
|
notouch = 1;
|
2013-03-10 15:34:52 -04:00
|
|
|
} else {
|
2014-10-01 01:26:33 -04:00
|
|
|
alpm_backup_t *oldbackup;
|
|
|
|
if(oldpkg && (oldbackup = _alpm_needbackup(entryname, oldpkg))) {
|
|
|
|
hash_orig = oldbackup->hash;
|
|
|
|
needbackup = 1;
|
|
|
|
} else if(backup) {
|
|
|
|
/* allow adding backup files retroactively */
|
|
|
|
needbackup = 1;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2006-07-14 19:15:07 -04:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2006-07-14 19:15:07 -04:00
|
|
|
|
2014-10-01 02:26:14 -04:00
|
|
|
if(notouch || needbackup) {
|
|
|
|
if(filename_len + strlen(".pacnew") >= PATH_MAX) {
|
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR,
|
|
|
|
_("unable to extract %s.pacnew: path too long"), filename);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
strcpy(filename + filename_len, ".pacnew");
|
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2014-10-01 02:26:14 -04:00
|
|
|
if(handle->trans->flags & ALPM_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);
|
|
|
|
}
|
2008-10-31 23:43:55 -04:00
|
|
|
|
2014-10-01 02:26:14 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "extracting %s\n", filename);
|
|
|
|
if(perform_extraction(handle, archive, entry, filename)) {
|
|
|
|
errors++;
|
|
|
|
return errors;
|
|
|
|
}
|
2005-03-26 15:24:57 -05:00
|
|
|
|
2014-10-01 02:26:14 -04:00
|
|
|
if(backup) {
|
|
|
|
FREE(backup->hash);
|
|
|
|
backup->hash = alpm_compute_md5sum(filename);
|
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
|
2014-10-01 02:26:14 -04:00
|
|
|
if(notouch) {
|
|
|
|
alpm_event_pacnew_created_t event = {
|
|
|
|
.type = ALPM_EVENT_PACNEW_CREATED,
|
|
|
|
.from_noupgrade = 1,
|
|
|
|
.oldpkg = oldpkg,
|
|
|
|
.newpkg = newpkg,
|
|
|
|
.file = filename
|
|
|
|
};
|
|
|
|
/* "remove" the .pacnew suffix */
|
|
|
|
filename[filename_len] = '\0';
|
|
|
|
EVENT(handle, &event);
|
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"warning: %s installed as %s.pacnew\n", filename, filename);
|
|
|
|
} else if(needbackup) {
|
|
|
|
char *hash_local = NULL, *hash_pkg = NULL;
|
|
|
|
char origfile[PATH_MAX] = "";
|
|
|
|
|
|
|
|
strncat(origfile, filename, filename_len);
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2014-10-01 02:26:14 -04:00
|
|
|
hash_local = alpm_compute_md5sum(origfile);
|
|
|
|
hash_pkg = backup ? backup->hash : alpm_compute_md5sum(filename);
|
|
|
|
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "checking hashes for %s\n", origfile);
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "current: %s\n", hash_local);
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "new: %s\n", hash_pkg);
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "original: %s\n", hash_orig);
|
2005-03-26 03:50:27 -05:00
|
|
|
|
2013-05-18 19:37:59 -04:00
|
|
|
if(hash_local && hash_pkg && strcmp(hash_local, hash_pkg) == 0) {
|
2013-06-04 05:20:14 -04:00
|
|
|
/* local and new files are the same, updating anyway to get
|
|
|
|
* correct timestamps */
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "action: installing new file: %s\n",
|
2014-10-01 02:26:14 -04:00
|
|
|
origfile);
|
|
|
|
if(try_rename(handle, filename, origfile)) {
|
2013-06-04 05:20:14 -04:00
|
|
|
errors++;
|
|
|
|
}
|
2013-05-18 19:37:59 -04:00
|
|
|
} else if(hash_orig && hash_pkg && strcmp(hash_orig, hash_pkg) == 0) {
|
|
|
|
/* original and new files are the same, leave the local version alone,
|
|
|
|
* including any user changes */
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG,
|
|
|
|
"action: leaving existing file in place\n");
|
2014-10-01 02:26:14 -04:00
|
|
|
unlink(filename);
|
2013-05-18 19:37:59 -04:00
|
|
|
} else if(hash_orig && hash_local && strcmp(hash_orig, hash_local) == 0) {
|
|
|
|
/* installed file has NOT been changed by user,
|
|
|
|
* update to the new version */
|
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "action: installing new file: %s\n",
|
2014-10-01 02:26:14 -04:00
|
|
|
origfile);
|
|
|
|
if(try_rename(handle, filename, origfile)) {
|
2013-05-18 19:37:59 -04:00
|
|
|
errors++;
|
|
|
|
}
|
|
|
|
} else {
|
2014-10-01 02:06:49 -04:00
|
|
|
/* none of the three files matched another, leave the unpacked
|
|
|
|
* file alongside the local file */
|
|
|
|
alpm_event_pacnew_created_t event = {
|
|
|
|
.type = ALPM_EVENT_PACNEW_CREATED,
|
|
|
|
.from_noupgrade = 0,
|
|
|
|
.oldpkg = oldpkg,
|
|
|
|
.newpkg = newpkg,
|
2014-10-01 02:26:14 -04:00
|
|
|
.file = origfile
|
2014-10-01 02:06:49 -04:00
|
|
|
};
|
2014-10-01 01:57:44 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG,
|
|
|
|
"action: keeping current file and installing"
|
|
|
|
" new one with .pacnew ending\n");
|
2014-10-01 02:06:49 -04:00
|
|
|
EVENT(handle, &event);
|
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
2014-10-01 02:26:14 -04:00
|
|
|
"warning: %s installed as %s\n", origfile, filename);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2011-09-30 12:43:11 -04:00
|
|
|
free(hash_local);
|
2014-10-01 02:26:14 -04:00
|
|
|
if(!backup) {
|
|
|
|
free(hash_pkg);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
}
|
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-06-28 09:26:39 -04:00
|
|
|
static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
|
2011-06-03 14:18:36 -04:00
|
|
|
size_t pkg_current, size_t pkg_count)
|
2007-07-15 21:36:46 -04:00
|
|
|
{
|
|
|
|
int i, ret = 0, errors = 0;
|
2013-03-07 01:32:41 -05:00
|
|
|
int is_upgrade = 0;
|
2011-06-28 09:26:39 -04:00
|
|
|
alpm_pkg_t *oldpkg = NULL;
|
2011-06-28 00:11:43 -04:00
|
|
|
alpm_db_t *db = handle->db_local;
|
2011-06-28 09:27:16 -04:00
|
|
|
alpm_trans_t *trans = handle->trans;
|
2013-12-02 15:45:15 -05:00
|
|
|
alpm_progress_t progress = ALPM_PROGRESS_ADD_START;
|
2014-01-10 10:25:14 -05:00
|
|
|
alpm_event_package_operation_t event;
|
2013-03-07 01:32:41 -05:00
|
|
|
const char *log_msg = "adding";
|
2011-10-27 15:59:24 -04:00
|
|
|
const char *pkgfile;
|
2009-12-04 19:50:09 -05:00
|
|
|
|
2011-06-28 18:46:04 -04:00
|
|
|
ASSERT(trans != NULL, return -1);
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* see if this is an upgrade. if so, remove the old package first */
|
2011-06-28 09:26:39 -04:00
|
|
|
alpm_pkg_t *local = _alpm_db_get_pkgfromcache(db, newpkg->name);
|
2007-07-15 21:36:46 -04:00
|
|
|
if(local) {
|
2013-03-07 01:32:41 -05:00
|
|
|
int cmp = _alpm_pkg_compare_versions(newpkg, local);
|
|
|
|
if(cmp < 0) {
|
|
|
|
log_msg = "downgrading";
|
2013-12-02 15:45:15 -05:00
|
|
|
progress = ALPM_PROGRESS_DOWNGRADE_START;
|
2014-01-10 10:25:14 -05:00
|
|
|
event.operation = ALPM_PACKAGE_DOWNGRADE;
|
2013-03-07 01:32:41 -05:00
|
|
|
} else if(cmp == 0) {
|
|
|
|
log_msg = "reinstalling";
|
2013-12-02 15:45:15 -05:00
|
|
|
progress = ALPM_PROGRESS_REINSTALL_START;
|
2014-01-10 10:25:14 -05:00
|
|
|
event.operation = ALPM_PACKAGE_REINSTALL;
|
2013-03-07 01:32:41 -05:00
|
|
|
} else {
|
|
|
|
log_msg = "upgrading";
|
2013-12-02 15:45:15 -05:00
|
|
|
progress = ALPM_PROGRESS_UPGRADE_START;
|
2014-01-10 10:25:14 -05:00
|
|
|
event.operation = ALPM_PACKAGE_UPGRADE;
|
2013-03-07 01:32:41 -05:00
|
|
|
}
|
2007-07-15 21:36:46 -04:00
|
|
|
is_upgrade = 1;
|
|
|
|
|
|
|
|
/* we'll need to save some record for backup checks later */
|
2011-08-19 12:06:55 -04:00
|
|
|
if(_alpm_pkg_dup(local, &oldpkg) == -1) {
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2008-07-30 17:36:46 -04:00
|
|
|
|
2008-01-13 16:15:10 -05:00
|
|
|
/* copy over the install reason */
|
2011-08-19 12:06:55 -04:00
|
|
|
newpkg->reason = alpm_pkg_get_reason(local);
|
2014-01-10 10:25:14 -05:00
|
|
|
} else {
|
|
|
|
event.operation = ALPM_PACKAGE_INSTALL;
|
2011-09-28 04:45:46 -04:00
|
|
|
}
|
2007-02-17 03:55:05 -05:00
|
|
|
|
2014-01-10 10:25:14 -05:00
|
|
|
event.type = ALPM_EVENT_PACKAGE_OPERATION_START;
|
|
|
|
event.oldpkg = oldpkg;
|
|
|
|
event.newpkg = newpkg;
|
|
|
|
EVENT(handle, &event);
|
2013-03-07 01:32:41 -05:00
|
|
|
|
2011-10-27 15:59:24 -04:00
|
|
|
pkgfile = newpkg->origin_data.file;
|
|
|
|
|
2011-09-28 04:45:46 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "%s package %s-%s\n",
|
2013-03-07 01:32:41 -05:00
|
|
|
log_msg, newpkg->name, newpkg->version);
|
2011-09-28 04:45:46 -04:00
|
|
|
/* pre_install/pre_upgrade scriptlet */
|
|
|
|
if(alpm_pkg_has_scriptlet(newpkg) &&
|
|
|
|
!(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
|
|
|
|
const char *scriptlet_name = is_upgrade ? "pre_upgrade" : "pre_install";
|
2012-05-04 12:41:40 -04:00
|
|
|
|
|
|
|
_alpm_runscriptlet(handle, pkgfile, scriptlet_name,
|
|
|
|
newpkg->version, oldpkg ? oldpkg->version : NULL, 1);
|
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 */
|
2011-07-01 12:01:39 -04:00
|
|
|
if(trans->flags & ALPM_TRANS_FLAG_ALLDEPS) {
|
2011-07-01 12:01:38 -04:00
|
|
|
newpkg->reason = ALPM_PKG_REASON_DEPEND;
|
2011-07-01 12:01:39 -04:00
|
|
|
} else if(trans->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) {
|
2011-07-01 12:01:38 -04:00
|
|
|
newpkg->reason = ALPM_PKG_REASON_EXPLICIT;
|
2008-01-13 16:15:10 -05:00
|
|
|
}
|
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
if(oldpkg) {
|
|
|
|
/* set up fake remove transaction */
|
2011-07-06 10:18:59 -04:00
|
|
|
if(_alpm_remove_single_package(handle, oldpkg, newpkg, 0, 0) == -1) {
|
2011-07-01 12:01:39 -04:00
|
|
|
handle->pm_errno = ALPM_ERR_TRANS_ABORT;
|
2009-07-15 13:14:01 -04:00
|
|
|
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
|
2013-07-15 00:14:46 -04:00
|
|
|
changelog/install script installation */
|
2010-10-13 04:04:07 -04:00
|
|
|
if(_alpm_local_db_prepare(db, newpkg)) {
|
2013-01-18 20:42:21 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"error: could not create database entry %s-%s\n",
|
2011-08-18 00:25:19 -04:00
|
|
|
newpkg->name, newpkg->version);
|
2011-07-01 12:01:39 -04:00
|
|
|
handle->pm_errno = ALPM_ERR_DB_WRITE;
|
2009-01-02 04:12:22 -05:00
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2011-07-01 12:01:39 -04:00
|
|
|
if(!(trans->flags & ALPM_TRANS_FLAG_DBONLY)) {
|
2008-04-08 23:14:21 -04:00
|
|
|
struct archive *archive;
|
|
|
|
struct archive_entry *entry;
|
2011-11-14 00:45:55 -05:00
|
|
|
struct stat buf;
|
|
|
|
int fd, cwdfd;
|
2008-04-08 23:14:21 -04:00
|
|
|
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "extracting files\n");
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2011-11-14 00:45:55 -05:00
|
|
|
fd = _alpm_open_archive(db->handle, pkgfile, &buf,
|
|
|
|
&archive, ALPM_ERR_PKG_OPEN);
|
|
|
|
if(fd < 0) {
|
2008-07-15 07:30:34 -04:00
|
|
|
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 */
|
2014-01-02 13:37:12 -05:00
|
|
|
OPEN(cwdfd, ".", O_RDONLY | O_CLOEXEC);
|
2011-09-19 15:08:14 -04:00
|
|
|
if(cwdfd < 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("could not get current working directory\n"));
|
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 */
|
2011-06-07 17:13:58 -04:00
|
|
|
if(chdir(handle->root) != 0) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("could not change directory to %s (%s)\n"),
|
2011-06-07 17:13:58 -04:00
|
|
|
handle->root, strerror(errno));
|
2013-01-28 20:23:25 -05:00
|
|
|
_alpm_archive_read_free(archive);
|
2013-07-03 20:33:19 -04:00
|
|
|
close(fd);
|
2010-06-27 06:32:11 -04:00
|
|
|
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 */
|
2013-12-02 15:45:15 -05:00
|
|
|
PROGRESS(handle, progress, newpkg->name, 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) */
|
2013-01-28 20:23:25 -05:00
|
|
|
int64_t pos = _alpm_archive_compressed_ftell(archive);
|
2011-01-09 21:36:42 -05:00
|
|
|
percent = (pos * 100) / 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
|
|
|
|
2013-12-02 15:45:15 -05:00
|
|
|
PROGRESS(handle, progress, newpkg->name, percent, pkg_count, pkg_current);
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2007-07-15 21:36:46 -04:00
|
|
|
/* extract the next file from the archive */
|
2011-06-09 16:15:15 -04:00
|
|
|
errors += extract_single_file(handle, archive, entry, newpkg, oldpkg);
|
2005-05-04 17:06:03 -04:00
|
|
|
}
|
2013-01-28 20:23:25 -05:00
|
|
|
_alpm_archive_read_free(archive);
|
2013-07-03 20:33:19 -04:00
|
|
|
close(fd);
|
2005-05-04 17:06:03 -04:00
|
|
|
|
2010-06-27 06:32:11 -04:00
|
|
|
/* restore the old cwd if we have it */
|
2011-09-19 15:08:14 -04:00
|
|
|
if(cwdfd >= 0) {
|
|
|
|
if(fchdir(cwdfd) != 0) {
|
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR,
|
|
|
|
_("could not restore working directory (%s)\n"), strerror(errno));
|
|
|
|
}
|
2013-07-03 20:33:19 -04:00
|
|
|
close(cwdfd);
|
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) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("problem occurred while upgrading %s\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
2013-01-18 20:42:21 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"error: problem occurred while upgrading %s\n",
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
|
|
|
} else {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("problem occurred while installing %s\n"),
|
2007-07-15 21:36:46 -04:00
|
|
|
newpkg->name);
|
2013-01-18 20:42:21 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"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
|
|
|
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_DEBUG, "updating database\n");
|
|
|
|
_alpm_log(handle, ALPM_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)) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("could not update database entry %s-%s\n"),
|
2011-08-18 00:25:19 -04:00
|
|
|
newpkg->name, newpkg->version);
|
2013-01-18 20:42:21 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX,
|
|
|
|
"error: could not update database entry %s-%s\n",
|
2011-08-18 00:25:19 -04:00
|
|
|
newpkg->name, newpkg->version);
|
2011-07-01 12:01:39 -04:00
|
|
|
handle->pm_errno = ALPM_ERR_DB_WRITE;
|
2008-07-15 07:30:34 -04:00
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if(_alpm_db_add_pkgincache(db, newpkg) == -1) {
|
2011-07-01 12:01:38 -04:00
|
|
|
_alpm_log(handle, ALPM_LOG_ERROR, _("could not add entry '%s' in cache\n"),
|
2011-08-18 00:25:19 -04:00
|
|
|
newpkg->name);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
|
|
|
|
2013-12-02 15:45:15 -05:00
|
|
|
PROGRESS(handle, progress, newpkg->name, 100, pkg_count, pkg_current);
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2014-01-10 10:25:14 -05:00
|
|
|
switch(event.operation) {
|
|
|
|
case ALPM_PACKAGE_INSTALL:
|
2013-11-05 11:29:55 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX, "installed %s (%s)\n",
|
|
|
|
newpkg->name, newpkg->version);
|
|
|
|
break;
|
2014-01-10 10:25:14 -05:00
|
|
|
case ALPM_PACKAGE_DOWNGRADE:
|
2013-11-05 11:29:55 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX, "downgraded %s (%s -> %s)\n",
|
|
|
|
newpkg->name, oldpkg->version, newpkg->version);
|
|
|
|
break;
|
2014-01-10 10:25:14 -05:00
|
|
|
case ALPM_PACKAGE_REINSTALL:
|
2013-11-05 11:29:55 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX, "reinstalled %s (%s)\n",
|
|
|
|
newpkg->name, newpkg->version);
|
|
|
|
break;
|
2014-01-10 10:25:14 -05:00
|
|
|
case ALPM_PACKAGE_UPGRADE:
|
2013-11-05 11:29:55 -05:00
|
|
|
alpm_logaction(handle, ALPM_CALLER_PREFIX, "upgraded %s (%s -> %s)\n",
|
|
|
|
newpkg->name, oldpkg->version, newpkg->version);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* we should never reach here */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-11-08 00:44:40 -05:00
|
|
|
/* run the post-install script if it exists */
|
2007-07-15 21:36:46 -04:00
|
|
|
if(alpm_pkg_has_scriptlet(newpkg)
|
2011-07-01 12:01:39 -04:00
|
|
|
&& !(trans->flags & ALPM_TRANS_FLAG_NOSCRIPTLET)) {
|
2011-09-28 05:43:23 -04:00
|
|
|
char *scriptlet = _alpm_local_db_pkgpath(db, newpkg, "install");
|
|
|
|
const char *scriptlet_name = is_upgrade ? "post_upgrade" : "post_install";
|
2011-09-28 04:45:46 -04:00
|
|
|
|
|
|
|
_alpm_runscriptlet(handle, scriptlet, scriptlet_name,
|
|
|
|
newpkg->version, oldpkg ? oldpkg->version : NULL, 0);
|
2011-09-28 05:43:23 -04:00
|
|
|
free(scriptlet);
|
2007-07-15 21:36:46 -04:00
|
|
|
}
|
2006-10-15 15:31:03 -04:00
|
|
|
|
2014-01-10 10:25:14 -05:00
|
|
|
event.type = ALPM_EVENT_PACKAGE_OPERATION_DONE;
|
|
|
|
EVENT(handle, &event);
|
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
|
|
|
}
|
|
|
|
|
2011-06-28 00:04:00 -04:00
|
|
|
int _alpm_upgrade_packages(alpm_handle_t *handle)
|
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;
|
2011-06-28 09:27:16 -04:00
|
|
|
alpm_trans_t *trans = handle->trans;
|
2007-07-15 21:36:46 -04:00
|
|
|
|
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) {
|
2011-06-28 09:26:39 -04:00
|
|
|
alpm_pkg_t *newpkg = targ->data;
|
2011-06-14 11:01:08 -04:00
|
|
|
|
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
|
|
|
|
2011-06-03 14:18:36 -04:00
|
|
|
if(commit_single_pkg(handle, newpkg, pkg_current, pkg_count)) {
|
2008-10-31 23:43:55 -04:00
|
|
|
/* something screwed up on the commit, abort the trans */
|
|
|
|
trans->state = STATE_INTERRUPTED;
|
2011-07-01 12:01:39 -04:00
|
|
|
handle->pm_errno = ALPM_ERR_TRANS_ABORT;
|
2008-10-31 23:43:55 -04:00
|
|
|
/* 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 */
|
2011-06-03 13:33:18 -04:00
|
|
|
_alpm_ldconfig(handle);
|
2008-10-31 23:43:55 -04:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2014-01-22 18:06:11 -05:00
|
|
|
/* vim: set noet: */
|