Send patches - preferably formatted by git format-patch - to patches at archlinux32 dot org.
summaryrefslogtreecommitdiff
path: root/lib/libalpm/sync.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libalpm/sync.c')
-rw-r--r--lib/libalpm/sync.c454
1 files changed, 241 insertions, 213 deletions
diff --git a/lib/libalpm/sync.c b/lib/libalpm/sync.c
index f83b0ef9..643d65e8 100644
--- a/lib/libalpm/sync.c
+++ b/lib/libalpm/sync.c
@@ -26,11 +26,9 @@
#include <sys/types.h> /* off_t */
#include <stdlib.h>
#include <stdio.h>
-#include <fcntl.h>
#include <string.h>
#include <stdint.h> /* intmax_t */
#include <unistd.h>
-#include <time.h>
#include <limits.h>
/* libalpm */
@@ -50,13 +48,14 @@
#include "delta.h"
#include "remove.h"
#include "diskspace.h"
+#include "signing.h"
/** Check for new version of pkg in sync repos
* (only the first occurrence is considered in sync)
*/
pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
{
- ASSERT(pkg != NULL, return(NULL));
+ ASSERT(pkg != NULL, return NULL);
alpm_list_t *i;
pmpkg_t *spkg = NULL;
@@ -66,47 +65,43 @@ pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
}
if(spkg == NULL) {
- _alpm_log(PM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
+ _alpm_log(pkg->handle, PM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
alpm_pkg_get_name(pkg));
- return(NULL);
+ return NULL;
}
/* compare versions and see if spkg is an upgrade */
if(_alpm_pkg_compare_versions(spkg, pkg) > 0) {
- _alpm_log(PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
+ _alpm_log(pkg->handle, PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg),
alpm_pkg_get_version(spkg));
- return(spkg);
+ return spkg;
}
/* spkg is not an upgrade */
- return(NULL);
+ return NULL;
}
-/** Search for packages to upgrade and add them to the transaction.
- * @return 0 on success, -1 on error (pm_errno is set accordingly)
- */
-int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
+/** Search for packages to upgrade and add them to the transaction. */
+int SYMEXPORT alpm_sync_sysupgrade(pmhandle_t *handle, int enable_downgrade)
{
alpm_list_t *i, *j, *k;
pmtrans_t *trans;
pmdb_t *db_local;
alpm_list_t *dbs_sync;
- ALPM_LOG_FUNC;
-
- ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
+ ASSERT(handle != NULL, return -1);
trans = handle->trans;
db_local = handle->db_local;
dbs_sync = handle->dbs_sync;
- 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(handle, PM_ERR_TRANS_NULL, -1));
+ ASSERT(trans->state == STATE_INITIALIZED, RET_ERR(handle, PM_ERR_TRANS_NOT_INITIALIZED, -1));
- _alpm_log(PM_LOG_DEBUG, "checking for package upgrades\n");
+ _alpm_log(handle, PM_LOG_DEBUG, "checking for package upgrades\n");
for(i = _alpm_db_get_pkgcache(db_local); i; i = i->next) {
pmpkg_t *lpkg = i->data;
if(_alpm_pkg_find(trans->add, lpkg->name)) {
- _alpm_log(PM_LOG_DEBUG, "%s is already in the target list -- skipping\n", lpkg->name);
+ _alpm_log(handle, PM_LOG_DEBUG, "%s is already in the target list -- skipping\n", lpkg->name);
continue;
}
@@ -116,46 +111,52 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
pmdb_t *sdb = j->data;
/* Check sdb */
pmpkg_t *spkg = _alpm_db_get_pkgfromcache(sdb, lpkg->name);
- if(spkg) { /* 1. literal was found in sdb */
+ if(spkg) {
+ /* 1. literal was found in sdb */
int cmp = _alpm_pkg_compare_versions(spkg, lpkg);
if(cmp > 0) {
- _alpm_log(PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
lpkg->name, lpkg->version, spkg->version);
/* check IgnorePkg/IgnoreGroup */
- if(_alpm_pkg_should_ignore(spkg) || _alpm_pkg_should_ignore(lpkg)) {
- _alpm_log(PM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
- lpkg->name, lpkg->version, spkg->version);
+ if(_alpm_pkg_should_ignore(spkg)
+ || _alpm_pkg_should_ignore(lpkg)) {
+ _alpm_log(handle, PM_LOG_WARNING, _("%s: ignoring package upgrade (%s => %s)\n"),
+ lpkg->name, lpkg->version, spkg->version);
} else {
- _alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
spkg->name, spkg->version);
trans->add = alpm_list_add(trans->add, spkg);
}
} else if(cmp < 0) {
if(enable_downgrade) {
/* check IgnorePkg/IgnoreGroup */
- if(_alpm_pkg_should_ignore(spkg) || _alpm_pkg_should_ignore(lpkg)) {
- _alpm_log(PM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
+ if(_alpm_pkg_should_ignore(spkg)
+ || _alpm_pkg_should_ignore(lpkg)) {
+ _alpm_log(handle, PM_LOG_WARNING, _("%s: ignoring package downgrade (%s => %s)\n"),
lpkg->name, lpkg->version, spkg->version);
} else {
- _alpm_log(PM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
+ _alpm_log(handle, PM_LOG_WARNING, _("%s: downgrading from version %s to version %s\n"),
lpkg->name, lpkg->version, spkg->version);
trans->add = alpm_list_add(trans->add, spkg);
}
} else {
- _alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
+ _alpm_log(handle, PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
lpkg->name, lpkg->version, sdb->treename, spkg->version);
}
}
- break; /* jump to next local package */
- } else { /* 2. search for replacers in sdb */
+ /* jump to next local package */
+ break;
+ } else {
+ /* 2. search for replacers in sdb */
int found = 0;
for(k = _alpm_db_get_pkgcache(sdb); k; k = k->next) {
spkg = k->data;
if(alpm_list_find_str(alpm_pkg_get_replaces(spkg), lpkg->name)) {
found = 1;
/* check IgnorePkg/IgnoreGroup */
- if(_alpm_pkg_should_ignore(spkg) || _alpm_pkg_should_ignore(lpkg)) {
- _alpm_log(PM_LOG_WARNING, _("ignoring package replacement (%s-%s => %s-%s)\n"),
+ if(_alpm_pkg_should_ignore(spkg)
+ || _alpm_pkg_should_ignore(lpkg)) {
+ _alpm_log(handle, PM_LOG_WARNING, _("ignoring package replacement (%s-%s => %s-%s)\n"),
lpkg->name, lpkg->version, spkg->name, spkg->version);
continue;
}
@@ -172,22 +173,23 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
if(tpkg) {
/* sanity check, multiple repos can contain spkg->name */
if(tpkg->origin_data.db != sdb) {
- _alpm_log(PM_LOG_WARNING, _("cannot replace %s by %s\n"),
+ _alpm_log(handle, PM_LOG_WARNING, _("cannot replace %s by %s\n"),
lpkg->name, spkg->name);
continue;
}
- _alpm_log(PM_LOG_DEBUG, "appending %s to the removes list of %s\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "appending %s to the removes list of %s\n",
lpkg->name, tpkg->name);
tpkg->removes = alpm_list_add(tpkg->removes, lpkg);
/* check the to-be-replaced package's reason field */
if(alpm_pkg_get_reason(lpkg) == PM_PKG_REASON_EXPLICIT) {
tpkg->reason = PM_PKG_REASON_EXPLICIT;
}
- } else { /* add spkg to the target list */
+ } else {
+ /* add spkg to the target list */
/* copy over reason */
spkg->reason = alpm_pkg_get_reason(lpkg);
spkg->removes = alpm_list_add(NULL, lpkg);
- _alpm_log(PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "adding package %s-%s to the transaction targets\n",
spkg->name, spkg->version);
trans->add = alpm_list_add(trans->add, spkg);
}
@@ -200,7 +202,7 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
}
}
- return(0);
+ return 0;
}
/** Find group members across a list of databases.
@@ -231,7 +233,7 @@ alpm_list_t SYMEXPORT *alpm_find_grp_pkgs(alpm_list_t *dbs,
if(_alpm_pkg_should_ignore(pkg)) {
ignorelist = alpm_list_add(ignorelist, pkg);
int install = 0;
- QUESTION(handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
+ QUESTION(db->handle->trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, pkg,
NULL, NULL, &install);
if(!install)
continue;
@@ -242,7 +244,7 @@ alpm_list_t SYMEXPORT *alpm_find_grp_pkgs(alpm_list_t *dbs,
}
}
alpm_list_free(ignorelist);
- return(pkgs);
+ return pkgs;
}
/** Compute the size of the files that will be downloaded to install a
@@ -254,16 +256,17 @@ static int compute_download_size(pmpkg_t *newpkg)
const char *fname;
char *fpath;
off_t size = 0;
+ pmhandle_t *handle = newpkg->handle;
if(newpkg->origin != PKG_FROM_SYNCDB) {
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = 0;
- return(0);
+ return 0;
}
fname = alpm_pkg_get_filename(newpkg);
- ASSERT(fname != NULL, RET_ERR(PM_ERR_PKG_INVALID_NAME, -1));
- fpath = _alpm_filecache_find(fname);
+ ASSERT(fname != NULL, RET_ERR(handle, PM_ERR_PKG_INVALID_NAME, -1));
+ fpath = _alpm_filecache_find(handle, fname);
if(fpath) {
FREE(fpath);
@@ -272,16 +275,16 @@ static int compute_download_size(pmpkg_t *newpkg)
off_t dltsize;
off_t pkgsize = alpm_pkg_get_size(newpkg);
- dltsize = _alpm_shortest_delta_path(
+ dltsize = _alpm_shortest_delta_path(newpkg->handle,
alpm_pkg_get_deltas(newpkg),
alpm_pkg_get_filename(newpkg),
&newpkg->delta_path);
if(newpkg->delta_path && (dltsize < pkgsize * MAX_DELTA_RATIO)) {
- _alpm_log(PM_LOG_DEBUG, "using delta size\n");
+ _alpm_log(handle, PM_LOG_DEBUG, "using delta size\n");
size = dltsize;
} else {
- _alpm_log(PM_LOG_DEBUG, "using package size\n");
+ _alpm_log(handle, PM_LOG_DEBUG, "using package size\n");
size = alpm_pkg_get_size(newpkg);
alpm_list_free(newpkg->delta_path);
newpkg->delta_path = NULL;
@@ -290,26 +293,22 @@ static int compute_download_size(pmpkg_t *newpkg)
size = alpm_pkg_get_size(newpkg);
}
- _alpm_log(PM_LOG_DEBUG, "setting download size %jd for pkg %s\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "setting download size %jd for pkg %s\n",
(intmax_t)size, alpm_pkg_get_name(newpkg));
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = size;
- return(0);
+ return 0;
}
-int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data)
+int _alpm_sync_prepare(pmhandle_t *handle, alpm_list_t **data)
{
+ alpm_list_t *i, *j;
alpm_list_t *deps = NULL;
alpm_list_t *unresolvable = NULL;
- alpm_list_t *i, *j;
alpm_list_t *remove = NULL;
int ret = 0;
-
- ALPM_LOG_FUNC;
-
- ASSERT(db_local != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ pmtrans_t *trans = handle->trans;
if(data) {
*data = NULL;
@@ -321,7 +320,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* Build up list by repeatedly resolving each transaction package */
/* Resolve targets dependencies */
EVENT(trans, PM_TRANS_EVT_RESOLVEDEPS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "resolving target's dependencies\n");
+ _alpm_log(handle, PM_LOG_DEBUG, "resolving target's dependencies\n");
/* build remove list for resolvedeps */
for(i = trans->add; i; i = i->next) {
@@ -333,14 +332,14 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* Compute the fake local database for resolvedeps (partial fix for the
* phonon/qt issue) */
- alpm_list_t *localpkgs = alpm_list_diff(_alpm_db_get_pkgcache(db_local),
+ alpm_list_t *localpkgs = alpm_list_diff(_alpm_db_get_pkgcache(handle->db_local),
trans->add, _alpm_pkg_cmp);
/* Resolve packages in the transaction one at a time, in addition
building up a list of packages which could not be resolved. */
for(i = trans->add; i; i = i->next) {
pmpkg_t *pkg = i->data;
- if(_alpm_resolvedeps(localpkgs, dbs_sync, pkg, trans->add,
+ if(_alpm_resolvedeps(handle, localpkgs, pkg, trans->add,
&resolved, remove, data) == -1) {
unresolvable = alpm_list_add(unresolvable, pkg);
}
@@ -353,14 +352,14 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
see if they'd like to ignore them rather than failing the sync */
if(unresolvable != NULL) {
int remove_unresolvable = 0;
- QUESTION(handle->trans, PM_TRANS_CONV_REMOVE_PKGS, unresolvable,
+ QUESTION(trans, PM_TRANS_CONV_REMOVE_PKGS, unresolvable,
NULL, NULL, &remove_unresolvable);
- if (remove_unresolvable) {
+ if(remove_unresolvable) {
/* User wants to remove the unresolvable packages from the
transaction. The packages will be removed from the actual
transaction when the transaction packages are replaced with a
dependency-reordered list below */
- pm_errno = 0; /* pm_errno was set by resolvedeps */
+ handle->pm_errno = 0; /* pm_errno was set by resolvedeps */
if(data) {
alpm_list_free_inner(*data, (alpm_list_fn_free)_alpm_depmiss_free);
alpm_list_free(*data);
@@ -388,7 +387,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* re-order w.r.t. dependencies */
alpm_list_free(trans->add);
- trans->add = _alpm_sortbydeps(resolved, 0);
+ trans->add = _alpm_sortbydeps(handle, resolved, 0);
alpm_list_free(resolved);
EVENT(trans, PM_TRANS_EVT_RESOLVEDEPS_DONE, NULL, NULL);
@@ -398,11 +397,11 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
/* check for inter-conflicts and whatnot */
EVENT(trans, PM_TRANS_EVT_INTERCONFLICTS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "looking for conflicts\n");
+ _alpm_log(handle, PM_LOG_DEBUG, "looking for conflicts\n");
/* 1. check for conflicts in the target list */
- _alpm_log(PM_LOG_DEBUG, "check targets vs targets\n");
- deps = _alpm_innerconflicts(trans->add);
+ _alpm_log(handle, PM_LOG_DEBUG, "check targets vs targets\n");
+ deps = _alpm_innerconflicts(handle, trans->add);
for(i = deps; i; i = i->next) {
pmconflict_t *conflict = i->data;
@@ -415,7 +414,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
continue;
}
- _alpm_log(PM_LOG_DEBUG, "conflicting packages in the sync list: '%s' <-> '%s'\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "conflicting packages in the sync list: '%s' <-> '%s'\n",
conflict->package1, conflict->package2);
/* if sync1 provides sync2, we remove sync2 from the targets, and vice versa */
@@ -428,8 +427,8 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
rsync = sync1;
sync = sync2;
} else {
- _alpm_log(PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
- pm_errno = PM_ERR_CONFLICTING_DEPS;
+ _alpm_log(handle, PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
+ handle->pm_errno = PM_ERR_CONFLICTING_DEPS;
ret = -1;
if(data) {
pmconflict_t *newconflict = _alpm_conflict_dup(conflict);
@@ -447,7 +446,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
_alpm_dep_free(dep2);
/* Prints warning */
- _alpm_log(PM_LOG_WARNING,
+ _alpm_log(handle, PM_LOG_WARNING,
_("removing '%s' from target list because it conflicts with '%s'\n"),
rsync->name, sync->name);
trans->add = alpm_list_remove(trans->add, rsync, _alpm_pkg_cmp, NULL);
@@ -460,8 +459,8 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
deps = NULL;
/* 2. we check for target vs db conflicts (and resolve)*/
- _alpm_log(PM_LOG_DEBUG, "check targets vs db and db vs targets\n");
- deps = _alpm_outerconflicts(db_local, trans->add);
+ _alpm_log(handle, PM_LOG_DEBUG, "check targets vs db and db vs targets\n");
+ deps = _alpm_outerconflicts(handle->db_local, trans->add);
for(i = deps; i; i = i->next) {
pmconflict_t *conflict = i->data;
@@ -479,21 +478,21 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
continue;
}
- _alpm_log(PM_LOG_DEBUG, "package '%s' conflicts with '%s'\n",
+ _alpm_log(handle, PM_LOG_DEBUG, "package '%s' conflicts with '%s'\n",
conflict->package1, conflict->package2);
pmpkg_t *sync = _alpm_pkg_find(trans->add, conflict->package1);
- pmpkg_t *local = _alpm_db_get_pkgfromcache(db_local, conflict->package2);
+ pmpkg_t *local = _alpm_db_get_pkgfromcache(handle->db_local, conflict->package2);
int doremove = 0;
QUESTION(trans, PM_TRANS_CONV_CONFLICT_PKG, conflict->package1,
conflict->package2, conflict->reason, &doremove);
if(doremove) {
/* append to the removes list */
- _alpm_log(PM_LOG_DEBUG, "electing '%s' for removal\n", conflict->package2);
+ _alpm_log(handle, PM_LOG_DEBUG, "electing '%s' for removal\n", conflict->package2);
sync->removes = alpm_list_add(sync->removes, local);
} else { /* abort */
- _alpm_log(PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
- pm_errno = PM_ERR_CONFLICTING_DEPS;
+ _alpm_log(handle, PM_LOG_ERROR, _("unresolvable package conflicts detected\n"));
+ handle->pm_errno = PM_ERR_CONFLICTING_DEPS;
ret = -1;
if(data) {
pmconflict_t *newconflict = _alpm_conflict_dup(conflict);
@@ -517,17 +516,18 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
for(j = spkg->removes; j; j = j->next) {
pmpkg_t *rpkg = j->data;
if(!_alpm_pkg_find(trans->remove, rpkg->name)) {
- _alpm_log(PM_LOG_DEBUG, "adding '%s' to remove list\n", rpkg->name);
+ _alpm_log(handle, PM_LOG_DEBUG, "adding '%s' to remove list\n", rpkg->name);
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(rpkg));
}
}
}
if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
- _alpm_log(PM_LOG_DEBUG, "checking dependencies\n");
- deps = alpm_checkdeps(_alpm_db_get_pkgcache(db_local), 1, trans->remove, trans->add);
+ _alpm_log(handle, PM_LOG_DEBUG, "checking dependencies\n");
+ deps = alpm_checkdeps(handle, _alpm_db_get_pkgcache(handle->db_local),
+ trans->remove, trans->add, 1);
if(deps) {
- pm_errno = PM_ERR_UNSATISFIED_DEPS;
+ handle->pm_errno = PM_ERR_UNSATISFIED_DEPS;
ret = -1;
if(data) {
*data = deps;
@@ -551,7 +551,7 @@ cleanup:
alpm_list_free(unresolvable);
alpm_list_free(remove);
- return(ret);
+ return ret;
}
/** Returns the size of the files that will be downloaded to install a
@@ -564,13 +564,13 @@ off_t SYMEXPORT alpm_pkg_download_size(pmpkg_t *newpkg)
if(!(newpkg->infolevel & INFRQ_DSIZE)) {
compute_download_size(newpkg);
}
- return(newpkg->download_size);
+ return newpkg->download_size;
}
static int endswith(const char *filename, const char *extension)
{
const char *s = filename + strlen(filename) - strlen(extension);
- return(strcmp(s, extension) == 0);
+ return strcmp(s, extension) == 0;
}
/** Applies delta files to create an upgraded package file.
@@ -578,15 +578,16 @@ static int endswith(const char *filename, const char *extension)
* All intermediate files are deleted, leaving only the starting and
* ending package files.
*
- * @param trans the transaction
+ * @param handle the context handle
*
* @return 0 if all delta files were able to be applied, 1 otherwise.
*/
-static int apply_deltas(pmtrans_t *trans)
+static int apply_deltas(pmhandle_t *handle)
{
alpm_list_t *i;
int ret = 0;
- const char *cachedir = _alpm_filecache_setup();
+ const char *cachedir = _alpm_filecache_setup(handle);
+ pmtrans_t *trans = handle->trans;
for(i = trans->add; i; i = i->next) {
pmpkg_t *spkg = i->data;
@@ -603,18 +604,18 @@ static int apply_deltas(pmtrans_t *trans)
char command[PATH_MAX];
size_t len = 0;
- delta = _alpm_filecache_find(d->delta);
+ delta = _alpm_filecache_find(handle, d->delta);
/* the initial package might be in a different cachedir */
if(dlts == delta_path) {
- from = _alpm_filecache_find(d->from);
+ from = _alpm_filecache_find(handle, d->from);
} else {
/* len = cachedir len + from len + '/' + null */
len = strlen(cachedir) + strlen(d->from) + 2;
- CALLOC(from, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, 1));
+ CALLOC(from, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, 1));
snprintf(from, len, "%s/%s", cachedir, d->from);
}
len = strlen(cachedir) + strlen(d->to) + 2;
- CALLOC(to, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, 1));
+ CALLOC(to, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, 1));
snprintf(to, len, "%s/%s", cachedir, d->to);
/* build the patch command */
@@ -625,7 +626,7 @@ static int apply_deltas(pmtrans_t *trans)
snprintf(command, PATH_MAX, "xdelta3 -d -q -s %s %s %s", from, delta, to);
}
- _alpm_log(PM_LOG_DEBUG, "command: %s\n", command);
+ _alpm_log(handle, PM_LOG_DEBUG, "command: %s\n", command);
EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_START, d->to, d->delta);
@@ -650,13 +651,14 @@ static int apply_deltas(pmtrans_t *trans)
if(retval != 0) {
/* one delta failed for this package, cancel the remaining ones */
EVENT(trans, PM_TRANS_EVT_DELTA_PATCH_FAILED, NULL, NULL);
+ handle->pm_errno = PM_ERR_DLT_PATCHFAILED;
ret = 1;
break;
}
}
}
- return(ret);
+ return ret;
}
/** Compares the md5sum of a file to the expected value.
@@ -665,50 +667,75 @@ static int apply_deltas(pmtrans_t *trans)
* should be deleted.
*
* @param trans the transaction
- * @param filename the filename of the file to test
+ * @param filename the absolute path of the file to test
* @param md5sum the expected md5sum of the file
*
* @return 0 if the md5sum matched, 1 if not, -1 in case of errors
*/
-static int test_md5sum(pmtrans_t *trans, const char *filename,
+static int test_md5sum(pmtrans_t *trans, const char *filepath,
const char *md5sum)
{
- char *filepath;
- int ret;
-
- filepath = _alpm_filecache_find(filename);
-
- ret = _alpm_test_md5sum(filepath, md5sum);
-
+ int ret = _alpm_test_md5sum(filepath, md5sum);
if(ret == 1) {
int doremove = 0;
- QUESTION(trans, PM_TRANS_CONV_CORRUPTED_PKG, (char *)filename,
+ QUESTION(trans, PM_TRANS_CONV_CORRUPTED_PKG, (char *)filepath,
NULL, NULL, &doremove);
if(doremove) {
unlink(filepath);
}
}
- FREE(filepath);
-
- return(ret);
+ return ret;
}
-int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
+static int validate_deltas(pmhandle_t *handle, alpm_list_t *deltas,
+ alpm_list_t **data)
{
- alpm_list_t *i, *j, *files = NULL;
- alpm_list_t *deltas = NULL;
- size_t numtargs, current = 0, replaces = 0;
- int errors = 0;
- const char *cachedir = NULL;
- int ret = -1;
+ int errors = 0, ret = 0;
+ alpm_list_t *i;
+ pmtrans_t *trans = handle->trans;
- ALPM_LOG_FUNC;
+ if(!deltas) {
+ return 0;
+ }
+
+ /* Check integrity of deltas */
+ EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
+
+ for(i = deltas; i; i = i->next) {
+ pmdelta_t *d = alpm_list_getdata(i);
+ const char *filename = alpm_delta_get_filename(d);
+ char *filepath = _alpm_filecache_find(handle, filename);
+ const char *md5sum = alpm_delta_get_md5sum(d);
+
+ if(test_md5sum(trans, filepath, md5sum) != 0) {
+ errors++;
+ *data = alpm_list_add(*data, strdup(filename));
+ }
+ FREE(filepath);
+ }
+ if(errors) {
+ handle->pm_errno = PM_ERR_DLT_INVALID;
+ return -1;
+ }
+ EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
- ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
+ /* Use the deltas to generate the packages */
+ EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
+ ret = apply_deltas(handle);
+ EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
+ return ret;
+}
- cachedir = _alpm_filecache_setup();
- trans->state = STATE_DOWNLOADING;
+static int download_files(pmhandle_t *handle, alpm_list_t **deltas)
+{
+ const char *cachedir;
+ alpm_list_t *i, *j;
+ alpm_list_t *files = NULL;
+ int errors = 0;
+
+ cachedir = _alpm_filecache_setup(handle);
+ handle->trans->state = STATE_DOWNLOADING;
/* Total progress - figure out the total download size if required to
* pass to the callback. This function is called once, and it is up to the
@@ -716,7 +743,7 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(handle->totaldlcb) {
off_t total_size = (off_t)0;
/* sum up the download size for each package and store total */
- for(i = trans->add; i; i = i->next) {
+ for(i = handle->trans->add; i; i = i->next) {
pmpkg_t *spkg = i->data;
total_size += spkg->download_size;
}
@@ -727,59 +754,74 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
for(i = handle->dbs_sync; i; i = i->next) {
pmdb_t *current = i->data;
- for(j = trans->add; j; j = j->next) {
+ for(j = handle->trans->add; j; j = j->next) {
pmpkg_t *spkg = j->data;
if(spkg->origin != PKG_FROM_FILE && current == spkg->origin_data.db) {
const char *fname = NULL;
fname = alpm_pkg_get_filename(spkg);
- ASSERT(fname != NULL, RET_ERR(PM_ERR_PKG_INVALID_NAME, -1));
+ ASSERT(fname != NULL, RET_ERR(handle, PM_ERR_PKG_INVALID_NAME, -1));
alpm_list_t *delta_path = spkg->delta_path;
if(delta_path) {
/* using deltas */
- alpm_list_t *dlts = NULL;
-
+ alpm_list_t *dlts;
for(dlts = delta_path; dlts; dlts = dlts->next) {
- pmdelta_t *d = dlts->data;
-
- if(d->download_size != 0) {
- /* add the delta filename to the download list if needed */
- files = alpm_list_add(files, strdup(d->delta));
+ pmdelta_t *delta = dlts->data;
+ if(delta->download_size != 0) {
+ files = alpm_list_add(files, strdup(delta->delta));
}
-
/* keep a list of all the delta files for md5sums */
- deltas = alpm_list_add(deltas, d);
+ *deltas = alpm_list_add(*deltas, delta);
}
- } else {
- /* not using deltas */
- if(spkg->download_size != 0) {
- /* add the filename to the download list if needed */
- files = alpm_list_add(files, strdup(fname));
- }
+ } else if(spkg->download_size != 0) {
+ files = alpm_list_add(files, strdup(fname));
}
}
}
if(files) {
- EVENT(trans, PM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
- errors = _alpm_download_files(files, current->servers, cachedir);
+ EVENT(handle->trans, PM_TRANS_EVT_RETRIEVE_START, current->treename, NULL);
+ for(j = files; j; j = j->next) {
+ const char *filename = j->data;
+ alpm_list_t *server;
+ int ret = -1;
+ for(server = current->servers; server; server = server->next) {
+ const char *server_url = server->data;
+ char *fileurl;
+ size_t len;
+
+ /* print server + filename into a buffer */
+ len = strlen(server_url) + strlen(filename) + 2;
+ CALLOC(fileurl, len, sizeof(char), RET_ERR(handle, PM_ERR_MEMORY, -1));
+ snprintf(fileurl, len, "%s/%s", server_url, filename);
+
+ ret = _alpm_download(handle, fileurl, cachedir, 0, 1, 0);
+ FREE(fileurl);
+ if(ret != -1) {
+ break;
+ }
+ }
+ if(ret == -1) {
+ errors++;
+ }
+ }
- if (errors) {
- _alpm_log(PM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
+ FREELIST(files);
+ if(errors) {
+ _alpm_log(handle, PM_LOG_WARNING, _("failed to retrieve some files from %s\n"),
current->treename);
- if(pm_errno == 0) {
- pm_errno = PM_ERR_RETRIEVE;
+ if(handle->pm_errno == 0) {
+ handle->pm_errno = PM_ERR_RETRIEVE;
}
- goto error;
+ return -1;
}
- FREELIST(files);
}
}
- for(j = trans->add; j; j = j->next) {
+ for(j = handle->trans->add; j; j = j->next) {
pmpkg_t *pkg = j->data;
pkg->infolevel &= ~INFRQ_DSIZE;
pkg->download_size = 0;
@@ -789,70 +831,60 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(handle->totaldlcb) {
handle->totaldlcb(0);
}
+ return 0;
+}
- /* if we have deltas to work with */
- if(handle->usedelta && deltas) {
- int ret = 0;
- errors = 0;
- /* Check integrity of deltas */
- EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_START, NULL, NULL);
-
- for(i = deltas; i; i = i->next) {
- pmdelta_t *d = alpm_list_getdata(i);
- const char *filename = alpm_delta_get_filename(d);
- const char *md5sum = alpm_delta_get_md5sum(d);
-
- if(test_md5sum(trans, filename, md5sum) != 0) {
- errors++;
- *data = alpm_list_add(*data, strdup(filename));
- }
- }
- if(errors) {
- pm_errno = PM_ERR_DLT_INVALID;
- goto error;
- }
- EVENT(trans, PM_TRANS_EVT_DELTA_INTEGRITY_DONE, NULL, NULL);
+int _alpm_sync_commit(pmhandle_t *handle, alpm_list_t **data)
+{
+ alpm_list_t *i;
+ alpm_list_t *deltas = NULL;
+ size_t numtargs, current = 0, replaces = 0;
+ int errors;
+ pmtrans_t *trans = handle->trans;
- /* Use the deltas to generate the packages */
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_START, NULL, NULL);
- ret = apply_deltas(trans);
- EVENT(trans, PM_TRANS_EVT_DELTA_PATCHES_DONE, NULL, NULL);
+ if(download_files(handle, &deltas)) {
+ alpm_list_free(deltas);
+ return -1;
+ }
- if(ret) {
- pm_errno = PM_ERR_DLT_PATCHFAILED;
- goto error;
- }
+ if(validate_deltas(handle, deltas, data)) {
+ alpm_list_free(deltas);
+ return -1;
}
+ alpm_list_free(deltas);
/* Check integrity of packages */
numtargs = alpm_list_count(trans->add);
EVENT(trans, PM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
errors = 0;
+
for(i = trans->add; i; i = i->next, current++) {
pmpkg_t *spkg = i->data;
int percent = (current * 100) / numtargs;
+ const char *filename;
+ char *filepath;
+ pgp_verify_t check_sig;
+
+ PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
+ numtargs, current);
if(spkg->origin == PKG_FROM_FILE) {
continue; /* pkg_load() has been already called, this package is valid */
}
- PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
- numtargs, current);
- const char *filename = alpm_pkg_get_filename(spkg);
- const char *md5sum = alpm_pkg_get_md5sum(spkg);
+ filename = alpm_pkg_get_filename(spkg);
+ filepath = _alpm_filecache_find(handle, filename);
+ pmdb_t *sdb = alpm_pkg_get_db(spkg);
+ check_sig = _alpm_db_get_sigverify_level(sdb);
- if(test_md5sum(trans, filename, md5sum) != 0) {
- errors++;
- *data = alpm_list_add(*data, strdup(filename));
- continue;
- }
/* load the package file and replace pkgcache entry with it in the target list */
/* TODO: alpm_pkg_get_db() will not work on this target anymore */
- _alpm_log(PM_LOG_DEBUG, "replacing pkgcache entry with package file for target %s\n", spkg->name);
- char *filepath = _alpm_filecache_find(filename);
- pmpkg_t *pkgfile;
- if(alpm_pkg_load(filepath, 1, &pkgfile) != 0) {
- _alpm_pkg_free(pkgfile);
+ _alpm_log(handle, PM_LOG_DEBUG,
+ "replacing pkgcache entry with package file for target %s\n",
+ spkg->name);
+ pmpkg_t *pkgfile =_alpm_pkg_load_internal(handle, filepath, 1, spkg->md5sum,
+ spkg->base64_sig, check_sig);
+ if(!pkgfile) {
errors++;
*data = alpm_list_add(*data, strdup(filename));
FREE(filepath);
@@ -863,17 +895,18 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
i->data = pkgfile;
_alpm_pkg_free_trans(spkg); /* spkg has been removed from the target list */
}
+
PROGRESS(trans, PM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
numtargs, current);
EVENT(trans, PM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
+
+
if(errors) {
- pm_errno = PM_ERR_PKG_INVALID;
- goto error;
+ RET_ERR(handle, PM_ERR_PKG_INVALID, -1);
}
if(trans->flags & PM_TRANS_FLAG_DOWNLOADONLY) {
- ret = 0;
- goto error;
+ return 0;
}
trans->state = STATE_COMMITING;
@@ -884,18 +917,17 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(!(trans->flags & PM_TRANS_FLAG_FORCE)) {
EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "looking for file conflicts\n");
- alpm_list_t *conflict = _alpm_db_find_fileconflicts(db_local, trans,
- trans->add, trans->remove);
+ _alpm_log(handle, PM_LOG_DEBUG, "looking for file conflicts\n");
+ alpm_list_t *conflict = _alpm_db_find_fileconflicts(handle,
+ trans->add, trans->remove);
if(conflict) {
- pm_errno = PM_ERR_FILE_CONFLICTS;
if(data) {
*data = conflict;
} else {
alpm_list_free_inner(conflict, (alpm_list_fn_free)_alpm_fileconflict_free);
alpm_list_free(conflict);
}
- goto error;
+ RET_ERR(handle, PM_ERR_FILE_CONFLICTS, -1);
}
EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
@@ -905,10 +937,10 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
if(handle->checkspace) {
EVENT(trans, PM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
- _alpm_log(PM_LOG_DEBUG, "checking available disk space\n");
- if(_alpm_check_diskspace(trans, handle->db_local) == -1) {
- _alpm_log(PM_LOG_ERROR, "%s\n", _("not enough free disk space"));
- goto error;
+ _alpm_log(handle, PM_LOG_DEBUG, "checking available disk space\n");
+ if(_alpm_check_diskspace(handle) == -1) {
+ _alpm_log(handle, PM_LOG_ERROR, "%s\n", _("not enough free disk space"));
+ return -1;
}
EVENT(trans, PM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
@@ -916,26 +948,22 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
/* remove conflicting and to-be-replaced packages */
if(replaces) {
- _alpm_log(PM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
+ _alpm_log(handle, PM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
/* we want the frontend to be aware of commit details */
- if(_alpm_remove_packages(trans, handle->db_local) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not commit removal transaction\n"));
- goto error;
+ if(_alpm_remove_packages(handle) == -1) {
+ _alpm_log(handle, PM_LOG_ERROR, _("could not commit removal transaction\n"));
+ return -1;
}
}
/* install targets */
- _alpm_log(PM_LOG_DEBUG, "installing packages\n");
- if(_alpm_upgrade_packages(trans, handle->db_local) == -1) {
- _alpm_log(PM_LOG_ERROR, _("could not commit transaction\n"));
- goto error;
+ _alpm_log(handle, PM_LOG_DEBUG, "installing packages\n");
+ if(_alpm_upgrade_packages(handle) == -1) {
+ _alpm_log(handle, PM_LOG_ERROR, _("could not commit transaction\n"));
+ return -1;
}
- ret = 0;
-error:
- FREELIST(files);
- alpm_list_free(deltas);
- return(ret);
+ return 0;
}
/* vim: set ts=2 sw=2 noet: */

Copyright © 2002-2022 Judd Vinet and Aaron Griffin. Copyright © 2022 Erich Eckner.
The Arch Linux name and logo are recognized trademarks. Some rights reserved. The registered trademark Linux® is used pursuant to a sublicense from LMI, the exclusive licensee of Linus Torvalds, owner of the mark on a world-wide basis.