1 files changed, 138 insertions, 189 deletions

diff --git a/lib/libalpm/be_local.c b/lib/libalpm/be_local.c
index d5edf34c..50066883 100644
--- a/lib/libalpm/be_local.c
+++ b/lib/libalpm/be_local.c
@@ -1,5 +1,5 @@
 /*
- *  be_local.c
+ *  be_local.c : backend for the local database
  *
  *  Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
  *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
@@ -31,10 +31,6 @@
 #include <time.h>
 #include <limits.h> /* PATH_MAX */
 
-/* libarchive */
-#include <archive.h>
-#include <archive_entry.h>
-
 /* libalpm */
 #include "db.h"
 #include "alpm_list.h"
@@ -43,16 +39,10 @@
 #include "alpm.h"
 #include "handle.h"
 #include "package.h"
-#include "group.h"
 #include "deps.h"
-#include "dload.h"
-
 
 #define LAZY_LOAD(info, errret) \
 	do { \
-		ALPM_LOG_FUNC; \
-		ASSERT(handle != NULL, return(errret)); \
-		ASSERT(pkg != NULL, return(errret)); \
 		if(pkg->origin != PKG_FROM_FILE && !(pkg->infolevel & info)) { \
 			_alpm_local_db_read(pkg->origin_data.db, pkg, info); \
 		} \
@@ -71,18 +61,6 @@ static const char *_cache_get_filename(pmpkg_t *pkg)
 	return pkg->filename;
 }
 
-static const char *_cache_get_name(pmpkg_t *pkg)
-{
-	ASSERT(pkg != NULL, return(NULL));
-	return pkg->name;
-}
-
-static const char *_cache_get_version(pmpkg_t *pkg)
-{
-	ASSERT(pkg != NULL, return(NULL));
-	return pkg->version;
-}
-
 static const char *_cache_get_desc(pmpkg_t *pkg)
 {
 	LAZY_LOAD(INFRQ_DESC, NULL);
@@ -157,12 +135,6 @@ static alpm_list_t *_cache_get_groups(pmpkg_t *pkg)
 
 static int _cache_has_scriptlet(pmpkg_t *pkg)
 {
-	ALPM_LOG_FUNC;
-
-	/* Sanity checks */
-	ASSERT(handle != NULL, return(-1));
-	ASSERT(pkg != NULL, return(-1));
-
 	if(!(pkg->infolevel & INFRQ_SCRIPTLET)) {
 		_alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_SCRIPTLET);
 	}
@@ -200,19 +172,13 @@ static alpm_list_t *_cache_get_replaces(pmpkg_t *pkg)
 }
 
 /* local packages can not have deltas */
-static alpm_list_t *_cache_get_deltas(pmpkg_t *pkg)
+static alpm_list_t *_cache_get_deltas(pmpkg_t UNUSED *pkg)
 {
 	return NULL;
 }
 
 static alpm_list_t *_cache_get_files(pmpkg_t *pkg)
 {
-	ALPM_LOG_FUNC;
-
-	/* Sanity checks */
-	ASSERT(handle != NULL, return(NULL));
-	ASSERT(pkg != NULL, return(NULL));
-
 	if(pkg->origin == PKG_FROM_LOCALDB
 		 && !(pkg->infolevel & INFRQ_FILES)) {
 		_alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
@@ -222,12 +188,6 @@ static alpm_list_t *_cache_get_files(pmpkg_t *pkg)
 
 static alpm_list_t *_cache_get_backup(pmpkg_t *pkg)
 {
-	ALPM_LOG_FUNC;
-
-	/* Sanity checks */
-	ASSERT(handle != NULL, return(NULL));
-	ASSERT(pkg != NULL, return(NULL));
-
 	if(pkg->origin == PKG_FROM_LOCALDB
 		 && !(pkg->infolevel & INFRQ_FILES)) {
 		_alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
@@ -243,15 +203,9 @@ static alpm_list_t *_cache_get_backup(pmpkg_t *pkg)
  */
 static void *_cache_changelog_open(pmpkg_t *pkg)
 {
-	ALPM_LOG_FUNC;
-
-	/* Sanity checks */
-	ASSERT(handle != NULL, return(NULL));
-	ASSERT(pkg != NULL, return(NULL));
-
 	char clfile[PATH_MAX];
 	snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
-			alpm_option_get_dbpath(),
+			alpm_option_get_dbpath(pkg->handle),
 			alpm_db_get_name(alpm_pkg_get_db(pkg)),
 			alpm_pkg_get_name(pkg),
 			alpm_pkg_get_version(pkg));
@@ -268,18 +222,11 @@ static void *_cache_changelog_open(pmpkg_t *pkg)
  * @return the number of characters read, or 0 if there is no more data
  */
 static size_t _cache_changelog_read(void *ptr, size_t size,
-		const pmpkg_t *pkg, const void *fp)
+		const pmpkg_t UNUSED *pkg, const void *fp)
 {
-	return ( fread(ptr, 1, size, (FILE*)fp) );
+	return fread(ptr, 1, size, (FILE *)fp);
 }
 
-/*
-static int _cache_changelog_feof(const pmpkg_t *pkg, void *fp)
-{
-	return( feof((FILE*)fp) );
-}
-*/
-
 /**
  * Close a package changelog for reading. Similar to fclose in functionality,
  * except that the 'file stream' is from the database.
@@ -287,9 +234,9 @@ static int _cache_changelog_feof(const pmpkg_t *pkg, void *fp)
  * @param fp a 'file stream' to the package changelog
  * @return whether closing the package changelog stream was successful
  */
-static int _cache_changelog_close(const pmpkg_t *pkg, void *fp)
+static int _cache_changelog_close(const pmpkg_t UNUSED *pkg, void *fp)
 {
-	return( fclose((FILE*)fp) );
+	return fclose((FILE *)fp);
 }
 
 
@@ -299,8 +246,6 @@ static int _cache_changelog_close(const pmpkg_t *pkg, void *fp)
  */
 static struct pkg_operations local_pkg_ops = {
 	.get_filename    = _cache_get_filename,
-	.get_name        = _cache_get_name,
-	.get_version     = _cache_get_version,
 	.get_desc        = _cache_get_desc,
 	.get_url         = _cache_get_url,
 	.get_builddate   = _cache_get_builddate,
@@ -334,25 +279,25 @@ static int checkdbdir(pmdb_t *db)
 	const char *path = _alpm_db_path(db);
 
 	if(stat(path, &buf) != 0) {
-		_alpm_log(PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
+		_alpm_log(db->handle, PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
 				path);
 		if(_alpm_makepath(path) != 0) {
-			RET_ERR(PM_ERR_SYSTEM, -1);
+			RET_ERR(db->handle, PM_ERR_SYSTEM, -1);
 		}
 	} else if(!S_ISDIR(buf.st_mode)) {
-		_alpm_log(PM_LOG_WARNING, _("removing invalid database: %s\n"), path);
+		_alpm_log(db->handle, PM_LOG_WARNING, _("removing invalid database: %s\n"), path);
 		if(unlink(path) != 0 || _alpm_makepath(path) != 0) {
-			RET_ERR(PM_ERR_SYSTEM, -1);
+			RET_ERR(db->handle, PM_ERR_SYSTEM, -1);
 		}
 	}
-	return(0);
+	return 0;
 }
 
 static int is_dir(const char *path, struct dirent *entry)
 {
 #ifdef HAVE_STRUCT_DIRENT_D_TYPE
 	if(entry->d_type != DT_UNKNOWN) {
-		return(entry->d_type == DT_DIR);
+		return (entry->d_type == DT_DIR);
 	}
 #endif
 	{
@@ -361,12 +306,68 @@ static int is_dir(const char *path, struct dirent *entry)
 
 		snprintf(buffer, PATH_MAX, "%s/%s", path, entry->d_name);
 
-		if (!stat(buffer, &sbuf)) {
-			return(S_ISDIR(sbuf.st_mode));
+		if(!stat(buffer, &sbuf)) {
+			return S_ISDIR(sbuf.st_mode);
+		}
+	}
+
+	return 0;
+}
+
+static int local_db_validate(pmdb_t *db)
+{
+	struct dirent *ent = NULL;
+	const char *dbpath;
+	DIR *dbdir;
+	int ret = -1;
+
+	if(db->status & DB_STATUS_VALID) {
+		return 0;
+	}
+
+	dbpath = _alpm_db_path(db);
+	if(dbpath == NULL) {
+		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+	}
+	dbdir = opendir(dbpath);
+	if(dbdir == NULL) {
+		if(errno == ENOENT) {
+			/* database dir doesn't exist yet */
+			db->status |= DB_STATUS_VALID;
+			return 0;
+		} else {
+			RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
+		}
+	}
+
+	while((ent = readdir(dbdir)) != NULL) {
+		const char *name = ent->d_name;
+		char path[PATH_MAX];
+
+		if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
+			continue;
+		}
+		if(!is_dir(dbpath, ent)) {
+			continue;
+		}
+
+		snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name);
+		if(access(path, F_OK) == 0) {
+			/* we found a depends file- bail */
+			db->handle->pm_errno = PM_ERR_DB_VERSION;
+			goto done;
 		}
 	}
+	/* we found no depends file after full scan */
+	db->status |= DB_STATUS_VALID;
+	ret = 0;
+
+done:
+	if(dbdir) {
+		closedir(dbdir);
+	}
 
-	return(0);
+	return ret;
 }
 
 static int local_db_populate(pmdb_t *db)
@@ -378,25 +379,22 @@ static int local_db_populate(pmdb_t *db)
 	const char *dbpath;
 	DIR *dbdir;
 
-	ALPM_LOG_FUNC;
-
-	ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
-
 	dbpath = _alpm_db_path(db);
 	if(dbpath == NULL) {
 		/* pm_errno set in _alpm_db_path() */
 		return -1;
 	}
+
 	dbdir = opendir(dbpath);
 	if(dbdir == NULL) {
 		if(errno == ENOENT) {
 			/* no database existing yet is not an error */
-			return(0);
+			return 0;
 		}
-		RET_ERR(PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
 	}
 	if(fstat(dirfd(dbdir), &buf) != 0) {
-		RET_ERR(PM_ERR_DB_OPEN, -1);
+		RET_ERR(db->handle, PM_ERR_DB_OPEN, -1);
 	}
 	if(buf.st_nlink >= 2) {
 		est_count = buf.st_nlink;
@@ -420,7 +418,7 @@ static int local_db_populate(pmdb_t *db)
 	db->pkgcache = _alpm_pkghash_create(est_count * 2);
 	if(db->pkgcache == NULL){
 		closedir(dbdir);
-		RET_ERR(PM_ERR_MEMORY, -1);
+		RET_ERR(db->handle, PM_ERR_MEMORY, -1);
 	}
 
 	while((ent = readdir(dbdir)) != NULL) {
@@ -438,11 +436,12 @@ static int local_db_populate(pmdb_t *db)
 		pkg = _alpm_pkg_new();
 		if(pkg == NULL) {
 			closedir(dbdir);
-			RET_ERR(PM_ERR_MEMORY, -1);
+			RET_ERR(db->handle, PM_ERR_MEMORY, -1);
 		}
 		/* split the db entry name */
-		if(_alpm_splitname(name, pkg) != 0) {
-			_alpm_log(PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
+		if(_alpm_splitname(name, &(pkg->name), &(pkg->version),
+					&(pkg->name_hash)) != 0) {
+			_alpm_log(db->handle, PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
 					name);
 			_alpm_pkg_free(pkg);
 			continue;
@@ -450,7 +449,7 @@ static int local_db_populate(pmdb_t *db)
 
 		/* 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_log(db->handle, PM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
 			_alpm_pkg_free(pkg);
 			continue;
 		}
@@ -458,16 +457,17 @@ static int local_db_populate(pmdb_t *db)
 		pkg->origin = PKG_FROM_LOCALDB;
 		pkg->origin_data.db = db;
 		pkg->ops = &local_pkg_ops;
+		pkg->handle = db->handle;
 
 		/* explicitly read with only 'BASE' data, accessors will handle the rest */
 		if(_alpm_local_db_read(db, pkg, INFRQ_BASE) == -1) {
-			_alpm_log(PM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
+			_alpm_log(db->handle, PM_LOG_ERROR, _("corrupted database entry '%s'\n"), name);
 			_alpm_pkg_free(pkg);
 			continue;
 		}
 
 		/* add to the collection */
-		_alpm_log(PM_LOG_DEBUG, "adding '%s' to package cache for db '%s'\n",
+		_alpm_log(db->handle, 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++;
@@ -477,7 +477,10 @@ static int local_db_populate(pmdb_t *db)
 	if(count > 0) {
 		db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
 	}
-	return(count);
+	_alpm_log(db->handle, PM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
+			count, db->treename);
+
+	return count;
 }
 
 /* Note: the return value must be freed by the caller */
@@ -489,9 +492,9 @@ static char *get_pkgpath(pmdb_t *db, pmpkg_t *info)
 
 	dbpath = _alpm_db_path(db);
 	len = strlen(dbpath) + strlen(info->name) + strlen(info->version) + 3;
-	MALLOC(pkgpath, len, RET_ERR(PM_ERR_MEMORY, NULL));
+	MALLOC(pkgpath, len, RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
 	sprintf(pkgpath, "%s%s-%s/", dbpath, info->name, info->version);
-	return(pkgpath);
+	return pkgpath;
 }
 
 
@@ -502,22 +505,17 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	char line[1024];
 	char *pkgpath = NULL;
 
-	ALPM_LOG_FUNC;
-
-	if(db == NULL) {
-		RET_ERR(PM_ERR_DB_NULL, -1);
-	}
-
 	if(info == NULL || info->name == NULL || info->version == NULL) {
-		_alpm_log(PM_LOG_DEBUG, "invalid package entry provided to _alpm_local_db_read, skipping\n");
-		return(-1);
+		_alpm_log(db->handle, PM_LOG_DEBUG,
+				"invalid package entry provided to _alpm_local_db_read, skipping\n");
+		return -1;
 	}
 
 	if(info->origin != PKG_FROM_LOCALDB) {
-		_alpm_log(PM_LOG_DEBUG,
+		_alpm_log(db->handle, PM_LOG_DEBUG,
 				"request to read info for a non-local package '%s', skipping...\n",
 				info->name);
-		return(-1);
+		return -1;
 	}
 
 	/* bitmask logic here:
@@ -527,9 +525,9 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	 * == to inforeq? nope, we need to load more info. */
 	if((info->infolevel & inforeq) == inforeq) {
 		/* already loaded all of this info, do nothing */
-		return(0);
+		return 0;
 	}
-	_alpm_log(PM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
+	_alpm_log(db->handle, PM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
 			info->name, inforeq);
 
 	/* clear out 'line', to be certain - and to make valgrind happy */
@@ -539,7 +537,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 
 	if(access(pkgpath, F_OK)) {
 		/* directory doesn't exist or can't be opened */
-		_alpm_log(PM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
+		_alpm_log(db->handle, PM_LOG_DEBUG, "cannot find '%s-%s' in db '%s'\n",
 				info->name, info->version, db->treename);
 		goto error;
 	}
@@ -548,7 +546,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	if(inforeq & INFRQ_DESC && !(info->infolevel & INFRQ_DESC)) {
 		snprintf(path, PATH_MAX, "%sdesc", pkgpath);
 		if((fp = fopen(path, "r")) == NULL) {
-			_alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
 			goto error;
 		}
 		while(!feof(fp)) {
@@ -561,7 +559,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 					goto error;
 				}
 				if(strcmp(_alpm_strtrim(line), info->name) != 0) {
-					_alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: name "
+					_alpm_log(db->handle, PM_LOG_ERROR, _("%s database is inconsistent: name "
 								"mismatch on package %s\n"), db->treename, info->name);
 				}
 			} else if(strcmp(line, "%VERSION%") == 0) {
@@ -569,7 +567,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 					goto error;
 				}
 				if(strcmp(_alpm_strtrim(line), info->version) != 0) {
-					_alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: version "
+					_alpm_log(db->handle, PM_LOG_ERROR, _("%s database is inconsistent: version "
 								"mismatch on package %s\n"), db->treename, info->name);
 				}
 			} else if(strcmp(line, "%DESC%") == 0) {
@@ -672,7 +670,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	if(inforeq & INFRQ_FILES && !(info->infolevel & INFRQ_FILES)) {
 		snprintf(path, PATH_MAX, "%sfiles", pkgpath);
 		if((fp = fopen(path, "r")) == NULL) {
-			_alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
 			goto error;
 		}
 		while(fgets(line, sizeof(line), fp)) {
@@ -685,9 +683,12 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 				}
 			} else if(strcmp(line, "%BACKUP%") == 0) {
 				while(fgets(line, sizeof(line), fp) && strlen(_alpm_strtrim(line))) {
-					char *linedup;
-					STRDUP(linedup, line, goto error);
-					info->backup = alpm_list_add(info->backup, linedup);
+					pmbackup_t *backup;
+					CALLOC(backup, 1, sizeof(pmbackup_t), goto error);
+					if(_alpm_split_backup(line, &backup)) {
+						goto error;
+					}
+					info->backup = alpm_list_add(info->backup, backup);
 				}
 			}
 		}
@@ -707,14 +708,14 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	info->infolevel |= inforeq;
 
 	free(pkgpath);
-	return(0);
+	return 0;
 
 error:
 	free(pkgpath);
 	if(fp) {
 		fclose(fp);
 	}
-	return(-1);
+	return -1;
 }
 
 int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
@@ -724,21 +725,21 @@ int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
 	char *pkgpath = NULL;
 
 	if(checkdbdir(db) != 0) {
-		return(-1);
+		return -1;
 	}
 
 	oldmask = umask(0000);
 	pkgpath = get_pkgpath(db, info);
 
 	if((retval = mkdir(pkgpath, 0755)) != 0) {
-		_alpm_log(PM_LOG_ERROR, _("could not create directory %s: %s\n"),
+		_alpm_log(db->handle, PM_LOG_ERROR, _("could not create directory %s: %s\n"),
 				pkgpath, strerror(errno));
 	}
 
 	free(pkgpath);
 	umask(oldmask);
 
-	return(retval);
+	return retval;
 }
 
 int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
@@ -750,10 +751,8 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	int retval = 0;
 	char *pkgpath = NULL;
 
-	ALPM_LOG_FUNC;
-
 	if(db == NULL || info == NULL) {
-		return(-1);
+		return -1;
 	}
 
 	pkgpath = get_pkgpath(db, info);
@@ -762,16 +761,17 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 	oldmask = umask(0022);
 
 	if(strcmp(db->treename, "local") != 0) {
-		return(-1);
+		return -1;
 	}
 
 	/* DESC */
 	if(inforeq & INFRQ_DESC) {
-		_alpm_log(PM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
+		_alpm_log(db->handle, PM_LOG_DEBUG, "writing %s-%s DESC information back to db\n",
 				info->name, info->version);
 		snprintf(path, PATH_MAX, "%sdesc", pkgpath);
 		if((fp = fopen(path, "w")) == NULL) {
-			_alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"),
+					path, strerror(errno));
 			retval = -1;
 			goto cleanup;
 		}
@@ -868,11 +868,12 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 
 	/* FILES */
 	if(inforeq & INFRQ_FILES) {
-		_alpm_log(PM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
+		_alpm_log(db->handle, PM_LOG_DEBUG, "writing %s-%s FILES information back to db\n",
 				info->name, info->version);
 		snprintf(path, PATH_MAX, "%sfiles", pkgpath);
 		if((fp = fopen(path, "w")) == NULL) {
-			_alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), path, strerror(errno));
+			_alpm_log(db->handle, PM_LOG_ERROR, _("could not open file %s: %s\n"),
+					path, strerror(errno));
 			retval = -1;
 			goto cleanup;
 		}
@@ -886,7 +887,8 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
 		if(info->backup) {
 			fprintf(fp, "%%BACKUP%%\n");
 			for(lp = info->backup; lp; lp = lp->next) {
-				fprintf(fp, "%s\n", (char *)lp->data);
+				pmbackup_t *backup = lp->data;
+				fprintf(fp, "%s\t%s\n", backup->name, backup->hash);
 			}
 			fprintf(fp, "\n");
 		}
@@ -905,7 +907,7 @@ cleanup:
 		fclose(fp);
 	}
 
-	return(retval);
+	return retval;
 }
 
 int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
@@ -913,12 +915,6 @@ int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
 	int ret = 0;
 	char *pkgpath = NULL;
 
-	ALPM_LOG_FUNC;
-
-	if(db == NULL || info == NULL) {
-		RET_ERR(PM_ERR_DB_NULL, -1);
-	}
-
 	pkgpath = get_pkgpath(db, info);
 
 	ret = _alpm_rmrf(pkgpath);
@@ -926,83 +922,36 @@ int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
 	if(ret != 0) {
 		ret = -1;
 	}
-	return(ret);
-}
-
-static int local_db_version(pmdb_t *db)
-{
-	struct dirent *ent = NULL;
-	const char *dbpath;
-	DIR *dbdir;
-	int version;
-
-	dbpath = _alpm_db_path(db);
-	if(dbpath == NULL) {
-		RET_ERR(PM_ERR_DB_OPEN, -1);
-	}
-	dbdir = opendir(dbpath);
-	if(dbdir == NULL) {
-		if(errno == ENOENT) {
-			/* database dir doesn't exist yet */
-			version = 2;
-			goto done;
-		} else {
-			RET_ERR(PM_ERR_DB_OPEN, -1);
-		}
-	}
-
-	while((ent = readdir(dbdir)) != NULL) {
-		const char *name = ent->d_name;
-		char path[PATH_MAX];
-
-		if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
-			continue;
-		}
-		if(!is_dir(dbpath, ent)) {
-			continue;
-		}
-
-		snprintf(path, PATH_MAX, "%s%s/depends", dbpath, name);
-		if(access(path, F_OK) == 0) {
-			/* we found a depends file- bail */
-			version = 1;
-			goto done;
-		}
-	}
-	/* we found no depends file after full scan */
-	version = 2;
-
-done:
-	if(dbdir) {
-		closedir(dbdir);
-	}
-
-	_alpm_log(PM_LOG_DEBUG, "local database version %d\n", version);
-	return(version);
+	return ret;
 }
 
 struct db_operations local_db_ops = {
 	.populate         = local_db_populate,
 	.unregister       = _alpm_db_unregister,
-	.version          = local_db_version,
 };
 
-pmdb_t *_alpm_db_register_local(void)
+pmdb_t *_alpm_db_register_local(pmhandle_t *handle)
 {
 	pmdb_t *db;
 
-	ALPM_LOG_FUNC;
-
-	_alpm_log(PM_LOG_DEBUG, "registering local database\n");
+	_alpm_log(handle, PM_LOG_DEBUG, "registering local database\n");
 
 	db = _alpm_db_new("local", 1);
 	if(db == NULL) {
-		RET_ERR(PM_ERR_DB_CREATE, NULL);
+		handle->pm_errno = PM_ERR_DB_CREATE;
+		return NULL;
 	}
 	db->ops = &local_db_ops;
+	db->handle = handle;
+
+	if(local_db_validate(db)) {
+		/* pm_errno set in local_db_validate() */
+		_alpm_db_free(db);
+		return NULL;
+	}
 
 	handle->db_local = db;
-	return(db);
+	return db;
 }
 
 /* vim: set ts=2 sw=2 noet: */