1 files changed, 203 insertions, 180 deletions

diff --git a/src/pacman/sync.c b/src/pacman/sync.c
index e3e87703..47ab4ebb 100644
--- a/src/pacman/sync.c
+++ b/src/pacman/sync.c
@@ -29,15 +29,11 @@
 
 #include <alpm.h>
 #include <alpm_list.h>
-#include <download.h> /* downloadLastErrString */
-/* TODO remove above download.h inclusion once we abstract more, and also
- * remove it from Makefile.am on the pacman side */
 
 /* pacman */
 #include "pacman.h"
 #include "util.h"
 #include "package.h"
-#include "callback.h"
 #include "conf.h"
 
 extern pmdb_t *db_local;
@@ -50,7 +46,7 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
 
 	dir = opendir(dbpath);
 	if(dir == NULL) {
-		fprintf(stderr, _("error: could not access database directory\n"));
+		pm_fprintf(stderr, PM_LOG_ERROR, _("could not access database directory\n"));
 		return(1);
 	}
 
@@ -61,7 +57,7 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
 		struct stat buf;
 		alpm_list_t *syncdbs = NULL, *i;
 		int found = 0;
-		char *dname = ent->d_name;
+		const char *dname = ent->d_name;
 
 		if(!strcmp(dname, ".") || !strcmp(dname, "..")) {
 			continue;
@@ -72,7 +68,7 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
 		}
 
 		/* build the full path */
-		snprintf(path, PATH_MAX, "%s%s", dbpath, ent->d_name);
+		snprintf(path, PATH_MAX, "%s%s", dbpath, dname);
 		/* skip entries that are not dirs (lock file, etc.) */
 		stat(path, &buf);
 		if(!S_ISDIR(buf.st_mode)) {
@@ -89,12 +85,13 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
 		/* We have a directory that doesn't match any syncdb.
 		 * Ask the user if he wants to remove it. */
 		if(!found) {
-			if(!yesno(_("Do you want to remove %s? [Y/n] "), path)) {
+			if(!yesno(1, _("Do you want to remove %s?"), path)) {
 				continue;
 			}
 
 			if(rmrf(path)) {
-				fprintf(stderr, _("error: could not remove repository directory\n"));
+				pm_fprintf(stderr, PM_LOG_ERROR,
+					_("could not remove repository directory\n"));
 				return(1);
 			}
 		}
@@ -108,7 +105,7 @@ static int sync_cleandb_all(void) {
 	char newdbpath[PATH_MAX];
 
 	printf(_("Database directory: %s\n"), dbpath);
-	if(!yesno(_("Do you want to remove unused repositories? [Y/n] "))) {
+	if(!yesno(1, _("Do you want to remove unused repositories?"))) {
 		return(0);
 	}
 	/* The sync dbs were previously put in dbpath/, but are now in dbpath/sync/,
@@ -133,19 +130,29 @@ static int sync_cleancache(int level)
 		/* incomplete cleanup */
 		DIR *dir;
 		struct dirent *ent;
-		/* Let's vastly improve the way this is done. Before, we went by package
-		 * name. Instead, let's only keep packages we have installed. Open up each
-		 * package and see if it has an entry in the local DB; if not, delete it.
-		 */
+		/* Open up each package and see if it should be deleted,
+		 * depending on the clean method used */
 		printf(_("Cache directory: %s\n"), cachedir);
-		if(!yesno(_("Do you want to remove uninstalled packages from cache? [Y/n] "))) {
-			return(0);
+		switch(config->cleanmethod) {
+			case PM_CLEAN_KEEPINST:
+				if(!yesno(1, _("Do you want to remove uninstalled packages from cache?"))) {
+					return(0);
+				}
+				break;
+			case PM_CLEAN_KEEPCUR:
+				if(!yesno(1, _("Do you want to remove outdated packages from cache?"))) {
+					return(0);
+				}
+				break;
+			default:
+				/* this should not happen : the config parsing doesn't set any other value */
+				return(1);
 		}
 		printf(_("removing old packages from cache... "));
 
 		dir = opendir(cachedir);
 		if(dir == NULL) {
-			fprintf(stderr, _("error: could not access cache directory\n"));
+			pm_fprintf(stderr, PM_LOG_ERROR, _("could not access cache directory\n"));
 			return(1);
 		}
 
@@ -153,13 +160,16 @@ static int sync_cleancache(int level)
 		/* step through the directory one file at a time */
 		while((ent = readdir(dir)) != NULL) {
 			char path[PATH_MAX];
-			pmpkg_t *localpkg = NULL, *dbpkg = NULL;
+			int delete = 1;
+			pmpkg_t *localpkg = NULL, *pkg = NULL;
+			alpm_list_t *sync_dbs = alpm_option_get_syncdbs();
+			alpm_list_t *j;
 
 			if(!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) {
 				continue;
 			}
 			/* build the full filepath */
-			snprintf(path, PATH_MAX, "%s/%s", cachedir, ent->d_name);
+			snprintf(path, PATH_MAX, "%s%s", cachedir, ent->d_name);
 
 			/* attempt to load the package, skip file on failures as we may have
 			 * files here that aren't valid packages. we also don't need a full
@@ -167,36 +177,56 @@ static int sync_cleancache(int level)
 			if(alpm_pkg_load(path, 0, &localpkg) != 0 || localpkg == NULL) {
 				continue;
 			}
-			/* check if this package is in the local DB */
-			dbpkg = alpm_db_get_pkg(db_local, alpm_pkg_get_name(localpkg));
-			if(dbpkg == NULL) {
-				/* delete package, not present in local DB */
-				unlink(path);
-			} else if(alpm_pkg_vercmp(alpm_pkg_get_version(localpkg),
-							alpm_pkg_get_version(dbpkg)) != 0) {
-				/* delete package, it was found but version differs */
-				unlink(path);
+			switch(config->cleanmethod) {
+				case PM_CLEAN_KEEPINST:
+					/* check if this package is in the local DB */
+					pkg = alpm_db_get_pkg(db_local, alpm_pkg_get_name(localpkg));
+					if(pkg != NULL && alpm_pkg_vercmp(alpm_pkg_get_version(localpkg),
+								alpm_pkg_get_version(pkg)) == 0) {
+						/* package was found in local DB and version matches, keep it */
+						delete = 0;
+					}
+					break;
+				case PM_CLEAN_KEEPCUR:
+					/* check if this package is in a sync DB */
+					for(j = sync_dbs; j && delete; j = alpm_list_next(j)) {
+						pmdb_t *db = alpm_list_getdata(j);
+						pkg = alpm_db_get_pkg(db, alpm_pkg_get_name(localpkg));
+						if(pkg != NULL && alpm_pkg_vercmp(alpm_pkg_get_version(localpkg),
+									alpm_pkg_get_version(pkg)) == 0) {
+							/* package was found in a sync DB and version matches, keep it */
+							delete = 0;
+						}
+					}
+					break;
+				default:
+					/* this should not happen : the config parsing doesn't set any other value */
+					delete = 0;
+					break;
 			}
-			/* else version was the same, so keep the package */
 			/* free the local file package */
 			alpm_pkg_free(localpkg);
+
+			if(delete) {
+				unlink(path);
+			}
 		}
 		printf(_("done.\n"));
 	} else {
 		/* full cleanup */
 		printf(_("Cache directory: %s\n"), cachedir);
-		if(!yesno(_("Do you want to remove ALL packages from cache? [Y/n] "))) {
+		if(!yesno(0, _("Do you want to remove ALL packages from cache?"))) {
 			return(0);
 		}
 		printf(_("removing all packages from cache... "));
 
 		if(rmrf(cachedir)) {
-			fprintf(stderr, _("error: could not remove cache directory\n"));
+			pm_fprintf(stderr, PM_LOG_ERROR, _("could not remove cache directory\n"));
 			return(1);
 		}
 
 		if(makepath(cachedir)) {
-			fprintf(stderr, _("error: could not create new cache directory\n"));
+			pm_fprintf(stderr, PM_LOG_ERROR, _("could not create new cache directory\n"));
 			return(1);
 		}
 		printf(_("done.\n"));
@@ -205,52 +235,22 @@ static int sync_cleancache(int level)
 	return(0);
 }
 
-static int sync_trans_init(pmtransflag_t flags) {
-	if(alpm_trans_init(PM_TRANS_TYPE_SYNC, flags, cb_trans_evt,
-				cb_trans_conv, cb_trans_progress) == -1) {
-		fprintf(stderr, _("error: failed to init transaction (%s)\n"),
-				alpm_strerrorlast());
-		if(pm_errno == PM_ERR_HANDLE_LOCK) {
-			printf(_("  if you're sure a package manager is not already\n"
-						"  running, you can remove %s.\n"), alpm_option_get_lockfile());
-		}
-		return(-1);
-	}
-	return(0);
-}
-
-static int sync_trans_release() {
-	if(alpm_trans_release() == -1) {
-		fprintf(stderr, _("error: failed to release transaction (%s)\n"),
-				alpm_strerrorlast());
-		return(-1);
-	}
-	return(0);
-}
 static int sync_synctree(int level, alpm_list_t *syncs)
 {
 	alpm_list_t *i;
 	int success = 0, ret;
 
+	if(trans_init(PM_TRANS_TYPE_SYNC, 0) == -1) {
+		return(0);
+	}
+
 	for(i = syncs; i; i = alpm_list_next(i)) {
 		pmdb_t *db = alpm_list_getdata(i);
 
 		ret = alpm_db_update((level < 2 ? 0 : 1), db);
 		if(ret < 0) {
-			if(pm_errno == PM_ERR_DB_SYNC) {
-				/* use libdownload error */
-				/* TODO breaking abstraction barrier here?
-				 *			pacman -> libalpm -> libdownload
-				 *
-				 * Yes.  This will be here until we add a nice pacman "pm_errstr" or
-				 * something, OR add all libdownload error codes into the pm_error enum
-				 */
-				fprintf(stderr, _("error: failed to synchronize %s: %s\n"),
-				        alpm_db_get_name(db), downloadLastErrString);
-			} else {
-				fprintf(stderr, _("error: failed to update %s (%s)\n"),
-				        alpm_db_get_name(db), alpm_strerrorlast());
-			}
+			pm_fprintf(stderr, PM_LOG_ERROR, _("failed to update %s (%s)\n"),
+					alpm_db_get_name(db), alpm_strerrorlast());
 		} else if(ret == 1) {
 			printf(_(" %s is up to date\n"), alpm_db_get_name(db));
 			success++;
@@ -259,10 +259,16 @@ static int sync_synctree(int level, alpm_list_t *syncs)
 		}
 	}
 
+	if(trans_release() == -1) {
+		return(0);
+	}
 	/* We should always succeed if at least one DB was upgraded - we may possibly
 	 * fail later with unresolved deps, but that should be rare, and would be
 	 * expected
 	 */
+	if(!success) {
+		pm_fprintf(stderr, PM_LOG_ERROR, _("failed to synchronize any databases\n"));
+	}
 	return(success > 0);
 }
 
@@ -289,8 +295,6 @@ static int sync_search(alpm_list_t *syncs, alpm_list_t *targets)
 			found = 1;
 		}
 		for(j = ret; j; j = alpm_list_next(j)) {
-			/* print repo/name (group) info about each package in our list */
-			char *group = NULL;
 			alpm_list_t *grp;
 			pmpkg_t *pkg = alpm_list_getdata(j);
 
@@ -311,8 +315,17 @@ static int sync_search(alpm_list_t *syncs, alpm_list_t *targets)
 
 			if (!config->quiet) {
 				if((grp = alpm_pkg_get_groups(pkg)) != NULL) {
-					group = alpm_list_getdata(grp);
-					printf(" (%s)", (char *)alpm_list_getdata(grp));
+					alpm_list_t *k;
+					printf(" (");
+					for(k = grp; k; k = alpm_list_next(k)) {
+						const char *group = alpm_list_getdata(k);
+						printf("%s", group);
+						if(alpm_list_next(k)) {
+							/* only print a spacer if there are more groups */
+							printf(" ");
+						}
+					}
+					printf(")");
 				}
 
 				/* we need a newline and initial indent first */
@@ -332,19 +345,21 @@ static int sync_search(alpm_list_t *syncs, alpm_list_t *targets)
 
 static int sync_group(int level, alpm_list_t *syncs, alpm_list_t *targets)
 {
-	alpm_list_t *i, *j;
+	alpm_list_t *i, *j, *k;
 
 	if(targets) {
 		for(i = targets; i; i = alpm_list_next(i)) {
-			char *grpname = alpm_list_getdata(i);
+			const char *grpname = alpm_list_getdata(i);
 			for(j = syncs; j; j = alpm_list_next(j)) {
 				pmdb_t *db = alpm_list_getdata(j);
 				pmgrp_t *grp = alpm_db_readgrp(db, grpname);
 
 				if(grp) {
-					/* TODO this should be a lot cleaner, why two outputs? */
-					printf("%s\n", (char *)alpm_grp_get_name(grp));
-					list_display("   ", alpm_grp_get_pkgs(grp));
+					/* get names of packages in group */
+					for(k = alpm_grp_get_pkgs(grp); k; k = alpm_list_next(k)) {
+						printf("%s %s\n", grpname,
+								alpm_pkg_get_name(alpm_list_getdata(k)));
+					}
 				}
 			}
 		}
@@ -354,10 +369,16 @@ static int sync_group(int level, alpm_list_t *syncs, alpm_list_t *targets)
 
 			for(j = alpm_db_getgrpcache(db); j; j = alpm_list_next(j)) {
 				pmgrp_t *grp = alpm_list_getdata(j);
+				const char *grpname = alpm_grp_get_name(grp);
 
-				printf("%s\n", (char *)alpm_grp_get_name(grp));
-				if(grp && level > 1) {
-					list_display("   ", alpm_grp_get_pkgs(grp));
+				if(level > 1) {
+					for(k = alpm_grp_get_pkgs(grp); k; k = alpm_list_next(k)) {
+						printf("%s %s\n", grpname,
+								alpm_pkg_get_name(alpm_list_getdata(k)));
+					}
+				} else {
+					/* print grp names only, no package names */
+					printf("%s\n", grpname);
 				}
 			}
 		}
@@ -395,7 +416,8 @@ static int sync_info(alpm_list_t *syncs, alpm_list_t *targets)
 				}
 
 				if(!db) {
-					fprintf(stderr, _("error: repository '%s' does not exist\n"), repo);
+					pm_fprintf(stderr, PM_LOG_ERROR,
+						_("repository '%s' does not exist\n"), repo);
 					return(1);
 				}
 
@@ -410,7 +432,8 @@ static int sync_info(alpm_list_t *syncs, alpm_list_t *targets)
 				}
 
 				if(!foundpkg) {
-					fprintf(stderr, _("error: package '%s' was not found in repository '%s'\n"), pkgstr, repo);
+					pm_fprintf(stderr, PM_LOG_ERROR,
+						_("package '%s' was not found in repository '%s'\n"), pkgstr, repo);
 					ret++;
 				}
 			} else {
@@ -430,7 +453,8 @@ static int sync_info(alpm_list_t *syncs, alpm_list_t *targets)
 					}
 				}
 				if(!foundpkg) {
-					fprintf(stderr, _("error: package '%s' was not found\n"), pkgstr);
+					pm_fprintf(stderr, PM_LOG_ERROR,
+						_("package '%s' was not found\n"), pkgstr);
 					ret++;
 				}
 			}
@@ -467,7 +491,8 @@ static int sync_list(alpm_list_t *syncs, alpm_list_t *targets)
 			}
 
 			if(db == NULL) {
-				fprintf(stderr, _("error: repository \"%s\" was not found.\n"),repo);
+				pm_fprintf(stderr, PM_LOG_ERROR,
+					_("repository \"%s\" was not found.\n"),repo);
 				alpm_list_free(ls);
 				return(1);
 			}
@@ -499,74 +524,43 @@ static int sync_list(alpm_list_t *syncs, alpm_list_t *targets)
 	return(0);
 }
 
-static int sync_trans(alpm_list_t *targets, int sync_only)
+static alpm_list_t *syncfirst() {
+	alpm_list_t *i, *res = NULL;
+
+	for(i = config->syncfirst; i; i = alpm_list_next(i)) {
+		char *pkgname = alpm_list_getdata(i);
+		pmpkg_t *pkg = alpm_db_get_pkg(alpm_option_get_localdb(), pkgname);
+		if(pkg == NULL) {
+			continue;
+		}
+
+		if(alpm_sync_newversion(pkg, alpm_option_get_syncdbs())) {
+			res = alpm_list_add(res, strdup(pkgname));
+		}
+	}
+
+	return(res);
+}
+
+static int sync_trans(alpm_list_t *targets)
 {
 	int retval = 0;
 	alpm_list_t *data = NULL;
 	alpm_list_t *sync_dbs = alpm_option_get_syncdbs();
 
 	/* Step 1: create a new transaction... */
-	if(sync_trans_init(config->flags) == -1) {
+	if(trans_init(PM_TRANS_TYPE_SYNC, config->flags) == -1) {
 		return(1);
 	}
 
-	if(config->op_s_sync) {
-		/* grab a fresh package list */
-		printf(_(":: Synchronizing package databases...\n"));
-		alpm_logaction("synchronizing package lists\n");
-		if(!sync_synctree(config->op_s_sync, sync_dbs)) {
-			fprintf(stderr, _("error: failed to synchronize any databases\n"));
-			retval = 1;
-			goto cleanup;
-		}
-		if(sync_only) {
-			goto cleanup;
-		}
-	}
-
 	if(config->op_s_upgrade) {
-		alpm_list_t *pkgs, *i;
-
 		printf(_(":: Starting full system upgrade...\n"));
 		alpm_logaction("starting full system upgrade\n");
 		if(alpm_trans_sysupgrade() == -1) {
-			fprintf(stderr, _("error: %s\n"), alpm_strerrorlast());
+			pm_fprintf(stderr, PM_LOG_ERROR, "%s\n", alpm_strerrorlast());
 			retval = 1;
 			goto cleanup;
 		}
-
-		if(!(alpm_trans_get_flags() & (PM_TRANS_FLAG_DOWNLOADONLY | PM_TRANS_FLAG_PRINTURIS))) {
-			/* check if pacman itself is one of the packages to upgrade.
-			 * this can prevent some of the "syntax error" problems users can have
-			 * when sysupgrade'ing with an older version of pacman.
-			 */
-			pkgs = alpm_trans_get_pkgs();
-			for(i = pkgs; i; i = alpm_list_next(i)) {
-				pmsyncpkg_t *sync = alpm_list_getdata(i);
-				pmpkg_t *spkg = alpm_sync_get_pkg(sync);
-				/* TODO pacman name should probably not be hardcoded. In addition, we
-				 * have problems on an -Syu if pacman has to pull in deps, so recommend
-				 * an '-S pacman' operation */
-				if(strcmp("pacman", alpm_pkg_get_name(spkg)) == 0) {
-					printf("\n");
-					printf(_(":: pacman has detected a newer version of itself.\n"));
-					if(yesno(_(":: Do you want to cancel the current operation\n"
-					           ":: and install the new pacman version now? [Y/n] "))) {
-						if(sync_trans_release() == -1) {
-							return(1);
-						}
-						if(sync_trans_init(0) == -1) {
-							return(1);
-						}
-						if(alpm_trans_addtarget("pacman") == -1) {
-							fprintf(stderr, _("error: pacman: %s\n"), alpm_strerrorlast());
-							return(1);
-						}
-						break;
-					}
-				}
-			}
-		}
 	} else {
 		alpm_list_t *i;
 
@@ -583,7 +577,7 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 					continue;
 				}
 				if(pm_errno != PM_ERR_PKG_NOT_FOUND) {
-					fprintf(stderr, _("error: '%s': %s\n"),
+					pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
 							targ, alpm_strerrorlast());
 					retval = 1;
 					goto cleanup;
@@ -594,26 +588,31 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 					pmdb_t *db = alpm_list_getdata(j);
 					grp = alpm_db_readgrp(db, targ);
 					if(grp) {
-						alpm_list_t *k;
+						alpm_list_t *k, *pkgnames = NULL;
 
 						found++;
 						printf(_(":: group %s (including ignored packages):\n"), targ);
 						/* remove dupe entries in case a package exists in multiple repos */
-						const alpm_list_t *grppkgs = alpm_grp_get_pkgs(grp);
+						alpm_list_t *grppkgs = alpm_grp_get_pkgs(grp);
 						alpm_list_t *pkgs = alpm_list_remove_dupes(grppkgs);
-						list_display("   ", pkgs);
-						if(yesno(_(":: Install whole content? [Y/n] "))) {
-							for(k = pkgs; k; k = alpm_list_next(k)) {
+						for(k = pkgs; k; k = alpm_list_next(k)) {
+							pkgnames = alpm_list_add(pkgnames,
+									(char*)alpm_pkg_get_name(k->data));
+						}
+						list_display("   ", pkgnames);
+						if(yesno(1, _(":: Install whole content?"))) {
+							for(k = pkgnames; k; k = alpm_list_next(k)) {
 								targets = alpm_list_add(targets, strdup(alpm_list_getdata(k)));
 							}
 						} else {
-							for(k = pkgs; k; k = alpm_list_next(k)) {
+							for(k = pkgnames; k; k = alpm_list_next(k)) {
 								char *pkgname = alpm_list_getdata(k);
-								if(yesno(_(":: Install %s from group %s? [Y/n] "), pkgname, targ)) {
+								if(yesno(1, _(":: Install %s from group %s?"), pkgname, targ)) {
 									targets = alpm_list_add(targets, strdup(pkgname));
 								}
 							}
 						}
+						alpm_list_free(pkgnames);
 						alpm_list_free(pkgs);
 					}
 				}
@@ -622,7 +621,9 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 					alpm_list_t *prov = NULL;
 					for(j = sync_dbs; j; j = alpm_list_next(j)) {
 						pmdb_t *db = alpm_list_getdata(j);
-						prov = alpm_list_join(prov, alpm_db_whatprovides(db, targ));
+						alpm_list_t *dblist = alpm_db_getpkgcache(db);
+						alpm_list_t *satisfiers = alpm_find_pkg_satisfiers(dblist, targ);
+						prov = alpm_list_join(prov, satisfiers);
 					}
 					if(prov != NULL) {
 						if(alpm_list_count(prov) == 1) {
@@ -634,7 +635,8 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 							targets = alpm_list_add(targets, strdup(pname));
 						} else {
 							alpm_list_t *k;
-							fprintf(stderr, _("error: several packages provide %s, please specify one :\n"), targ);
+							pm_fprintf(stderr, PM_LOG_ERROR,
+								_("several packages provide %s, please specify one :\n"), targ);
 							for(k = prov; k; k = alpm_list_next(k)) {
 								pmpkg_t *pkg = alpm_list_getdata(k);
 								printf("%s ", alpm_pkg_get_name(pkg));
@@ -645,7 +647,8 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 							goto cleanup;
 						}
 					} else {
-						fprintf(stderr, _("error: '%s': not found in sync db\n"), targ);
+						pm_fprintf(stderr, PM_LOG_ERROR,
+							_("'%s': not found in sync db\n"), targ);
 						retval = 1;
 						goto cleanup;
 					}
@@ -656,7 +659,7 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 
 	/* Step 2: "compute" the transaction based on targets and flags */
 	if(alpm_trans_prepare(&data) == -1) {
-		fprintf(stderr, _("error: failed to prepare transaction (%s)\n"),
+		pm_fprintf(stderr, PM_LOG_ERROR, _("failed to prepare transaction (%s)\n"),
 		        alpm_strerrorlast());
 		switch(pm_errno) {
 			alpm_list_t *i;
@@ -698,19 +701,9 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 		printf("\n");
 
 		if(config->op_s_downloadonly) {
-			if(config->noconfirm) {
-				printf(_("Beginning download...\n"));
-				confirm = 1;
-			} else {
-				confirm = yesno(_("Proceed with download? [Y/n] "));
-			}
+			confirm = yesno(1, _("Proceed with download?"));
 		} else {
-			if(config->noconfirm) {
-				printf(_("Beginning upgrade process...\n"));
-				confirm = 1;
-			} else {
-				confirm = yesno(_("Proceed with installation? [Y/n] "));
-			}
+			confirm = yesno(1, _("Proceed with installation?"));
 		}
 		if(!confirm) {
 			goto cleanup;
@@ -719,7 +712,7 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 
 	/* Step 3: actually perform the installation */
 	if(alpm_trans_commit(&data) == -1) {
-		fprintf(stderr, _("error: failed to commit transaction (%s)\n"),
+		pm_fprintf(stderr, PM_LOG_ERROR, _("failed to commit transaction (%s)\n"),
 		        alpm_strerrorlast());
 		switch(pm_errno) {
 			alpm_list_t *i;
@@ -741,9 +734,11 @@ static int sync_trans(alpm_list_t *targets, int sync_only)
 					}
 				}
 				break;
-			case PM_ERR_PKG_CORRUPTED:
+			case PM_ERR_PKG_INVALID:
+			case PM_ERR_DLT_INVALID:
 				for(i = data; i; i = alpm_list_next(i)) {
-					printf("%s", (char*)alpm_list_getdata(i));
+					char *filename = alpm_list_getdata(i);
+					printf(_("%s is invalid or corrupted\n"), filename);
 				}
 				break;
 			default:
@@ -760,7 +755,7 @@ cleanup:
 	if(data) {
 		FREELIST(data);
 	}
-	if(sync_trans_release() == -1) {
+	if(trans_release() == -1) {
 		retval = 1;
 	}
 
@@ -770,20 +765,19 @@ cleanup:
 int pacman_sync(alpm_list_t *targets)
 {
 	alpm_list_t *sync_dbs = NULL;
-	int sync_only = 0;
 
 	/* clean the cache */
 	if(config->op_s_clean) {
 		int ret = 0;
 
-		if(sync_trans_init(0) == -1) {
+		if(trans_init(PM_TRANS_TYPE_SYNC, 0) == -1) {
 			return(1);
 		}
 
 		ret += sync_cleancache(config->op_s_clean);
 		ret += sync_cleandb_all();
 
-		if(sync_trans_release() == -1) {
+		if(trans_release() == -1) {
 			ret++;
 		}
 
@@ -797,18 +791,11 @@ int pacman_sync(alpm_list_t *targets)
 		return(1);
 	}
 
-	if(config->op_s_search || config->group
-			|| config->op_s_info || config->op_q_list) {
-		sync_only = 1;
-	} else if(targets == NULL && !(config->op_s_sync || config->op_s_upgrade)) {
-		/* don't proceed here unless we have an operation that doesn't require
-		 * a target list */
-		pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
-		return(1);
-	}
-
-	if(needs_transaction()) {
-		if(sync_trans(targets, sync_only) == 1) {
+	if(config->op_s_sync) {
+		/* grab a fresh package list */
+		printf(_(":: Synchronizing package databases...\n"));
+		alpm_logaction("synchronizing package lists\n");
+		if(!sync_synctree(config->op_s_sync, sync_dbs)) {
 			return(1);
 		}
 	}
@@ -833,7 +820,43 @@ int pacman_sync(alpm_list_t *targets)
 		return(sync_list(sync_dbs, targets));
 	}
 
-	return(0);
+	if(targets == NULL) {
+		if(config->op_s_upgrade) {
+			/* proceed */
+		} else if(config->op_s_sync) {
+			return(0);
+		} else {
+			/* don't proceed here unless we have an operation that doesn't require a
+			 * target list */
+			pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
+			return(1);
+		}
+	}
+
+	alpm_list_t *targs = alpm_list_strdup(targets);
+	if(!(config->flags & (PM_TRANS_FLAG_DOWNLOADONLY | PM_TRANS_FLAG_PRINTURIS))) {
+		/* check for newer versions of packages to be upgraded first */
+		alpm_list_t *packages = syncfirst();
+		if(packages) {
+			printf(_(":: The following packages should be upgraded first :\n"));
+			list_display("   ", packages);
+			if(yesno(1, _(":: Do you want to cancel the current operation\n"
+							":: and upgrade these packages now?"))) {
+				FREELIST(targs);
+				targs = packages;
+				config->flags = 0;
+				config->op_s_upgrade = 0;
+			} else {
+				FREELIST(packages);
+			}
+			printf("\n");
+		}
+	}
+
+	int ret = sync_trans(targs);
+	FREELIST(targs);
+
+	return(ret);
 }
 
 /* vim: set ts=2 sw=2 noet: */