pactest: fix test errors being treated as success

Rules return -1 if there was an error with the rule itself. Later this
return value is passed to tap as a bool. Because -1 is a truthy value it
gets treated as success.

doc/pacman.8.asciidoc

@@ -256,6 +256,12 @@ Upgrade Options (apply to '-S' and '-U')[[UO]]
 	as explicitly installed so it will not be removed by the '\--recursive'
 	remove operation.
 
+*\--note*::
+	Add an install note to packages. This will only apply to targets explicitly
+	listed and not their dependencies. The note can be used to keep track of why
+	a package was installed or any other info of note. The note can later be
+	edited or removed with '\--D \--note' or '\--D \--rmnote' respectively.
+
 *\--ignore* <package>::
 	Directs pacman to ignore upgrades of package even if there is one
 	available. Multiple packages can be specified by separating them
@@ -468,6 +474,13 @@ Database Options (apply to '-D')[[QO]]
 	package installed even when it was initially installed as a dependency
 	of another package.
 
+*\--note*::
+	Add or edit a package's install note. The note can be used to keep track of why
+	a package was installed or any other info of note.
+
+*\--rmnote*::
+	Remove a package's install note.
+
 *-k, \--check*::
 	Check the local package database is internally consistent. This will
 	check all required files are present and that installed packages have

doc/repo-add.8.asciidoc

@@ -70,6 +70,8 @@ repo-add Options
 	Remove old package files from the disk when updating their entry in the
 	database.
 
+*\--include-sigs*::
+	Include package PGP signatures in the repository database (if available)
 
 Example
 -------

lib/libalpm/add.c

@@ -431,8 +431,22 @@ static int commit_single_pkg(alpm_handle_t *handle, alpm_pkg_t *newpkg,
 
 	ASSERT(trans != NULL, return -1);
 
+
+	if(_alpm_db_get_pkgfromcache(db, newpkg->name)) {
+			oldpkg = newpkg->oldpkg;
+	}
+
+	/* set note on package only if it was explicitly added to transaction */
+	if(trans->note && newpkg->reason == ALPM_PKG_REASON_EXPLICIT) {
+		STRDUP(newpkg->note, trans->note,
+				RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+	} else if(oldpkg && oldpkg->note) {
+		STRDUP(newpkg->note,oldpkg->note,
+				RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+	}
+
+	if(oldpkg) {
 	/* see if this is an upgrade. if so, remove the old package first */
-	if(_alpm_db_get_pkgfromcache(db, newpkg->name) && (oldpkg = newpkg->oldpkg)) {
 		int cmp = _alpm_pkg_compare_versions(newpkg, oldpkg);
 		if(cmp < 0) {
 			log_msg = "downgrading";

lib/libalpm/alpm.h

@@ -78,7 +78,7 @@ extern "C" {
  * This struct represents an instance of libalpm.
  * @ingroup libalpm_handle
  */
-typedef struct __alpm_handle_t alpm_handle_t;
+typedef struct _alpm_handle_t alpm_handle_t;
 
 /** A database.
  *
@@ -98,7 +98,7 @@ typedef struct __alpm_handle_t alpm_handle_t;
  * Databases are automatically unregistered when the \link alpm_handle_t \endlink is released.
  * @ingroup libalpm_databases
  */
-typedef struct __alpm_db_t alpm_db_t;
+typedef struct _alpm_db_t alpm_db_t;
 
 
 /** A package.
@@ -111,13 +111,7 @@ typedef struct __alpm_db_t alpm_db_t;
  * to be added or removed from the system.
  * @ingroup libalpm_packages
  */
-typedef struct __alpm_pkg_t alpm_pkg_t;
-
-/** Transaction structure used internally by libalpm
- * @ingroup libalpm_trans
- * */
-typedef struct __alpm_trans_t alpm_trans_t;
-
+typedef struct _alpm_pkg_t alpm_pkg_t;
 
 /** The time type used by libalpm. Represents a unix time stamp
  * @ingroup libalpm_misc */
@@ -1080,8 +1074,10 @@ typedef struct _alpm_question_import_key_t {
 	alpm_question_type_t type;
 	/** Answer: whether or not to import key */
 	int import;
-	/** The key to import */
-	alpm_pgpkey_t *key;
+	/** UID of the key to import */
+	const char *uid;
+	/** Fingerprint the key to import */
+	const char *fingerprint;
 } alpm_question_import_key_t;
 
 /**
@@ -2433,6 +2429,12 @@ const char *alpm_pkg_get_desc(alpm_pkg_t *pkg);
  */
 const char *alpm_pkg_get_url(alpm_pkg_t *pkg);
 
+/** Returns the package note.
+ * @param pkg a pointer to package
+ * @return a reference to an internal string
+ */
+char *alpm_pkg_get_note(alpm_pkg_t *pkg);
+
 /** Returns the build timestamp of the package.
  * @param pkg a pointer to package
  * @return the timestamp of the build time
@@ -2611,6 +2613,15 @@ off_t alpm_pkg_download_size(alpm_pkg_t *newpkg);
  */
 int alpm_pkg_set_reason(alpm_pkg_t *pkg, alpm_pkgreason_t reason);
 
+/** Set install note for a package in the local database.
+ * The provided package object must be from the local database or this method
+ * will fail. The write to the local database is performed immediately.
+ * @param pkg the package to edit
+ * @param note the new install note, null to remove a note
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int alpm_pkg_set_note(alpm_pkg_t *pkg, char *note);
+
 
 /* End of libalpm_pkg_t accessors */
 /** @} */
@@ -2719,7 +2730,8 @@ typedef enum _alpm_transflag_t {
 	ALPM_TRANS_FLAG_RECURSE = (1 << 5),
 	/** Modify database but do not commit changes to the filesystem. */
 	ALPM_TRANS_FLAG_DBONLY = (1 << 6),
-	/* (1 << 7) flag can go here */
+	/** Do not run hooks during a transaction */
+	ALPM_TRANS_FLAG_NOHOOKS = (1 << 7),
 	/** Use ALPM_PKG_REASON_DEPEND when installing packages. */
 	ALPM_TRANS_FLAG_ALLDEPS = (1 << 8),
 	/** Only download packages and do not actually install. */
@@ -2759,6 +2771,16 @@ alpm_list_t *alpm_trans_get_add(alpm_handle_t *handle);
  */
 alpm_list_t *alpm_trans_get_remove(alpm_handle_t *handle);
 
+/** Sets the install note for a transaction
+ *
+ * All target packages will gain the note, dependencies will not.
+ *
+ * @param handle the context handle
+ * @note the the note, may not contain new lines
+ * @return 0 on success, -1 on error (pm_errno is set accordingly)
+ */
+int alpm_trans_set_note(alpm_handle_t *handle, char *note);
+
 /** Initialize the transaction.
  * @param handle the context handle
  * @param flags flags of the transaction (like nodeps, etc; see alpm_transflag_t)

lib/libalpm/alpm_list.h

@@ -48,13 +48,13 @@ extern "C" {
  */
 
 /** A doubly linked list */
-typedef struct __alpm_list_t {
+typedef struct _alpm_list_t {
 	/** data held by the list node */
 	void *data;
 	/** pointer to the previous node */
-	struct __alpm_list_t *prev;
+	struct _alpm_list_t *prev;
 	/** pointer to the next node */
-	struct __alpm_list_t *next;
+	struct _alpm_list_t *next;
 } alpm_list_t;
 
 /** Frees a list and its contents */

lib/libalpm/be_local.c

@@ -81,6 +81,12 @@ static const char *_cache_get_url(alpm_pkg_t *pkg)
 	return pkg->url;
 }
 
+static char *_cache_get_note(alpm_pkg_t *pkg)
+{
+	LAZY_LOAD(INFRQ_DESC);
+	return pkg->note;
+}
+
 static alpm_time_t _cache_get_builddate(alpm_pkg_t *pkg)
 {
 	LAZY_LOAD(INFRQ_DESC);
@@ -330,6 +336,7 @@ static const struct pkg_operations local_pkg_ops = {
 	.get_base = _cache_get_base,
 	.get_desc = _cache_get_desc,
 	.get_url = _cache_get_url,
+	.get_note = _cache_get_note,
 	.get_builddate = _cache_get_builddate,
 	.get_installdate = _cache_get_installdate,
 	.get_packager = _cache_get_packager,
@@ -752,6 +759,8 @@ static int local_db_read(alpm_pkg_t *info, int inforeq)
 				READ_AND_STORE_ALL(info->groups);
 			} else if(strcmp(line, "%URL%") == 0) {
 				READ_AND_STORE(info->url);
+			} else if(strcmp(line, "%NOTE%") == 0) {
+				READ_AND_STORE(info->note);
 			} else if(strcmp(line, "%LICENSE%") == 0) {
 				READ_AND_STORE_ALL(info->licenses);
 			} else if(strcmp(line, "%ARCH%") == 0) {
@@ -1040,6 +1049,11 @@ int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, int inforeq)
 		write_deps(fp, "%CONFLICTS%", info->conflicts);
 		write_deps(fp, "%PROVIDES%", info->provides);
 
+		if(info->note) {
+			fprintf(fp, "%%NOTE%%\n"
+							"%s\n\n", info->note);
+		}
+
 		fclose(fp);
 		fp = NULL;
 	}
@@ -1158,6 +1172,31 @@ int SYMEXPORT alpm_pkg_set_reason(alpm_pkg_t *pkg, alpm_pkgreason_t reason)
 	return 0;
 }
 
+int SYMEXPORT alpm_pkg_set_note(alpm_pkg_t *pkg, char *note)
+{
+	ASSERT(pkg != NULL, return -1);
+	ASSERT(pkg->origin == ALPM_PKG_FROM_LOCALDB,
+			RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
+	ASSERT(pkg->origin_data.db == pkg->handle->db_local,
+			RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
+
+	_alpm_log(pkg->handle, ALPM_LOG_DEBUG,
+			"setting note for %s: %s\n", pkg->name, note);
+	LAZY_LOAD(INFRQ_DESC);
+	FREE(pkg->note);
+	if(note) {
+		ASSERT(!strchr(note, '\n'), RET_ERR(pkg->handle, ALPM_ERR_WRONG_ARGS, -1));
+		STRDUP(pkg->note, note,
+				RET_ERR(pkg->handle, ALPM_ERR_MEMORY, -1));
+	}
+	/* write DESC */
+	if(_alpm_local_db_write(pkg->handle->db_local, pkg, INFRQ_DESC)) {
+		RET_ERR(pkg->handle, ALPM_ERR_DB_WRITE, -1);
+	}
+
+	return 0;
+}
+
 static const struct db_operations local_db_ops = {
 	.validate         = local_db_validate,
 	.populate         = local_db_populate,

lib/libalpm/db.c

@@ -405,6 +405,7 @@ int _alpm_db_search(alpm_db_t *db, const alpm_list_t *needles,
 			const char *matched = NULL;
 			const char *name = pkg->name;
 			const char *desc = alpm_pkg_get_desc(pkg);
+			const char *note = alpm_pkg_get_note(pkg);
 
 			/* check name as regex AND as plain text */
 			if(name && (regexec(&reg, name, 0, 0, 0) == 0 || strstr(name, targ))) {
@@ -414,6 +415,11 @@ int _alpm_db_search(alpm_db_t *db, const alpm_list_t *needles,
 			else if(desc && regexec(&reg, desc, 0, 0, 0) == 0) {
 				matched = desc;
 			}
+			/* check note */
+			else if(note && regexec(&reg, note, 0, 0, 0) == 0) {
+				matched = note;
+			}
+
 			/* TODO: should we be doing this, and should we print something
 			 * differently when we do match it since it isn't currently printed? */
 			if(!matched) {

lib/libalpm/db.h

@@ -62,7 +62,7 @@ struct db_operations {
 };
 
 /* Database */
-struct __alpm_db_t {
+struct _alpm_db_t {
 	alpm_handle_t *handle;
 	char *treename;
 	/* do not access directly, use _alpm_db_path(db) for lazy access */

lib/libalpm/diskspace.h

@@ -43,7 +43,7 @@ enum mount_fsinfo {
 	MOUNT_FSINFO_FAIL,
 };
 
-typedef struct __alpm_mountpoint_t {
+typedef struct _alpm_mountpoint_t {
 	/* mount point information */
 	char *mount_dir;
 	size_t mount_dir_len;

lib/libalpm/graph.h

@@ -23,19 +23,19 @@
 
 #include "alpm_list.h"
 
-enum __alpm_graph_vertex_state {
+enum _alpm_graph_vertex_state {
 	ALPM_GRAPH_STATE_UNPROCESSED,
 	ALPM_GRAPH_STATE_PROCESSING,
 	ALPM_GRAPH_STATE_PROCESSED
 };
 
-typedef struct __alpm_graph_t {
+typedef struct _alpm_graph_t {
 	void *data;
-	struct __alpm_graph_t *parent; /* where did we come from? */
+	struct _alpm_graph_t *parent; /* where did we come from? */
 	alpm_list_t *children;
 	alpm_list_t *iterator; /* used for DFS without recursion */
 	off_t weight; /* weight of the node */
-	enum __alpm_graph_vertex_state state;
+	enum _alpm_graph_vertex_state state;
 } alpm_graph_t;
 
 alpm_graph_t *_alpm_graph_new(void);

lib/libalpm/handle.h

@@ -26,6 +26,7 @@
 
 #include "alpm_list.h"
 #include "alpm.h"
+#include "trans.h"
 
 #ifdef HAVE_LIBCURL
 #include <curl/curl.h>
@@ -50,7 +51,7 @@ do { \
 	} \
 } while(0)
 
-struct __alpm_handle_t {
+struct _alpm_handle_t {
 	/* internal usage */
 	alpm_db_t *db_local;    /* local db pointer */
 	alpm_list_t *dbs_sync;  /* List of (alpm_db_t *) */

lib/libalpm/package.c

@@ -78,6 +78,7 @@ int SYMEXPORT alpm_pkg_checkmd5sum(alpm_pkg_t *pkg)
 static const char *_pkg_get_base(alpm_pkg_t *pkg)        { return pkg->base; }
 static const char *_pkg_get_desc(alpm_pkg_t *pkg)        { return pkg->desc; }
 static const char *_pkg_get_url(alpm_pkg_t *pkg)         { return pkg->url; }
+static char *_pkg_get_note(alpm_pkg_t *pkg)        { return pkg->note; }
 static alpm_time_t _pkg_get_builddate(alpm_pkg_t *pkg)   { return pkg->builddate; }
 static alpm_time_t _pkg_get_installdate(alpm_pkg_t *pkg) { return pkg->installdate; }
 static const char *_pkg_get_packager(alpm_pkg_t *pkg)    { return pkg->packager; }
@@ -142,6 +143,7 @@ const struct pkg_operations default_pkg_ops = {
 	.get_base        = _pkg_get_base,
 	.get_desc        = _pkg_get_desc,
 	.get_url         = _pkg_get_url,
+	.get_note        = _pkg_get_note,
 	.get_builddate   = _pkg_get_builddate,
 	.get_installdate = _pkg_get_installdate,
 	.get_packager    = _pkg_get_packager,
@@ -226,6 +228,13 @@ const char SYMEXPORT *alpm_pkg_get_url(alpm_pkg_t *pkg)
 	return pkg->ops->get_url(pkg);
 }
 
+char SYMEXPORT *alpm_pkg_get_note(alpm_pkg_t *pkg)
+{
+	ASSERT(pkg != NULL, return NULL);
+	pkg->handle->pm_errno = ALPM_ERR_OK;
+	return pkg->ops->get_note(pkg);
+}
+
 alpm_time_t SYMEXPORT alpm_pkg_get_builddate(alpm_pkg_t *pkg)
 {
 	ASSERT(pkg != NULL, return -1);
@@ -610,6 +619,7 @@ int _alpm_pkg_dup(alpm_pkg_t *pkg, alpm_pkg_t **new_ptr)
 	STRDUP(newpkg->version, pkg->version, goto cleanup);
 	STRDUP(newpkg->desc, pkg->desc, goto cleanup);
 	STRDUP(newpkg->url, pkg->url, goto cleanup);
+	STRDUP(newpkg->note, pkg->note, goto cleanup);
 	newpkg->builddate = pkg->builddate;
 	newpkg->installdate = pkg->installdate;
 	STRDUP(newpkg->packager, pkg->packager, goto cleanup);
@@ -683,6 +693,7 @@ void _alpm_pkg_free(alpm_pkg_t *pkg)
 	FREE(pkg->version);
 	FREE(pkg->desc);
 	FREE(pkg->url);
+	FREE(pkg->note);
 	FREE(pkg->packager);
 	FREE(pkg->md5sum);
 	FREE(pkg->sha256sum);

lib/libalpm/package.h

@@ -46,6 +46,7 @@ struct pkg_operations {
 	const char *(*get_base) (alpm_pkg_t *);
 	const char *(*get_desc) (alpm_pkg_t *);
 	const char *(*get_url) (alpm_pkg_t *);
+	char *(*get_note) (alpm_pkg_t *);
 	alpm_time_t (*get_builddate) (alpm_pkg_t *);
 	alpm_time_t (*get_installdate) (alpm_pkg_t *);
 	const char *(*get_packager) (alpm_pkg_t *);
@@ -85,7 +86,7 @@ struct pkg_operations {
  */
 extern const struct pkg_operations default_pkg_ops;
 
-struct __alpm_pkg_t {
+struct _alpm_pkg_t {
 	unsigned long name_hash;
 	char *filename;
 	char *base;
@@ -93,6 +94,7 @@ struct __alpm_pkg_t {
 	char *version;
 	char *desc;
 	char *url;
+	char *note;
 	char *packager;
 	char *md5sum;
 	char *sha256sum;

lib/libalpm/pkghash.h

@@ -32,7 +32,7 @@
  * A combination of a hash table and a list, allowing for fast look-up
  * by package name but also iteration over the packages.
  */
-struct __alpm_pkghash_t {
+struct _alpm_pkghash_t {
 	/** data held by the hash table */
 	alpm_list_t **hash_table;
 	/** head node of the hash table data in normal list format */
@@ -45,7 +45,7 @@ struct __alpm_pkghash_t {
 	unsigned int limit;
 };
 
-typedef struct __alpm_pkghash_t alpm_pkghash_t;
+typedef struct _alpm_pkghash_t alpm_pkghash_t;
 
 alpm_pkghash_t *_alpm_pkghash_create(unsigned int size);
 

lib/libalpm/signing.c

@@ -350,7 +350,7 @@ static int key_search_keyserver(alpm_handle_t *handle, const char *fpr,
 	pgpkey->data = key;
 	if(key->subkeys->fpr) {
 		pgpkey->fingerprint = key->subkeys->fpr;
-	} else if(key->subkeys->keyid) {
+	} else {
 		pgpkey->fingerprint = key->subkeys->keyid;
 	}
 	pgpkey->uid = key->uids->uid;
@@ -504,19 +504,15 @@ int _alpm_key_import(alpm_handle_t *handle, const char *uid, const char *fpr)
 		return -1;
 	}
 
-	STRDUP(fetch_key.uid, uid, return -1);
-	STRDUP(fetch_key.fingerprint, fpr, free(fetch_key.uid); return -1);
 
 	alpm_question_import_key_t question = {
 				.type = ALPM_QUESTION_IMPORT_KEY,
 				.import = 0,
-				.key = &fetch_key
+				.uid = uid,
+				.fingerprint = fpr
 			};
 	QUESTION(handle, &question);
 
-	free(fetch_key.uid);
-	free(fetch_key.fingerprint);
-
 	if(question.import) {
 		/* Try to import the key from a WKD first */
 		if(email_from_uid(uid, &email) == 0) {

lib/libalpm/trans.c

@@ -198,7 +198,8 @@ int SYMEXPORT alpm_trans_commit(alpm_handle_t *handle, alpm_list_t **data)
 		}
 	}
 
-	if(_alpm_hook_run(handle, ALPM_HOOK_PRE_TRANSACTION) != 0) {
+	if(!(trans->flags & ALPM_TRANS_FLAG_NOHOOKS) &&
+			_alpm_hook_run(handle, ALPM_HOOK_PRE_TRANSACTION) != 0) {
 		RET_ERR(handle, ALPM_ERR_TRANS_HOOK_FAILED, -1);
 	}
 
@@ -232,7 +233,10 @@ int SYMEXPORT alpm_trans_commit(alpm_handle_t *handle, alpm_list_t **data)
 		event.type = ALPM_EVENT_TRANSACTION_DONE;
 		EVENT(handle, (void *)&event);
 		alpm_logaction(handle, ALPM_CALLER_PREFIX, "transaction completed\n");
-		_alpm_hook_run(handle, ALPM_HOOK_POST_TRANSACTION);
+
+		if(!(trans->flags & ALPM_TRANS_FLAG_NOHOOKS)) {
+			_alpm_hook_run(handle, ALPM_HOOK_POST_TRANSACTION);
+		}
 	}
 
 	trans->state = STATE_COMMITED;
@@ -294,6 +298,7 @@ void _alpm_trans_free(alpm_trans_t *trans)
 	alpm_list_free(trans->add);
 	alpm_list_free_inner(trans->remove, (alpm_list_fn_free)_alpm_pkg_free);
 	alpm_list_free(trans->remove);
+	FREE(trans->note);
 
 	FREELIST(trans->skip_remove);
 
@@ -446,3 +451,19 @@ alpm_list_t SYMEXPORT *alpm_trans_get_remove(alpm_handle_t *handle)
 
 	return handle->trans->remove;
 }
+
+int SYMEXPORT alpm_trans_set_note(alpm_handle_t *handle, char *note) {
+	CHECK_HANDLE(handle, return -1);
+	ASSERT(handle->trans != NULL, RET_ERR(handle, ALPM_ERR_TRANS_NULL, -1));
+	ASSERT(handle->trans->state == STATE_INITIALIZED, RET_ERR(handle, ALPM_ERR_TRANS_NOT_INITIALIZED, -1));
+
+	if(handle->trans->note) {
+		ASSERT(!strchr(handle->trans->note, '\n'), RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
+		free(handle->trans->note);
+		handle->trans->note = NULL;
+	}
+
+	STRDUP(handle->trans->note, note, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
+	return 0;
+}
+

lib/libalpm/trans.h

@@ -36,15 +36,16 @@ typedef enum _alpm_transstate_t {
 } alpm_transstate_t;
 
 /* Transaction */
-struct __alpm_trans_t {
+typedef struct _alpm_trans_t {
 	/* bitfield of alpm_transflag_t flags */
 	int flags;
+	char *note;
 	alpm_transstate_t state;
 	alpm_list_t *unresolvable;  /* list of (alpm_pkg_t *) */
 	alpm_list_t *add;           /* list of (alpm_pkg_t *) */
 	alpm_list_t *remove;        /* list of (alpm_pkg_t *) */
 	alpm_list_t *skip_remove;   /* list of (char *) */
-};
+} alpm_trans_t;
 
 void _alpm_trans_free(alpm_trans_t *trans);
 /* flags is a bitfield of alpm_transflag_t flags */

scripts/repo-add.sh.in

@@ -42,6 +42,7 @@ LOCKFILE=
 CLEAN_LOCK=0
 USE_COLOR='y'
 PREVENT_DOWNGRADE=0
+INCLUDE_SIGS=0
 
 # Import libmakepkg
 source "$LIBRARY"/util/compress.sh
@@ -260,7 +261,7 @@ db_write_entry() {
 	fi
 
 	# compute base64'd PGP signature
-	if [[ -f "$pkgfile.sig" ]]; then
+	if (( INCLUDE_SIGS )) && [[ -f "$pkgfile.sig" ]]; then
 		if grep -q 'BEGIN PGP SIGNATURE' "$pkgfile.sig"; then
 			error "$(gettext "Cannot use armored signatures for packages: %s")" "$pkgfile.sig"
 			return 1
@@ -622,6 +623,9 @@ while (( $# )); do
 		-p|--prevent-downgrade)
 			PREVENT_DOWNGRADE=1
 			;;
+		--include-sigs)
+			INCLUDE_SIGS=1
+			;;
 		*)
 			args+=("$1")
 			;;

src/pacman/callback.c

@@ -541,12 +541,12 @@ void cb_question(void *ctx, alpm_question_t *question)
 			{
 				alpm_question_import_key_t *q = &question->import_key;
 				/* the uid is unknown with db signatures */
-				if (q->key->uid == NULL) {
+				if (q->uid == NULL) {
 					q->import = yesno(_("Import PGP key %s?"),
-							q->key->fingerprint);
+							q->fingerprint);
 				} else {
 					q->import = yesno(_("Import PGP key %s, \"%s\"?"),
-							q->key->fingerprint, q->key->uid);
+							q->fingerprint, q->uid);
 				}
 			}
 			break;

src/pacman/conf.c

@@ -155,6 +155,7 @@ int config_free(config_t *oldconfig)
 	free(oldconfig->dbpath);
 	free(oldconfig->logfile);
 	free(oldconfig->gpgdir);
+	free(oldconfig->note);
 	FREELIST(oldconfig->hookdirs);
 	FREELIST(oldconfig->cachedirs);
 	free(oldconfig->xfercommand);

src/pacman/conf.h

@@ -99,6 +99,8 @@ typedef struct __config_t {
 	unsigned int ask;
 	/* Bitfield of alpm_transflag_t */
 	int flags;
+	char *note;
+	int rmnote;
 	/* Bitfields of alpm_siglevel_t */
 	int siglevel;
 	int localfilesiglevel;
@@ -170,6 +172,8 @@ enum {
 	OP_IGNOREGROUP,
 	OP_NEEDED,
 	OP_ASEXPLICIT,
+	OP_NOTE,
+	OP_RMNOTE,
 	OP_ARCH,
 	OP_PRINTFORMAT,
 	OP_GPGDIR,

src/pacman/database.c

@@ -38,11 +38,12 @@
  *
  * @return 0 on success, 1 on failure
  */
-static int change_install_reason(alpm_list_t *targets)
+static int change_pkg(alpm_list_t *targets)
 {
 	alpm_list_t *i;
 	alpm_db_t *db_local;
 	int ret = 0;
+	int set_reason = 0;
 
 	alpm_pkgreason_t reason;
 
@@ -53,11 +54,10 @@ static int change_install_reason(alpm_list_t *targets)
 
 	if(config->flags & ALPM_TRANS_FLAG_ALLDEPS) { /* --asdeps */
 		reason = ALPM_PKG_REASON_DEPEND;
+		set_reason = 1;
 	} else if(config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT) { /* --asexplicit */
 		reason = ALPM_PKG_REASON_EXPLICIT;
-	} else {
-		pm_printf(ALPM_LOG_ERROR, _("no install reason specified (use -h for help)\n"));
-		return 1;
+		set_reason = 1;
 	}
 
 	/* Lock database */
@@ -69,19 +69,46 @@ static int change_install_reason(alpm_list_t *targets)
 	for(i = targets; i; i = alpm_list_next(i)) {
 		char *pkgname = i->data;
 		alpm_pkg_t *pkg = alpm_db_get_pkg(db_local, pkgname);
-		if(!pkg || alpm_pkg_set_reason(pkg, reason)) {
-			pm_printf(ALPM_LOG_ERROR, _("could not set install reason for package %s (%s)\n"),
-							pkgname, alpm_strerror(alpm_errno(config->handle)));
+
+		if(!pkg) {
+			pm_printf(ALPM_LOG_ERROR, _("package '%s' was not found"), pkgname);
 			ret = 1;
-		} else {
-			if(!config->quiet) {
-				if(reason == ALPM_PKG_REASON_DEPEND) {
-					printf(_("%s: install reason has been set to 'installed as dependency'\n"), pkgname);
-				} else {
-					printf(_("%s: install reason has been set to 'explicitly installed'\n"), pkgname);
+			continue;
+		}
+
+		if(set_reason) {
+			if(alpm_pkg_set_reason(pkg, reason)) {
+				pm_printf(ALPM_LOG_ERROR, _("could not set install reason for package %s (%s)\n"),
+								pkgname, alpm_strerror(alpm_errno(config->handle)));
+				ret = 1;
+			} else {
+				if(!config->quiet) {
+					if(reason == ALPM_PKG_REASON_DEPEND) {
+						printf(_("%s: install reason has been set to 'installed as dependency'\n"), pkgname);
+					} else {
+						printf(_("%s: install reason has been set to 'explicitly installed'\n"), pkgname);
+					}
 				}
 			}
 		}
+
+		if(config->rmnote) {
+			if(alpm_pkg_set_note(pkg, NULL)) {
+				pm_printf(ALPM_LOG_ERROR, _("could not set install note for package %s (%s)\n"),
+								pkgname, alpm_strerror(alpm_errno(config->handle)));
+				ret = 1;
+			} else if(!config->quiet) {
+				printf(_("%s: note removed\n"), pkgname);
+			}
+		} else if(config->note) {
+			if(alpm_pkg_set_note(pkg, config->note)) {
+				pm_printf(ALPM_LOG_ERROR, _("could not set install note for package %s (%s)\n"),
+								pkgname, alpm_strerror(alpm_errno(config->handle)));
+				ret = 1;
+			} else if(!config->quiet) {
+				printf(_("%s: note set\n"), pkgname);
+			}
+		}
 	}
 
 	/* Unlock database */
@@ -296,8 +323,9 @@ int pacman_database(alpm_list_t *targets)
 		}
 	}
 
-	if(config->flags & (ALPM_TRANS_FLAG_ALLDEPS | ALPM_TRANS_FLAG_ALLEXPLICIT)) {
-		ret = change_install_reason(targets);
+	if(config->note || config->rmnote ||
+			(config->flags & (ALPM_TRANS_FLAG_ALLDEPS | ALPM_TRANS_FLAG_ALLEXPLICIT))) {
+		ret = change_pkg(targets);
 	}
 
 	return ret;

src/pacman/package.c

@@ -70,6 +70,7 @@ enum {
 	T_URL,
 	T_VALIDATED_BY,
 	T_VERSION,
+	T_NOTE,
 	/* the following is a sentinel and should remain in last position */
 	_T_MAX
 };
@@ -124,6 +125,7 @@ static void make_aligned_titles(void)
 	buf[T_URL] = _("URL");
 	buf[T_VALIDATED_BY] = _("Validated By");
 	buf[T_VERSION] = _("Version");
+	buf[T_NOTE] = _("Note");
 
 	for(i = 0; i < ARRAYSIZE(wbuf); i++) {
 		wlen[i] = mbstowcs(wbuf[i], buf[i], strlen(buf[i]) + 1);
@@ -301,6 +303,7 @@ void dump_pkg_full(alpm_pkg_t *pkg, int extra)
 	if(from == ALPM_PKG_FROM_LOCALDB) {
 		string_display(titles[T_INSTALL_DATE], idatestr, cols);
 		string_display(titles[T_INSTALL_REASON], reason, cols);
+		string_display(titles[T_NOTE], alpm_pkg_get_note(pkg), cols);
 	}
 	if(from == ALPM_PKG_FROM_FILE || from == ALPM_PKG_FROM_LOCALDB) {
 		string_display(titles[T_INSTALL_SCRIPT],

src/pacman/pacman.c

@@ -169,6 +169,8 @@ static void usage(int op, const char * const myname)
 			printf("%s:\n", str_opt);
 			addlist(_("      --asdeps         mark packages as non-explicitly installed\n"));
 			addlist(_("      --asexplicit     mark packages as explicitly installed\n"));
+			addlist(_("      --note <note>    add or edit a packages install notes\n"));
+			addlist(_("      --rmnote         remove install note from packages\n"));
 			addlist(_("  -k, --check          test local database for validity (-kk for sync databases)\n"));
 			addlist(_("  -q, --quiet          suppress output of success messages\n"));
 		} else if(op == PM_OP_DEPTEST) {
@@ -193,6 +195,7 @@ static void usage(int op, const char * const myname)
 				          "                       overwrite conflicting files (can be used more than once)\n"));
 				addlist(_("      --asdeps         install packages as non-explicitly installed\n"));
 				addlist(_("      --asexplicit     install packages as explicitly installed\n"));
+				addlist(_("      --note <note>    add an install note to packages\n"));
 				addlist(_("      --ignore <pkg>   ignore a package upgrade (can be used more than once)\n"));
 				addlist(_("      --ignoregroup <grp>\n"
 				          "                       ignore a group upgrade (can be used more than once)\n"));
@@ -481,6 +484,12 @@ static int parsearg_database(int opt)
 		case OP_ASEXPLICIT:
 			config->flags |= ALPM_TRANS_FLAG_ALLEXPLICIT;
 			break;
+		case OP_NOTE:
+			config->note = strdup(optarg);
+			break;
+		case OP_RMNOTE:
+			config->rmnote = 1;
+			break;
 		case OP_CHECK:
 		case 'k':
 			(config->op_q_check)++;
@@ -501,7 +510,11 @@ static void checkargs_database(void)
 			&& config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT,
 			"--asdeps", "--asexplicit");
 
+	invalid_opt(config->note && config->rmnote, "--note", "--rmnote");
+
 	if(config->op_q_check) {
+	invalid_opt(config->note != NULL, "--note", "--check");
+	invalid_opt(config->rmnote, "--rmnote", "--check");
 		invalid_opt(config->flags & ALPM_TRANS_FLAG_ALLDEPS,
 				"--asdeps", "--check");
 		invalid_opt(config->flags & ALPM_TRANS_FLAG_ALLEXPLICIT,
@@ -634,6 +647,7 @@ static int parsearg_trans(int opt)
 		case OP_DBONLY:
 			config->flags |= ALPM_TRANS_FLAG_DBONLY;
 			config->flags |= ALPM_TRANS_FLAG_NOSCRIPTLET;
+			config->flags |= ALPM_TRANS_FLAG_NOHOOKS;
 			break;
 		case OP_NOPROGRESSBAR:
 			config->noprogressbar = 1;
@@ -727,6 +741,9 @@ static int parsearg_upgrade(int opt)
 		case OP_ASEXPLICIT:
 			config->flags |= ALPM_TRANS_FLAG_ALLEXPLICIT;
 			break;
+		case OP_NOTE:
+			config->note = strdup(optarg);
+			break;
 		case OP_NEEDED:
 			config->flags |= ALPM_TRANS_FLAG_NEEDED;
 			break;
@@ -941,6 +958,8 @@ static int parseargs(int argc, char *argv[])
 		{"ignoregroup", required_argument, 0, OP_IGNOREGROUP},
 		{"needed",     no_argument,       0, OP_NEEDED},
 		{"asexplicit",     no_argument,   0, OP_ASEXPLICIT},
+		{"note",       required_argument, 0, OP_NOTE},
+		{"rmnote",     no_argument,       0, OP_RMNOTE},
 		{"arch",       required_argument, 0, OP_ARCH},
 		{"print-format", required_argument, 0, OP_PRINTFORMAT},
 		{"gpgdir",     required_argument, 0, OP_GPGDIR},

src/pacman/query.c

@@ -329,9 +329,15 @@ static int display(alpm_pkg_t *pkg)
 			&& !config->op_q_changelog && !config->op_q_check) {
 		if(!config->quiet) {
 			const colstr_t *colstr = &config->colstr;
+			char *note = alpm_pkg_get_note(pkg);
+
 			printf("%s%s %s%s%s", colstr->title, alpm_pkg_get_name(pkg),
 					colstr->version, alpm_pkg_get_version(pkg), colstr->nocolor);
 
+			if(note) {
+				printf(" (%s)", note);
+			}
+
 			if(config->op_q_upgrade) {
 				int usage;
 				alpm_pkg_t *newpkg = alpm_sync_get_new_version(pkg, alpm_get_syncdbs(config->handle));

src/pacman/util.c

@@ -72,6 +72,15 @@ int trans_init(int flags, int check_valid)
 		trans_init_error();
 		return -1;
 	}
+
+	if(config->note) {
+		ret = alpm_trans_set_note(config->handle, config->note);
+		if(ret == -1) {
+			trans_init_error();
+			return -1;
+		}
+	}
+
 	return 0;
 }
 

test/pacman/meson.build

@@ -9,6 +9,8 @@ pacman_tests = [
   'tests/config002.py',
   'tests/database001.py',
   'tests/database002.py',
+  'tests/database003.py',
+  'tests/database004.py',
   'tests/database010.py',
   'tests/database011.py',
   'tests/database012.py',
@@ -174,6 +176,7 @@ pacman_tests = [
   'tests/symlink020.py',
   'tests/symlink021.py',
   'tests/sync-failover-404-with-body.py',
+  'tests/sync-keep-note.py',
   'tests/sync-install-assumeinstalled.py',
   'tests/sync-nodepversion01.py',
   'tests/sync-nodepversion02.py',
@@ -181,6 +184,7 @@ pacman_tests = [
   'tests/sync-nodepversion04.py',
   'tests/sync-nodepversion05.py',
   'tests/sync-nodepversion06.py',
+  'tests/sync-note-targets-only.py',
   'tests/sync-sysupgrade-print-replaced-packages.py',
   'tests/sync-update-assumeinstalled.py',
   'tests/sync-update-package-removing-required-provides.py',

test/pacman/pmdb.py

@@ -121,6 +121,8 @@ class pmdb(object):
                 pkg.groups = _getsection(fd)
             elif line == "%URL%":
                 pkg.url = fd.readline().strip("\n")
+            elif line == "%NOTE%":
+                pkg.note = fd.readline().strip("\n")
             elif line == "%LICENSE%":
                 pkg.license = _getsection(fd)
             elif line == "%ARCH%":
@@ -208,6 +210,7 @@ class pmdb(object):
             make_section(data, "INSTALLDATE", pkg.installdate)
             make_section(data, "SIZE", pkg.size)
             make_section(data, "REASON", pkg.reason)
+            make_section(data, "NOTE", pkg.note)
         else:
             make_section(data, "FILENAME", pkg.filename())
             make_section(data, "REPLACES", pkg.replaces)

test/pacman/pmpkg.py

@@ -34,6 +34,7 @@ class pmpkg(object):
         self.desc = ""
         self.groups = []
         self.url = ""
+        self.note = ""
         self.license = []
         self.arch = ""
         self.builddate = ""
@@ -71,6 +72,7 @@ class pmpkg(object):
         s.append("url: %s" % self.url)
         s.append("files: %s" % " ".join(self.files))
         s.append("reason: %d" % self.reason)
+        s.append("note: %s" % self.note)
         return "\n".join(s)
 
     def fullname(self):

test/pacman/pmrule.py

@@ -108,6 +108,9 @@ class pmrule(object):
                         if f.startswith(value + "\t"):
                             success = 1
                             break;
+                elif case == "NOTE":
+                    if newpkg.note != value:
+                        success = 0
                 else:
                     tap.diag("PKG rule '%s' not found" % case)
                     success = -1

test/pacman/pmtest.py

@@ -322,7 +322,7 @@ class pmtest(object):
                 self.result["success"] += 1
             else:
                 self.result["fail"] += 1
-            tap.ok(success, i)
+            tap.ok(success == 1, i)
 
     def configfile(self):
         return os.path.join(self.root, util.PACCONF)

test/pacman/tests/database003.py

@@ -0,0 +1,10 @@
+self.description = "-D --note :D"
+
+lp = pmpkg("pkg")
+self.addpkg2db("local", lp)
+
+self.args = "-D pkg --note :D"
+
+self.addrule("PACMAN_RETCODE=0")
+self.addrule("PKG_EXIST=pkg")
+self.addrule("PKG_NOTE=pkg|:D")

test/pacman/tests/database004.py

@@ -0,0 +1,11 @@
+self.description = "-D --rmnote"
+
+lp = pmpkg("pkg")
+lp.note = "D:"
+self.addpkg2db("local", lp)
+
+self.args = "-D pkg --rmnote"
+
+self.addrule("PACMAN_RETCODE=0")
+self.addrule("PKG_EXIST=pkg")
+self.addrule("PKG_NOTE=pkg|")

test/pacman/tests/sync-keep-note.py

@@ -0,0 +1,14 @@
+self.description = "Sync a package keeping the existing note"
+
+sp = pmpkg("pkg")
+self.addpkg2db("sync", sp)
+
+lp = pmpkg("pkg")
+lp.note = "this is a note"
+self.addpkg2db("local", lp)
+
+self.args = "-S pkg"
+
+self.addrule("PACMAN_RETCODE=0")
+self.addrule("PKG_EXIST=pkg")
+self.addrule("PKG_NOTE=pkg|this is a note")

test/pacman/tests/sync-note-targets-only.py

@@ -0,0 +1,30 @@
+self.description = "Make sure note is only set for targets"
+
+sp1 = pmpkg("pkg1", "1.0-2")
+sp1.depends = ["pkg2"]
+
+sp2 = pmpkg("pkg2")
+
+sp3 = pmpkg("pkg3")
+sp3.depends = ["pkg4"]
+
+sp4 = pmpkg("pkg4")
+
+for p in sp1, sp2, sp3, sp4:
+	self.addpkg2db("sync", p)
+
+lp1 = pmpkg("pkg1")
+self.addpkg2db("local", lp1)
+
+self.args = "-S pkg1 pkg3 --note aaaa"
+
+self.addrule("PACMAN_RETCODE=0")
+self.addrule("PKG_EXIST=pkg1")
+self.addrule("PKG_EXIST=pkg2")
+self.addrule("PKG_EXIST=pkg3")
+self.addrule("PKG_EXIST=pkg4")
+
+self.addrule("PKG_NOTE=pkg1|aaaa")
+self.addrule("PKG_NOTE=pkg2|")
+self.addrule("PKG_NOTE=pkg3|aaaa")
+self.addrule("PKG_NOTE=pkg4|")