1 files changed, 295 insertions, 193 deletions

diff --git a/lib/libalpm/be_sync.c b/lib/libalpm/be_sync.c
index c440cd6b..d7e14ba3 100644
--- a/lib/libalpm/be_sync.c
+++ b/lib/libalpm/be_sync.c
@@ -1,5 +1,5 @@
 /*
- *  be_sync.c
+ *  be_sync.c : backend for sync databases
  *
  *  Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
  *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
@@ -21,7 +21,8 @@
 #include "config.h"
 
 #include <errno.h>
-#include <limits.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 /* libarchive */
 #include <archive.h>
@@ -38,32 +39,93 @@
 #include "deps.h"
 #include "dload.h"
 
+static char *get_sync_dir(alpm_handle_t *handle)
+{
+	const char *dbpath = alpm_option_get_dbpath(handle);
+	size_t len = strlen(dbpath) + 6;
+	char *syncpath;
+	struct stat buf;
+
+	MALLOC(syncpath, len, RET_ERR(handle, ALPM_ERR_MEMORY, NULL));
+	sprintf(syncpath, "%s%s", dbpath, "sync/");
+
+	if(stat(syncpath, &buf) != 0) {
+		_alpm_log(handle, ALPM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
+				syncpath);
+		if(_alpm_makepath(syncpath) != 0) {
+			free(syncpath);
+			RET_ERR(handle, ALPM_ERR_SYSTEM, NULL);
+		}
+	} else if(!S_ISDIR(buf.st_mode)) {
+		_alpm_log(handle, ALPM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
+		if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) {
+			free(syncpath);
+			RET_ERR(handle, ALPM_ERR_SYSTEM, NULL);
+		}
+	}
+
+	return syncpath;
+}
+
+static int sync_db_validate(alpm_db_t *db)
+{
+	alpm_siglevel_t level;
+
+	if(db->status & DB_STATUS_VALID) {
+		return 0;
+	}
+
+	/* this takes into account the default verification level if UNKNOWN
+	 * was assigned to this db */
+	level = alpm_db_get_siglevel(db);
+
+	if(level & ALPM_SIG_DATABASE) {
+		const char *dbpath = _alpm_db_path(db);
+		if(!dbpath) {
+			/* pm_errno set in _alpm_db_path() */
+			return -1;
+		}
+
+		/* we can skip any validation if the database doesn't exist */
+		if(access(dbpath, R_OK) != 0 && errno == ENOENT) {
+			goto valid;
+			return 0;
+		}
+
+		if(_alpm_check_pgp_helper(db->handle, dbpath, NULL,
+					level & ALPM_SIG_DATABASE_OPTIONAL, level & ALPM_SIG_DATABASE_MARGINAL_OK,
+					level & ALPM_SIG_DATABASE_UNKNOWN_OK, ALPM_ERR_DB_INVALID_SIG)) {
+			return 1;
+		}
+	}
+
+valid:
+	db->status |= DB_STATUS_VALID;
+	return 0;
+}
+
 /** Update a package database
  *
  * An update of the package database \a db will be attempted. Unless
  * \a force is true, the update will only be performed if the remote
  * database was modified since the last update.
  *
- * A transaction is necessary for this operation, in order to obtain a
- * database lock. During this transaction the front-end will be informed
- * of the download progress of the database via the download callback.
+ * This operation requires a database lock, and will return an applicable error
+ * if the lock could not be obtained.
  *
  * Example:
  * @code
  * alpm_list_t *syncs = alpm_option_get_syncdbs();
- * if(alpm_trans_init(0, NULL, NULL, NULL) == 0) {
- *     for(i = syncs; i; i = alpm_list_next(i)) {
- *         pmdb_t *db = alpm_list_getdata(i);
- *         result = alpm_db_update(0, db);
- *         alpm_trans_release();
+ * for(i = syncs; i; i = alpm_list_next(i)) {
+ *     alpm_db_t *db = alpm_list_getdata(i);
+ *     result = alpm_db_update(0, db);
  *
- *         if(result < 0) {
- *	           printf("Unable to update database: %s\n", alpm_strerrorlast());
- *         } else if(result == 1) {
- *             printf("Database already up to date\n");
- *         } else {
- *             printf("Database updated\n");
- *         }
+ *     if(result < 0) {
+ *	       printf("Unable to update database: %s\n", alpm_strerrorlast());
+ *     } else if(result == 1) {
+ *         printf("Database already up to date\n");
+ *     } else {
+ *         printf("Database updated\n");
  *     }
  * }
  * @endcode
@@ -77,78 +139,175 @@
  * @return 0 on success, -1 on error (pm_errno is set accordingly), 1 if up to
  * to date
  */
-int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
+int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
 {
-	char *dbfile, *syncpath;
-	const char *dbpath;
-	struct stat buf;
-	size_t len;
-	int ret;
+	char *syncpath;
+	alpm_list_t *i;
+	int ret = -1;
 	mode_t oldmask;
-
-	ALPM_LOG_FUNC;
+	alpm_handle_t *handle;
+	alpm_siglevel_t level;
 
 	/* Sanity checks */
-	ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
-	ASSERT(db != NULL && db != handle->db_local, RET_ERR(PM_ERR_WRONG_ARGS, -1));
+	ASSERT(db != NULL, return -1);
+	handle = db->handle;
+	handle->pm_errno = 0;
+	ASSERT(db != handle->db_local, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+	ASSERT(db->servers != NULL, RET_ERR(handle, ALPM_ERR_SERVER_NONE, -1));
+
+	syncpath = get_sync_dir(handle);
+	if(!syncpath) {
+		return -1;
+	}
 
-	if(!alpm_list_find_ptr(handle->dbs_sync, db)) {
-		RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
+	/* make sure we have a sane umask */
+	oldmask = umask(0022);
+
+	level = alpm_db_get_siglevel(db);
+
+	/* attempt to grab a lock */
+	if(_alpm_handle_lock(handle)) {
+		RET_ERR(handle, ALPM_ERR_HANDLE_LOCK, -1);
 	}
 
-	len = strlen(db->treename) + 4;
-	MALLOC(dbfile, len, RET_ERR(PM_ERR_MEMORY, -1));
-	sprintf(dbfile, "%s.db", db->treename);
+	for(i = db->servers; i; i = i->next) {
+		const char *server = i->data;
+		struct dload_payload *payload;
+		size_t len;
+		int sig_ret = 0;
 
-	dbpath = alpm_option_get_dbpath();
-	len = strlen(dbpath) + 6;
-	MALLOC(syncpath, len, RET_ERR(PM_ERR_MEMORY, -1));
-	sprintf(syncpath, "%s%s", dbpath, "sync/");
+		CALLOC(payload, 1, sizeof(*payload), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
 
-	/* make sure we have a sane umask */
-	oldmask = umask(0022);
+		/* set hard upper limit of 25MiB */
+		payload->max_size = 25 * 1024 * 1024;
 
-	if(stat(syncpath, &buf) != 0) {
-		_alpm_log(PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
-				syncpath);
-		if(_alpm_makepath(syncpath) != 0) {
-			free(dbfile);
-			free(syncpath);
-			RET_ERR(PM_ERR_SYSTEM, -1);
+		/* print server + filename into a buffer (leave space for .sig) */
+		len = strlen(server) + strlen(db->treename) + 9;
+		CALLOC(payload->fileurl, len, sizeof(char), RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+		snprintf(payload->fileurl, len, "%s/%s.db", server, db->treename);
+		payload->handle = handle;
+		payload->force = force;
+
+		ret = _alpm_download(payload, syncpath, NULL);
+
+		if(ret == 0 && (level & ALPM_SIG_DATABASE)) {
+			/* an existing sig file is no good at this point */
+			char *sigpath = _alpm_db_sig_path(db);
+			if(!sigpath) {
+				ret = -1;
+				break;
+			}
+			unlink(sigpath);
+			free(sigpath);
+
+			/* if we downloaded a DB, we want the .sig from the same server */
+			snprintf(payload->fileurl, len, "%s/%s.db.sig", server, db->treename);
+			payload->handle = handle;
+			payload->force = 1;
+			payload->errors_ok = (level & ALPM_SIG_DATABASE_OPTIONAL);
+
+			/* set hard upper limit of 16KiB */
+			payload->max_size = 16 * 1024;
+
+			sig_ret = _alpm_download(payload, syncpath, NULL);
+			/* errors_ok suppresses error messages, but not the return code */
+			sig_ret = payload->errors_ok ? 0 : sig_ret;
 		}
-	} else if(!S_ISDIR(buf.st_mode)) {
-		_alpm_log(PM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
-		if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) {
-			free(dbfile);
-			free(syncpath);
-			RET_ERR(PM_ERR_SYSTEM, -1);
+
+		_alpm_dload_payload_free(payload);
+		if(ret != -1 && sig_ret != -1) {
+			break;
 		}
 	}
 
-	ret = _alpm_download_single_file(dbfile, db->servers, syncpath, force);
-	free(dbfile);
-	free(syncpath);
-	umask(oldmask);
-
 	if(ret == 1) {
 		/* files match, do nothing */
-		pm_errno = 0;
-		return(1);
+		handle->pm_errno = 0;
+		goto cleanup;
 	} else if(ret == -1) {
 		/* pm_errno was set by the download code */
-		_alpm_log(PM_LOG_DEBUG, "failed to sync db: %s\n", alpm_strerrorlast());
-		return(-1);
+		_alpm_log(handle, ALPM_LOG_DEBUG, "failed to sync db: %s\n",
+				alpm_strerror(handle->pm_errno));
+		goto cleanup;
 	}
 
 	/* Cache needs to be rebuilt */
 	_alpm_db_free_pkgcache(db);
 
-	return(0);
+	db->status &= ~DB_STATUS_VALID;
+	if(sync_db_validate(db)) {
+		/* pm_errno should be set */
+		ret = -1;
+	}
+
+cleanup:
+
+	if(_alpm_handle_unlock(handle)) {
+		_alpm_log(handle, ALPM_LOG_WARNING, _("could not remove lock file %s\n"),
+				alpm_option_get_lockfile(handle));
+	}
+	free(syncpath);
+	umask(oldmask);
+	return ret;
 }
 
 /* Forward decl so I don't reorganize the whole file right now */
-static int sync_db_read(pmdb_t *db, struct archive *archive,
-		struct archive_entry *entry, pmpkg_t *likely_pkg);
+static int sync_db_read(alpm_db_t *db, struct archive *archive,
+		struct archive_entry *entry, alpm_pkg_t **likely_pkg);
+
+static alpm_pkg_t *load_pkg_for_entry(alpm_db_t *db, const char *entryname,
+		const char **entry_filename, alpm_pkg_t *likely_pkg)
+{
+	char *pkgname = NULL, *pkgver = NULL;
+	unsigned long pkgname_hash;
+	alpm_pkg_t *pkg;
+
+	/* get package and db file names */
+	if(entry_filename) {
+		char *fname = strrchr(entryname, '/');
+		if(fname) {
+			*entry_filename = fname + 1;
+		} else {
+			*entry_filename = NULL;
+		}
+	}
+	if(_alpm_splitname(entryname, &pkgname, &pkgver, &pkgname_hash) != 0) {
+		_alpm_log(db->handle, ALPM_LOG_ERROR,
+				_("invalid name for database entry '%s'\n"), entryname);
+		return NULL;
+	}
+
+	if(likely_pkg && strcmp(likely_pkg->name, pkgname) == 0) {
+		pkg = likely_pkg;
+	} else {
+		pkg = _alpm_pkghash_find(db->pkgcache, pkgname);
+	}
+	if(pkg == NULL) {
+		pkg = _alpm_pkg_new();
+		if(pkg == NULL) {
+			RET_ERR(db->handle, ALPM_ERR_MEMORY, NULL);
+		}
+
+		pkg->name = pkgname;
+		pkg->version = pkgver;
+		pkg->name_hash = pkgname_hash;
+
+		pkg->origin = PKG_FROM_SYNCDB;
+		pkg->origin_data.db = db;
+		pkg->ops = &default_pkg_ops;
+		pkg->handle = db->handle;
+
+		/* add to the collection */
+		_alpm_log(db->handle, ALPM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
+				pkg->name, db->treename);
+		db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
+	} else {
+		free(pkgname);
+		free(pkgver);
+	}
+
+	return pkg;
+}
 
 /*
  * This is the data table used to generate the estimating function below.
@@ -206,10 +365,10 @@ static size_t estimate_package_count(struct stat *st, struct archive *archive)
 			/* assume it is at least somewhat compressed */
 			per_package = 200;
 	}
-	return((size_t)(st->st_size / per_package) + 1);
+	return (size_t)((st->st_size / per_package) + 1);
 }
 
-static int sync_db_populate(pmdb_t *db)
+static int sync_db_populate(alpm_db_t *db)
 {
 	const char *dbpath;
 	size_t est_count;
@@ -217,14 +376,10 @@ static int sync_db_populate(pmdb_t *db)
 	struct stat buf;
 	struct archive *archive;
 	struct archive_entry *entry;
-	pmpkg_t *pkg = NULL;
-
-	ALPM_LOG_FUNC;
-
-	ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
+	alpm_pkg_t *pkg = NULL;
 
 	if((archive = archive_read_new()) == NULL) {
-		RET_ERR(PM_ERR_LIBARCHIVE, -1);
+		RET_ERR(db->handle, ALPM_ERR_LIBARCHIVE, -1);
 	}
 
 	archive_read_support_compression_all(archive);
@@ -236,24 +391,24 @@ static int sync_db_populate(pmdb_t *db)
 		return -1;
 	}
 
-	_alpm_log(PM_LOG_DEBUG, "opening database archive %s\n", dbpath);
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "opening database archive %s\n", dbpath);
 
 	if(archive_read_open_filename(archive, dbpath,
 				ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
-		_alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
+		_alpm_log(db->handle, ALPM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
 				archive_error_string(archive));
 		archive_read_finish(archive);
-		RET_ERR(PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	if(stat(dbpath, &buf) != 0) {
-		RET_ERR(PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, ALPM_ERR_DB_OPEN, -1);
 	}
 	est_count = estimate_package_count(&buf, archive);
 
 	/* initialize hash at 66% full */
 	db->pkgcache = _alpm_pkghash_create(est_count * 3 / 2);
 	if(db->pkgcache == NULL) {
-		RET_ERR(PM_ERR_MEMORY, -1);
+		RET_ERR(db->handle, ALPM_ERR_MEMORY, -1);
 	}
 
 	while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
@@ -262,139 +417,94 @@ static int sync_db_populate(pmdb_t *db)
 		st = archive_entry_stat(entry);
 
 		if(S_ISDIR(st->st_mode)) {
-			const char *name;
-
-			pkg = _alpm_pkg_new();
-			if(pkg == NULL) {
-				archive_read_finish(archive);
-				RET_ERR(PM_ERR_MEMORY, -1);
-			}
-
-			name = archive_entry_pathname(entry);
-
-			if(_alpm_splitname(name, pkg) != 0) {
-				_alpm_log(PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
-						name);
-				_alpm_pkg_free(pkg);
-				continue;
-			}
-
-			/* duplicated database entries are not allowed */
-			if(_alpm_pkghash_find(db->pkgcache, pkg->name)) {
-				_alpm_log(PM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
-				_alpm_pkg_free(pkg);
-				continue;
-			}
-
-			pkg->origin = PKG_FROM_SYNCDB;
-			pkg->ops = &default_pkg_ops;
-			pkg->origin_data.db = db;
-
-			/* add to the collection */
-			_alpm_log(PM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
-					pkg->name, db->treename);
-			db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
-			count++;
+			continue;
 		} else {
 			/* we have desc, depends or deltas - parse it */
-			sync_db_read(db, archive, entry, pkg);
+			if(sync_db_read(db, archive, entry, &pkg) != 0) {
+				_alpm_log(db->handle, ALPM_LOG_ERROR,
+						_("could not parse package description file '%s' from db '%s'\n"),
+						archive_entry_pathname(entry), db->treename);
+				continue;
+			}
 		}
 	}
 
+	count = alpm_list_count(db->pkgcache->list);
+
 	if(count > 0) {
 		db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
 	}
 	archive_read_finish(archive);
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+			count, db->treename);
 
-	return(count);
+	return count;
 }
 
-#define READ_NEXT(s) do { \
+#define READ_NEXT() do { \
 	if(_alpm_archive_fgets(archive, &buf) != ARCHIVE_OK) goto error; \
-	s = _alpm_strtrim(buf.line); \
+	line = _alpm_strtrim(buf.line); \
 } while(0)
 
 #define READ_AND_STORE(f) do { \
-	READ_NEXT(line); \
+	READ_NEXT(); \
 	STRDUP(f, line, goto error); \
 } while(0)
 
 #define READ_AND_STORE_ALL(f) do { \
 	char *linedup; \
-	READ_NEXT(line); \
+	READ_NEXT(); \
 	if(strlen(line) == 0) break; \
 	STRDUP(linedup, line, goto error); \
 	f = alpm_list_add(f, linedup); \
 } while(1) /* note the while(1) and not (0) */
 
-static int sync_db_read(pmdb_t *db, struct archive *archive,
-		struct archive_entry *entry, pmpkg_t *likely_pkg)
+static int sync_db_read(alpm_db_t *db, struct archive *archive,
+		struct archive_entry *entry, alpm_pkg_t **likely_pkg)
 {
-	const char *entryname = NULL, *filename;
-	char *pkgname, *p, *q;
-	pmpkg_t *pkg;
+	const char *entryname, *filename;
+	alpm_pkg_t *pkg;
 	struct archive_read_buffer buf;
 
-	ALPM_LOG_FUNC;
-
-	if(db == NULL) {
-		RET_ERR(PM_ERR_DB_NULL, -1);
-	}
-
-	if(entry != NULL) {
-		entryname = archive_entry_pathname(entry);
-	}
+	entryname = archive_entry_pathname(entry);
 	if(entryname == NULL) {
-		_alpm_log(PM_LOG_DEBUG, "invalid archive entry provided to _alpm_sync_db_read, skipping\n");
-		return(-1);
+		_alpm_log(db->handle, ALPM_LOG_DEBUG,
+				"invalid archive entry provided to _alpm_sync_db_read, skipping\n");
+		return -1;
 	}
 
-	_alpm_log(PM_LOG_FUNCTION, "loading package data from archive entry %s\n",
+	_alpm_log(db->handle, ALPM_LOG_FUNCTION, "loading package data from archive entry %s\n",
 			entryname);
 
 	memset(&buf, 0, sizeof(buf));
 	/* 512K for a line length seems reasonable */
 	buf.max_line_size = 512 * 1024;
 
-	/* get package and db file names */
-	STRDUP(pkgname, entryname, RET_ERR(PM_ERR_MEMORY, -1));
-	p = pkgname + strlen(pkgname);
-	for(q = --p; *q && *q != '/'; q--);
-	filename = q + 1;
-	for(p = --q; *p && *p != '-'; p--);
-	for(q = --p; *q && *q != '-'; q--);
-	*q = '\0';
-
-	/* package is already in db due to parsing of directory name */
-	if(likely_pkg && strcmp(likely_pkg->name, pkgname) == 0) {
-		pkg = likely_pkg;
-	} else {
-		if(db->pkgcache == NULL) {
-			RET_ERR(PM_ERR_MEMORY, -1);
-		}
-		pkg = _alpm_pkghash_find(db->pkgcache, pkgname);
-	}
+	pkg = load_pkg_for_entry(db, entryname, &filename, *likely_pkg);
+
 	if(pkg == NULL) {
-		_alpm_log(PM_LOG_DEBUG, "package %s not found in %s sync database",
-					pkgname, db->treename);
-		return(-1);
+		_alpm_log(db->handle, ALPM_LOG_DEBUG,
+				"entry %s could not be loaded into %s sync database",
+				entryname, db->treename);
+		return -1;
 	}
 
 	if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0
 			|| strcmp(filename, "deltas") == 0) {
-		while(_alpm_archive_fgets(archive, &buf) == ARCHIVE_OK) {
+		int ret;
+		while((ret = _alpm_archive_fgets(archive, &buf)) == ARCHIVE_OK) {
 			char *line = _alpm_strtrim(buf.line);
 
 			if(strcmp(line, "%NAME%") == 0) {
-				READ_NEXT(line);
+				READ_NEXT();
 				if(strcmp(line, pkg->name) != 0) {
-					_alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: name "
+					_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: name "
 								"mismatch on package %s\n"), db->treename, pkg->name);
 				}
 			} else if(strcmp(line, "%VERSION%") == 0) {
-				READ_NEXT(line);
+				READ_NEXT();
 				if(strcmp(line, pkg->version) != 0) {
-					_alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: version "
+					_alpm_log(db->handle, ALPM_LOG_ERROR, _("%s database is inconsistent: version "
 								"mismatch on package %s\n"), db->treename, pkg->name);
 				}
 			} else if(strcmp(line, "%FILENAME%") == 0) {
@@ -410,7 +520,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
 			} else if(strcmp(line, "%ARCH%") == 0) {
 				READ_AND_STORE(pkg->arch);
 			} else if(strcmp(line, "%BUILDDATE%") == 0) {
-				READ_NEXT(line);
+				READ_NEXT();
 				pkg->builddate = _alpm_parsedate(line);
 			} else if(strcmp(line, "%PACKAGER%") == 0) {
 				READ_AND_STORE(pkg->packager);
@@ -419,29 +529,28 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
 				 * pkginfo_t struct. This can be done b/c CSIZE is currently only used
 				 * in sync databases, and SIZE is only used in local databases.
 				 */
-				READ_NEXT(line);
+				READ_NEXT();
 				pkg->size = atol(line);
 				/* also store this value to isize if isize is unset */
 				if(pkg->isize == 0) {
 					pkg->isize = pkg->size;
 				}
 			} else if(strcmp(line, "%ISIZE%") == 0) {
-				READ_NEXT(line);
+				READ_NEXT();
 				pkg->isize = atol(line);
 			} else if(strcmp(line, "%MD5SUM%") == 0) {
 				READ_AND_STORE(pkg->md5sum);
 			} else if(strcmp(line, "%SHA256SUM%") == 0) {
 				/* we don't do anything with this value right now */
-				READ_NEXT(line);
+				READ_NEXT();
 			} else if(strcmp(line, "%PGPSIG%") == 0) {
-				/* we don't do anything with this value right now */
-				READ_NEXT(line);
+				READ_AND_STORE(pkg->base64_sig);
 			} else if(strcmp(line, "%REPLACES%") == 0) {
 				READ_AND_STORE_ALL(pkg->replaces);
 			} else if(strcmp(line, "%DEPENDS%") == 0) {
 				/* Different than the rest because of the _alpm_splitdep call. */
 				while(1) {
-					READ_NEXT(line);
+					READ_NEXT();
 					if(strlen(line) == 0) break;
 					pkg->depends = alpm_list_add(pkg->depends, _alpm_splitdep(line));
 				}
@@ -454,62 +563,55 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
 			} else if(strcmp(line, "%DELTAS%") == 0) {
 				/* Different than the rest because of the _alpm_delta_parse call. */
 				while(1) {
-					READ_NEXT(line);
+					READ_NEXT();
 					if(strlen(line) == 0) break;
 					pkg->deltas = alpm_list_add(pkg->deltas, _alpm_delta_parse(line));
 				}
 			}
 		}
+		if(ret != ARCHIVE_EOF) {
+			goto error;
+		}
+		*likely_pkg = pkg;
 	} else if(strcmp(filename, "files") == 0) {
 		/* currently do nothing with this file */
 	} else {
 		/* unknown database file */
-		_alpm_log(PM_LOG_DEBUG, "unknown database file: %s\n", filename);
+		_alpm_log(db->handle, ALPM_LOG_DEBUG, "unknown database file: %s\n", filename);
 	}
 
-error:
-	FREE(pkgname);
-	/* TODO: return 0 always? */
-	return(0);
-}
+	return 0;
 
-static int sync_db_version(pmdb_t *db)
-{
-	return(2);
+error:
+	_alpm_log(db->handle, ALPM_LOG_DEBUG, "error parsing database file: %s\n", filename);
+	return -1;
 }
 
 struct db_operations sync_db_ops = {
+	.validate         = sync_db_validate,
 	.populate         = sync_db_populate,
 	.unregister       = _alpm_db_unregister,
-	.version          = sync_db_version,
 };
 
-pmdb_t *_alpm_db_register_sync(const char *treename)
+alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
+		alpm_siglevel_t level)
 {
-	pmdb_t *db;
-	alpm_list_t *i;
-
-	ALPM_LOG_FUNC;
-
-	for(i = handle->dbs_sync; i; i = i->next) {
-		pmdb_t *sdb = i->data;
-		if(strcmp(treename, sdb->treename) == 0) {
-			_alpm_log(PM_LOG_DEBUG, "attempt to re-register the '%s' database, using existing\n", sdb->treename);
-			return sdb;
-		}
-	}
+	alpm_db_t *db;
 
-	_alpm_log(PM_LOG_DEBUG, "registering sync database '%s'\n", treename);
+	_alpm_log(handle, ALPM_LOG_DEBUG, "registering sync database '%s'\n", treename);
 
 	db = _alpm_db_new(treename, 0);
 	if(db == NULL) {
-		RET_ERR(PM_ERR_DB_CREATE, NULL);
+		RET_ERR(handle, ALPM_ERR_DB_CREATE, NULL);
 	}
 	db->ops = &sync_db_ops;
+	db->handle = handle;
+	db->siglevel = level;
+
+	sync_db_validate(db);
 
 	handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
-	return(db);
+	return db;
 }
 
-
 /* vim: set ts=2 sw=2 noet: */