5 files changed, 273 insertions, 177 deletions

diff --git a/src/util/cleanupdelta.c b/src/util/cleanupdelta.c
index 71ba3a47..a45efdcc 100644
--- a/src/util/cleanupdelta.c
+++ b/src/util/cleanupdelta.c
@@ -29,21 +29,23 @@
 
 #define BASENAME "cleanupdelta"
 
+alpm_handle_t *handle = NULL;
+
 static void cleanup(int signum) {
-	if(alpm_release() == -1) {
-		fprintf(stderr, "error releasing alpm: %s\n", alpm_strerrorlast());
+	if(handle && alpm_release(handle) == -1) {
+		fprintf(stderr, "error releasing alpm\n");
 	}
 
 	exit(signum);
 }
 
-static void output_cb(pmloglevel_t level, const char *fmt, va_list args)
+static void output_cb(alpm_loglevel_t level, const char *fmt, va_list args)
 {
 	if(strlen(fmt)) {
 		switch(level) {
-			case PM_LOG_ERROR: printf("error: "); break;
-			case PM_LOG_WARNING: printf("warning: "); break;
-			//case PM_LOG_DEBUG: printf("debug: "); break;
+			case ALPM_LOG_ERROR: printf("error: "); break;
+			case ALPM_LOG_WARNING: printf("warning: "); break;
+			//case ALPM_LOG_DEBUG: printf("debug: "); break;
 			default: return;
 		}
 		vprintf(fmt, args);
@@ -55,7 +57,7 @@ static void checkpkgs(alpm_list_t *pkglist)
 {
 	alpm_list_t *i, *j;
 	for(i = pkglist; i; i = alpm_list_next(i)) {
-		pmpkg_t *pkg = alpm_list_getdata(i);
+		alpm_pkg_t *pkg = alpm_list_getdata(i);
 		alpm_list_t *unused = alpm_pkg_unused_deltas(pkg);
 		for(j = unused; j; j = alpm_list_next(j)) {
 			char *delta = alpm_list_getdata(j);
@@ -65,18 +67,19 @@ static void checkpkgs(alpm_list_t *pkglist)
 	}
 }
 
-static void checkdbs(char *dbpath, alpm_list_t *dbnames) {
+static void checkdbs(const char *dbpath, alpm_list_t *dbnames) {
 	char syncdbpath[PATH_MAX];
-	pmdb_t *db = NULL;
+	alpm_db_t *db = NULL;
 	alpm_list_t *i;
+	const alpm_siglevel_t level = ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
 
 	for(i = dbnames; i; i = alpm_list_next(i)) {
 		char *dbname = alpm_list_getdata(i);
 		snprintf(syncdbpath, PATH_MAX, "%s/sync/%s", dbpath, dbname);
-		db = alpm_db_register_sync(dbname);
+		db = alpm_db_register_sync(handle, dbname, level);
 		if(db == NULL) {
 			fprintf(stderr, "error: could not register sync database (%s)\n",
-					alpm_strerrorlast());
+					alpm_strerror(alpm_errno(handle)));
 			return;
 		}
 		checkpkgs(alpm_db_get_pkgcache(db));
@@ -93,7 +96,8 @@ static void usage(void) {
 
 int main(int argc, char *argv[])
 {
-	char *dbpath = DBPATH;
+	const char *dbpath = DBPATH;
+	enum _alpm_errno_t err;
 	int a = 1;
 	alpm_list_t *dbnames = NULL;
 
@@ -117,15 +121,14 @@ int main(int argc, char *argv[])
 		usage();
 	}
 
-	if(alpm_initialize() == -1) {
-		fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
-		return(1);
+	handle = alpm_initialize(ROOTDIR, dbpath, &err);
+	if(!handle) {
+		fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
+		return 1;
 	}
 
 	/* let us get log messages from libalpm */
-	alpm_option_set_logcb(output_cb);
-
-	alpm_option_set_dbpath(dbpath);
+	alpm_option_set_logcb(handle, output_cb);
 
 	checkdbs(dbpath,dbnames);
 	alpm_list_free(dbnames);
diff --git a/src/util/pactree.c b/src/util/pactree.c
index 6a10006f..9b678631 100644
--- a/src/util/pactree.c
+++ b/src/util/pactree.c
@@ -26,63 +26,137 @@
 #include <alpm.h>
 #include <alpm_list.h>
 
+#define LINE_MAX     512
+
 /* output */
-char *provides     = " provides";
-char *unresolvable = " [unresolvable]";
-char *branch_tip1  = "|--";
-char *branch_tip2  = "+--";
-int   indent_size  = 3;
-
-/* color */
-char *branch1_color = "\033[0;33m"; /* yellow */
-char *branch2_color = "\033[0;37m"; /* white */
-char *leaf1_color   = "\033[1;32m"; /* bold green */
-char *leaf2_color   = "\033[0;32m"; /* green */
-char *color_off     = "\033[0m";
+struct graph_style {
+	const char *provides;
+	const char *tip1;
+	const char *tip2;
+	int indent;
+};
+
+static struct graph_style graph_default = {
+	" provides",
+	"|--",
+	"+--",
+	3
+};
+
+static struct graph_style graph_linear = {
+	"",
+	"",
+	"",
+	0
+};
+
+/* color choices */
+struct color_choices {
+	const char *branch1;
+	const char *branch2;
+	const char *leaf1;
+	const char *leaf2;
+	const char *off;
+};
+
+static struct color_choices use_color = {
+	"\033[0;33m", /* yellow */
+	"\033[0;37m", /* white */
+	"\033[1;32m", /* bold green */
+	"\033[0;32m", /* green */
+	"\033[0m"
+};
+
+static struct color_choices no_color = {
+	"",
+	"",
+	"",
+	"",
+	""
+};
 
 /* globals */
-pmdb_t *db_local;
+alpm_handle_t *handle = NULL;
 alpm_list_t *walked = NULL;
 alpm_list_t *provisions = NULL;
 
 /* options */
-int color = 0;
+struct color_choices *color = &no_color;
+struct graph_style *style = &graph_default;
 int graphviz = 0;
-int linear = 0;
 int max_depth = -1;
 int reverse = 0;
 int unique = 0;
-char *dbpath = NULL;
+int searchsyncs = 0;
+const char *dbpath = DBPATH;
 
-static int alpm_local_init(void)
+static char *strtrim(char *str)
 {
-	int ret;
+	char *pch = str;
 
-	ret = alpm_initialize();
-	if(ret != 0) {
-		return(ret);
+	if(str == NULL || *str == '\0') {
+		/* string is empty, so we're done. */
+		return str;
 	}
 
-	ret = alpm_option_set_root(ROOTDIR);
-	if(ret != 0) {
-		return(ret);
+	while(isspace((unsigned char)*pch)) {
+		pch++;
+	}
+	if(pch != str) {
+		memmove(str, pch, (strlen(pch) + 1));
 	}
 
-	if(dbpath) {
-		ret = alpm_option_set_dbpath(dbpath);
-	} else {
-		ret = alpm_option_set_dbpath(DBPATH);
+	/* check if there wasn't anything but whitespace in the string. */
+	if(*str == '\0') {
+		return str;
 	}
-	if(ret != 0) {
-		return(ret);
+
+	pch = (str + (strlen(str) - 1));
+	while(isspace((unsigned char)*pch)) {
+		pch--;
 	}
+	*++pch = '\0';
+
+	return str;
+}
+
+static int register_syncs(void) {
+	FILE *fp;
+	char *ptr, *section = NULL;
+	char line[LINE_MAX];
+	const alpm_siglevel_t level = ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
 
-	db_local = alpm_option_get_localdb();
-	if(!db_local) {
-		return(1);
+	fp = fopen(CONFFILE, "r");
+	if(!fp) {
+		return 1;
 	}
 
-	return(0);
+	while(fgets(line, LINE_MAX, fp)) {
+		strtrim(line);
+
+		if(line[0] == '#' || !strlen(line)) {
+			continue;
+		}
+
+		if((ptr = strchr(line, '#'))) {
+			*ptr = '\0';
+			strtrim(line);
+		}
+
+		if(line[0] == '[' && line[strlen(line) - 1] == ']') {
+			free(section);
+			section = strndup(&line[1], strlen(line) - 2);
+
+			if(section && strcmp(section, "options") != 0) {
+				alpm_db_register_sync(handle, section, level);
+			}
+		}
+	}
+
+	free(section);
+	fclose(fp);
+
+	return 0;
 }
 
 static int parse_options(int argc, char *argv[])
@@ -98,21 +172,22 @@ static int parse_options(int argc, char *argv[])
 		{"help",    no_argument,          0, 'h'},
 		{"linear",  no_argument,          0, 'l'},
 		{"reverse", no_argument,          0, 'r'},
+		{"sync",    no_argument,          0, 'S'},
 		{"unique",  no_argument,          0, 'u'},
 		{0, 0, 0, 0}
 	};
 
-	while((opt = getopt_long(argc, argv, "b:cd:ghlru", opts, &option_index))) {
+	while((opt = getopt_long(argc, argv, "b:cd:ghlrsu", opts, &option_index))) {
 		if(opt < 0) {
 			break;
 		}
 
 		switch(opt) {
 			case 'b':
-				dbpath = strdup(optarg);
+				dbpath = optarg;
 				break;
 			case 'c':
-				color = 1;
+				color = &use_color;
 				break;
 			case 'd':
 				/* validate depth */
@@ -126,40 +201,30 @@ static int parse_options(int argc, char *argv[])
 				graphviz = 1;
 				break;
 			case 'l':
-				linear = 1;
+				style = &graph_linear;
 				break;
 			case 'r':
 				reverse = 1;
 				break;
+			case 's':
+				searchsyncs = 1;
+				break;
 			case 'u':
-				unique = linear = 1;
+				unique = 1;
+				style = &graph_linear;
 				break;
 			case 'h':
 			case '?':
 			default:
-				return(1);
+				return 1;
 		}
 	}
 
 	if(!argv[optind]) {
-		return(1);
+		return 1;
 	}
 
-	if(!color) {
-		branch1_color = "";
-		branch2_color = "";
-		leaf1_color   = "";
-		leaf2_color   = "";
-		color_off     = "";
-	}
-	if(linear) {
-		provides     = "";
-		branch_tip1  = "";
-		branch_tip2  = "";
-		indent_size  = 0;
-	}
-
-	return(0);
+	return 0;
 }
 
 static void usage(void)
@@ -172,25 +237,22 @@ static void usage(void)
 			"  -g, --graph          generate output for graphviz's dot\n"
 			"  -l, --linear         enable linear output\n"
 			"  -r, --reverse        show reverse dependencies\n"
+			"  -s, --sync           search sync DBs instead of local\n"
 			"  -u, --unique         show dependencies with no duplicates (implies -l)\n\n"
 			"  -h, --help           display this help message\n");
 }
 
 static void cleanup(void)
 {
-	if(dbpath) {
-		free(dbpath);
-	}
-
 	alpm_list_free(walked);
 	alpm_list_free(provisions);
-	alpm_release();
+	alpm_release(handle);
 }
 
 /* pkg provides provision */
 static void print_text(const char *pkg, const char *provision, int depth)
 {
-	int indent_sz = (depth + 1) * indent_size;
+	int indent_sz = (depth + 1) * style->indent;
 
 	if(!pkg && !provision) {
 		/* not much we can do */
@@ -199,17 +261,17 @@ static void print_text(const char *pkg, const char *provision, int depth)
 
 	if(!pkg && provision) {
 		/* we failed to resolve provision */
-		printf("%s%*s%s%s%s%s%s\n", branch1_color, indent_sz, branch_tip1,
-				leaf1_color, provision, branch1_color, unresolvable, color_off);
+		printf("%s%*s%s%s%s [unresolvable]%s\n", color->branch1, indent_sz,
+				style->tip1, color->leaf1, provision, color->branch1, color->off);
 	} else if(provision && strcmp(pkg, provision) != 0) {
 		/* pkg provides provision */
-		printf("%s%*s%s%s%s%s %s%s%s\n", branch2_color, indent_sz, branch_tip2,
-				leaf1_color, pkg, leaf2_color, provides, leaf1_color, provision,
-				color_off);
+		printf("%s%*s%s%s%s%s %s%s%s\n", color->branch2, indent_sz, style->tip2,
+				color->leaf1, pkg, color->leaf2, style->provides, color->leaf1, provision,
+				color->off);
 	} else {
 		/* pkg is a normal package */
-		printf("%s%*s%s%s%s\n", branch1_color, indent_sz, branch_tip1, leaf1_color,
-				pkg, color_off);
+		printf("%s%*s%s%s%s\n", color->branch1, indent_sz, style->tip1, color->leaf1,
+				pkg, color->off);
 	}
 }
 
@@ -255,19 +317,31 @@ static void print_end(void)
 	}
 }
 
+static alpm_pkg_t *get_pkg_from_dbs(alpm_list_t *dbs, const char *needle) {
+	alpm_list_t *i;
+	alpm_pkg_t *ret;
+
+	for(i = dbs; i; i = alpm_list_next(i)) {
+		ret = alpm_db_get_pkg(alpm_list_getdata(i), needle);
+		if(ret) {
+			return ret;
+		}
+	}
+	return NULL;
+}
 
 /**
  * walk dependencies in reverse, showing packages which require the target
  */
-static void walk_reverse_deps(pmpkg_t *pkg, int depth)
+static void walk_reverse_deps(alpm_list_t *dblist, alpm_pkg_t *pkg, int depth)
 {
 	alpm_list_t *required_by, *i;
 
-	if((max_depth >= 0) && (depth == max_depth + 1)) {
+	if(!pkg || ((max_depth >= 0) && (depth == max_depth + 1))) {
 		return;
 	}
 
-	walked = alpm_list_add(walked, (void*)alpm_pkg_get_name(pkg));
+	walked = alpm_list_add(walked, (void *)alpm_pkg_get_name(pkg));
 	required_by = alpm_pkg_compute_requiredby(pkg);
 
 	for(i = required_by; i; i = alpm_list_next(i)) {
@@ -281,7 +355,7 @@ static void walk_reverse_deps(pmpkg_t *pkg, int depth)
 			}
 		} else {
 			print(alpm_pkg_get_name(pkg), pkgname, NULL, depth);
-			walk_reverse_deps(alpm_db_get_pkg(db_local, pkgname), depth + 1);
+			walk_reverse_deps(dblist, get_pkg_from_dbs(dblist, pkgname), depth + 1);
 		}
 	}
 
@@ -291,7 +365,7 @@ static void walk_reverse_deps(pmpkg_t *pkg, int depth)
 /**
  * walk dependencies, showing dependencies of the target
  */
-static void walk_deps(pmpkg_t *pkg, int depth)
+static void walk_deps(alpm_list_t *dblist, alpm_pkg_t *pkg, int depth)
 {
 	alpm_list_t *i;
 
@@ -299,12 +373,11 @@ static void walk_deps(pmpkg_t *pkg, int depth)
 		return;
 	}
 
-	walked = alpm_list_add(walked, (void*)alpm_pkg_get_name(pkg));
+	walked = alpm_list_add(walked, (void *)alpm_pkg_get_name(pkg));
 
 	for(i = alpm_pkg_get_depends(pkg); i; i = alpm_list_next(i)) {
-		pmdepend_t *depend = alpm_list_getdata(i);
-		pmpkg_t *provider = alpm_find_satisfier(alpm_db_get_pkgcache(db_local),
-				alpm_dep_get_name(depend));
+		alpm_depend_t *depend = alpm_list_getdata(i);
+		alpm_pkg_t *provider = alpm_find_dbs_satisfier(handle, dblist, depend->name);
 
 		if(provider) {
 			const char *provname = alpm_pkg_get_name(provider);
@@ -313,41 +386,57 @@ static void walk_deps(pmpkg_t *pkg, int depth)
 				/* if we've already seen this package, don't print in "unique" output
 				 * and don't recurse */
 				if(!unique) {
-					print(alpm_pkg_get_name(pkg), provname, alpm_dep_get_name(depend), depth);
+					print(alpm_pkg_get_name(pkg), provname, depend->name, depth);
 				}
 			} else {
-				print(alpm_pkg_get_name(pkg), provname, alpm_dep_get_name(depend), depth);
-				walk_deps(provider, depth + 1);
+				print(alpm_pkg_get_name(pkg), provname, depend->name, depth);
+				walk_deps(dblist, provider, depth + 1);
 			}
 		} else {
 			/* unresolvable package */
-			print(alpm_pkg_get_name(pkg), NULL, alpm_dep_get_name(depend), depth);
+			print(alpm_pkg_get_name(pkg), NULL, depend->name, depth);
 		}
 	}
 }
 
 int main(int argc, char *argv[])
 {
-	int ret;
+	int freelist = 0, ret = 0;
+	enum _alpm_errno_t err;
 	const char *target_name;
-	pmpkg_t *pkg;
+	alpm_pkg_t *pkg;
+	alpm_list_t *dblist = NULL;
 
-	ret = parse_options(argc, argv);
-	if(ret != 0) {
+	if(parse_options(argc, argv) != 0) {
 		usage();
+		ret = 1;
 		goto finish;
 	}
 
-	ret = alpm_local_init();
-	if(ret != 0) {
-		fprintf(stderr, "error: cannot initialize alpm: %s\n", alpm_strerrorlast());
+	handle = alpm_initialize(ROOTDIR, dbpath, &err);
+	if(!handle) {
+		fprintf(stderr, "error: cannot initialize alpm: %s\n",
+				alpm_strerror(err));
+		ret = 1;
 		goto finish;
 	}
 
+	if(searchsyncs) {
+		if(register_syncs() != 0) {
+			fprintf(stderr, "error: failed to register sync DBs\n");
+			ret = 1;
+			goto finish;
+		}
+		dblist = alpm_option_get_syncdbs(handle);
+	} else {
+		dblist = alpm_list_add(dblist, alpm_option_get_localdb(handle));
+		freelist = 1;
+	}
+
 	/* we only care about the first non option arg for walking */
 	target_name = argv[optind];
 
-	pkg = alpm_find_satisfier(alpm_db_get_pkgcache(db_local), target_name);
+	pkg = alpm_find_dbs_satisfier(handle, dblist, target_name);
 	if(!pkg) {
 		fprintf(stderr, "error: package '%s' not found\n", target_name);
 		ret = 1;
@@ -357,16 +446,20 @@ int main(int argc, char *argv[])
 	print_start(alpm_pkg_get_name(pkg), target_name);
 
 	if(reverse) {
-		walk_reverse_deps(pkg, 1);
+		walk_reverse_deps(dblist, pkg, 1);
 	} else {
-		walk_deps(pkg, 1);
+		walk_deps(dblist, pkg, 1);
 	}
 
 	print_end();
 
+	if(freelist) {
+		alpm_list_free(dblist);
+	}
+
 finish:
 	cleanup();
-	return(ret);
+	return ret;
 }
 
 /* vim: set ts=2 sw=2 noet: */
diff --git a/src/util/testdb.c b/src/util/testdb.c
index 0436a23f..ee169df2 100644
--- a/src/util/testdb.c
+++ b/src/util/testdb.c
@@ -31,20 +31,22 @@
 
 #define BASENAME "testdb"
 
+alpm_handle_t *handle = NULL;
+
 static void cleanup(int signum) {
-	if(alpm_release() == -1) {
-		fprintf(stderr, "error releasing alpm: %s\n", alpm_strerrorlast());
+	if(handle && alpm_release(handle) == -1) {
+		fprintf(stderr, "error releasing alpm\n");
 	}
 
 	exit(signum);
 }
 
-static void output_cb(pmloglevel_t level, const char *fmt, va_list args)
+static void output_cb(alpm_loglevel_t level, const char *fmt, va_list args)
 {
 	if(strlen(fmt)) {
 		switch(level) {
-			case PM_LOG_ERROR: printf("error: "); break;
-			case PM_LOG_WARNING: printf("warning: "); break;
+			case ALPM_LOG_ERROR: printf("error: "); break;
+			case ALPM_LOG_WARNING: printf("warning: "); break;
 			default: return;
 		}
 		vprintf(fmt, args);
@@ -59,14 +61,14 @@ static int check_localdb_files(void)
 	int ret = 0;
 	DIR *dir;
 
-	dbpath = alpm_option_get_dbpath();
+	dbpath = alpm_option_get_dbpath(handle);
 	snprintf(path, sizeof(path), "%slocal", dbpath);
 	if(!(dir = opendir(path))) {
 		fprintf(stderr, "error : %s : %s\n", path, strerror(errno));
-		return(1);
+		return 1;
 	}
 
-	while ((ent = readdir(dir)) != NULL) {
+	while((ent = readdir(dir)) != NULL) {
 		if(strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0
 				|| ent->d_name[0] == '.') {
 			continue;
@@ -85,10 +87,10 @@ static int check_localdb_files(void)
 	}
 	if(closedir(dir)) {
 		fprintf(stderr, "error closing dbpath : %s\n", strerror(errno));
-		return(1);
+		return 1;
 	}
 
-	return(ret);
+	return ret;
 }
 
 static int checkdeps(alpm_list_t *pkglist)
@@ -96,18 +98,17 @@ static int checkdeps(alpm_list_t *pkglist)
 	alpm_list_t *data, *i;
 	int ret = 0;
 	/* check dependencies */
-	data = alpm_checkdeps(pkglist, 0, NULL, pkglist);
+	data = alpm_checkdeps(handle, pkglist, NULL, pkglist, 0);
 	for(i = data; i; i = alpm_list_next(i)) {
-		pmdepmissing_t *miss = alpm_list_getdata(i);
-		pmdepend_t *dep = alpm_miss_get_dep(miss);
-		char *depstring = alpm_dep_compute_string(dep);
-		printf("missing dependency for %s : %s\n", alpm_miss_get_target(miss),
+		alpm_depmissing_t *miss = alpm_list_getdata(i);
+		char *depstring = alpm_dep_compute_string(miss->depend);
+		printf("missing dependency for %s : %s\n", miss->target,
 				depstring);
 		free(depstring);
 		ret++;
 	}
 	FREELIST(data);
-	return(ret);
+	return ret;
 }
 
 static int checkconflicts(alpm_list_t *pkglist)
@@ -115,50 +116,46 @@ static int checkconflicts(alpm_list_t *pkglist)
 	alpm_list_t *data, *i;
 	int ret = 0;
 	/* check conflicts */
-	data = alpm_checkconflicts(pkglist);
+	data = alpm_checkconflicts(handle, pkglist);
 	for(i = data; i; i = i->next) {
-		pmconflict_t *conflict = alpm_list_getdata(i);
-		printf("%s conflicts with %s\n", alpm_conflict_get_package1(conflict),
-				alpm_conflict_get_package2(conflict));
+		alpm_conflict_t *conflict = alpm_list_getdata(i);
+		printf("%s conflicts with %s\n",
+				conflict->package1, conflict->package2);
 		ret++;
 	}
 	FREELIST(data);
-	return(ret);
+	return ret;
 }
 
 static int check_localdb(void) {
 	int ret = 0;
-	pmdb_t *db = NULL;
+	alpm_db_t *db = NULL;
 	alpm_list_t *pkglist;
 
 	ret = check_localdb_files();
 	if(ret) {
-		return(ret);
+		return ret;
 	}
 
-	db = alpm_option_get_localdb();
-	if(db == NULL) {
-		fprintf(stderr, "error: could not register 'local' database (%s)\n",
-				alpm_strerrorlast());
-		cleanup(EXIT_FAILURE);
-	}
+	db = alpm_option_get_localdb(handle);
 	pkglist = alpm_db_get_pkgcache(db);
 	ret += checkdeps(pkglist);
 	ret += checkconflicts(pkglist);
-	return(ret);
+	return ret;
 }
 
 static int check_syncdbs(alpm_list_t *dbnames) {
 	int ret = 0;
-	pmdb_t *db = NULL;
+	alpm_db_t *db = NULL;
 	alpm_list_t *i, *pkglist, *syncpkglist = NULL;
+	const alpm_siglevel_t level = ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
 
 	for(i = dbnames; i; i = alpm_list_next(i)) {
 		char *dbname = alpm_list_getdata(i);
-		db = alpm_db_register_sync(dbname);
+		db = alpm_db_register_sync(handle, dbname, level);
 		if(db == NULL) {
 			fprintf(stderr, "error: could not register sync database (%s)\n",
-					alpm_strerrorlast());
+					alpm_strerror(alpm_errno(handle)));
 			ret = 1;
 			goto cleanup;
 		}
@@ -169,7 +166,7 @@ static int check_syncdbs(alpm_list_t *dbnames) {
 
 cleanup:
 	alpm_list_free(syncpkglist);
-	return(ret);
+	return ret;
 }
 
 static void usage(void) {
@@ -184,7 +181,8 @@ static void usage(void) {
 int main(int argc, char *argv[])
 {
 	int ret = 0;
-	char *dbpath = DBPATH;
+	enum _alpm_errno_t err;
+	const char *dbpath = DBPATH;
 	int a = 1;
 	alpm_list_t *dbnames = NULL;
 
@@ -204,18 +202,14 @@ int main(int argc, char *argv[])
 		a++;
 	}
 
-	if(alpm_initialize() == -1) {
-		fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
-		return(EXIT_FAILURE);
+	handle = alpm_initialize(ROOTDIR, dbpath, &err);
+	if(!handle) {
+		fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
+		return EXIT_FAILURE;
 	}
 
 	/* let us get log messages from libalpm */
-	alpm_option_set_logcb(output_cb);
-
-	if(alpm_option_set_dbpath(dbpath) != 0) {
-		fprintf(stderr, "cannot set dbpath: %s\n", alpm_strerrorlast());
-		return(EXIT_FAILURE);
-	}
+	alpm_option_set_logcb(handle, output_cb);
 
 	if(!dbnames) {
 		ret = check_localdb();
diff --git a/src/util/testpkg.c b/src/util/testpkg.c
index d0d9cac1..ac2dde28 100644
--- a/src/util/testpkg.c
+++ b/src/util/testpkg.c
@@ -24,14 +24,14 @@
 
 #define BASENAME "testpkg"
 
-static void output_cb(pmloglevel_t level, const char *fmt, va_list args)
+static void output_cb(alpm_loglevel_t level, const char *fmt, va_list args)
 {
 	if(fmt[0] == '\0') {
 		return;
 	}
 	switch(level) {
-		case PM_LOG_ERROR: printf("error: "); break;
-		case PM_LOG_WARNING: printf("warning: "); break;
+		case ALPM_LOG_ERROR: printf("error: "); break;
+		case ALPM_LOG_WARNING: printf("warning: "); break;
 		default: return; /* skip other messages */
 	}
 	vprintf(fmt, args);
@@ -40,32 +40,38 @@ static void output_cb(pmloglevel_t level, const char *fmt, va_list args)
 int main(int argc, char *argv[])
 {
 	int retval = 1; /* default = false */
-	pmpkg_t *pkg = NULL;
+	alpm_handle_t *handle;
+	enum _alpm_errno_t err;
+	alpm_pkg_t *pkg = NULL;
+	const alpm_siglevel_t level = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL;
 
 	if(argc != 2) {
 		fprintf(stderr, "usage: %s <package file>\n", BASENAME);
-		return(1);
+		return 1;
 	}
 
-	if(alpm_initialize() == -1) {
-		fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
-		return(1);
+	handle = alpm_initialize(ROOTDIR, DBPATH, &err);
+	if(!handle) {
+		fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerror(err));
+		return 1;
 	}
 
 	/* let us get log messages from libalpm */
-	alpm_option_set_logcb(output_cb);
+	alpm_option_set_logcb(handle, output_cb);
 
-	if(alpm_pkg_load(argv[1], 1, &pkg) == -1 || pkg == NULL) {
-		switch(pm_errno) {
-			case PM_ERR_PKG_OPEN:
+	if(alpm_pkg_load(handle, argv[1], 1, level, &pkg) == -1
+			|| pkg == NULL) {
+		err = alpm_errno(handle);
+		switch(err) {
+			case ALPM_ERR_PKG_OPEN:
 				printf("Cannot open the given file.\n");
 				break;
-			case PM_ERR_LIBARCHIVE:
-			case PM_ERR_PKG_INVALID:
+			case ALPM_ERR_LIBARCHIVE:
+			case ALPM_ERR_PKG_INVALID:
 				printf("Package is invalid.\n");
 				break;
 			default:
-				printf("libalpm error: %s\n", alpm_strerrorlast());
+				printf("libalpm error: %s\n", alpm_strerror(err));
 				break;
 		}
 		retval = 1;
@@ -75,9 +81,9 @@ int main(int argc, char *argv[])
 		retval = 0;
 	}
 
-	if(alpm_release() == -1) {
-		fprintf(stderr, "error releasing alpm: %s\n", alpm_strerrorlast());
+	if(alpm_release(handle) == -1) {
+		fprintf(stderr, "error releasing alpm\n");
 	}
 
-	return(retval);
+	return retval;
 }
diff --git a/src/util/vercmp.c b/src/util/vercmp.c
index adb5a42a..f4356fb4 100644
--- a/src/util/vercmp.c
+++ b/src/util/vercmp.c
@@ -20,7 +20,7 @@
 
 #include <stdlib.h>
 #include <stdio.h> /* printf */
-#include <string.h> /* strncpy */
+#include <string.h>
 
 #define BASENAME "vercmp"
 
@@ -45,13 +45,13 @@ int main(int argc, char *argv[])
 
 	if(argc == 1) {
 		usage();
-		return(2);
+		return 2;
 	}
 	if(argc > 1 &&
 			(strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0
 			 || strcmp(argv[1], "--usage") == 0)) {
 		usage();
-		return(0);
+		return 0;
 	}
 	if(argc > 2) {
 		s2 = argv[2];
@@ -62,5 +62,5 @@ int main(int argc, char *argv[])
 
 	ret = alpm_pkg_vercmp(s1, s2);
 	printf("%d\n", ret);
-	return(EXIT_SUCCESS);
+	return EXIT_SUCCESS;
 }