On 15/09/15 08:46, Andrew Gregory wrote:
> ---
>
> Hopefully it will make it into the thread this time...
>
> lib/libalpm/Makefile.am | 2 +
> lib/libalpm/alpm.c | 7 +-
> lib/libalpm/alpm.h | 10 ++
> lib/libalpm/handle.c | 59 +++++++
> lib/libalpm/handle.h | 1 +
> lib/libalpm/hook.c | 443
> ++++++++++++++++++++++++++++++++++++++++++++++++
> lib/libalpm/hook.h | 34 ++++
> lib/libalpm/trans.c | 6 +
> 8 files changed, 561 insertions(+), 1 deletion(-)
> create mode 100644 lib/libalpm/hook.c
> create mode 100644 lib/libalpm/hook.h
>
Looks good overall. There are some minor comments below.
I could not understand the various loops for hook matching. Can you
give me an explanation?
> diff --git a/lib/libalpm/Makefile.am b/lib/libalpm/Makefile.am
> index f66daed..77e68a4 100644
> --- a/lib/libalpm/Makefile.am
> +++ b/lib/libalpm/Makefile.am
> @@ -42,6 +42,8 @@ libalpm_la_SOURCES = \
> graph.h graph.c \
> group.h group.c \
> handle.h handle.c \
> + hook.h hook.c \
> + ini.h ini.c \
> libarchive-compat.h \
> log.h log.c \
> package.h package.c \
> diff --git a/lib/libalpm/alpm.c b/lib/libalpm/alpm.c
> index d77b43a..b3f0734 100644
> --- a/lib/libalpm/alpm.c
> +++ b/lib/libalpm/alpm.c
> @@ -49,7 +49,8 @@ alpm_handle_t SYMEXPORT *alpm_initialize(const char *root,
> const char *dbpath,
> alpm_errno_t *err)
> {
> alpm_errno_t myerr;
> - const char *lf = "db.lck";
> + const char *lf = "db.lck", *syshookdir = "usr/share/alpm/hooks/";
This needs to be a define. Look at how $(conffile) is set in configure
and then -DCONFFILE in pacman/Makefile.am. Use libalpm instead of just
alpm. $datarootdir/libalpm/hooks.
> + char *hookdir;
> size_t lockfilelen;
> alpm_handle_t *myhandle = _alpm_handle_new();
>
> @@ -64,6 +65,10 @@ alpm_handle_t SYMEXPORT *alpm_initialize(const char *root,
> const char *dbpath,
> goto cleanup;
> }
>
> + MALLOC(hookdir, strlen(myhandle->root) + strlen(syshookdir) + 1, goto
> cleanup);
> + sprintf(hookdir, "%s%s", myhandle->root, syshookdir);
> + myhandle->hookdirs = alpm_list_add(NULL, hookdir);
> +
> /* set default database extension */
> STRDUP(myhandle->dbext, ".db", goto cleanup);
>
OK.
> diff --git a/lib/libalpm/alpm.h b/lib/libalpm/alpm.h
> index 594f0b6..3049f2f 100644
> --- a/lib/libalpm/alpm.h
> +++ b/lib/libalpm/alpm.h
> @@ -87,6 +87,7 @@ typedef enum _alpm_errno_t {
> ALPM_ERR_TRANS_ABORT,
> ALPM_ERR_TRANS_TYPE,
> ALPM_ERR_TRANS_NOT_LOCKED,
> + ALPM_ERR_TRANS_HOOK_FAILED,
> /* Packages */
> ALPM_ERR_PKG_NOT_FOUND,
> ALPM_ERR_PKG_IGNORED,
> @@ -775,6 +776,15 @@ int alpm_option_add_cachedir(alpm_handle_t *handle,
> const char *cachedir);
> int alpm_option_remove_cachedir(alpm_handle_t *handle, const char *cachedir);
> /** @} */
>
> +/** @name Accessors to the list of package hook directories.
> + * @{
> + */
> +alpm_list_t *alpm_option_get_hookdirs(alpm_handle_t *handle);
> +int alpm_option_set_hookdirs(alpm_handle_t *handle, alpm_list_t *hookdirs);
> +int alpm_option_add_hookdir(alpm_handle_t *handle, const char *hookdir);
> +int alpm_option_remove_hookdir(alpm_handle_t *handle, const char *hookdir);
> +/** @} */
> +
> /** Returns the logfile name. */
> const char *alpm_option_get_logfile(alpm_handle_t *handle);
> /** Sets the logfile name. */
OK.
> diff --git a/lib/libalpm/handle.c b/lib/libalpm/handle.c
> index a12ac50..98420b0 100644
> --- a/lib/libalpm/handle.c
> +++ b/lib/libalpm/handle.c
> @@ -83,6 +83,7 @@ void _alpm_handle_free(alpm_handle_t *handle)
> FREE(handle->dbpath);
> FREE(handle->dbext);
> FREELIST(handle->cachedirs);
> + FREELIST(handle->hookdirs);
> FREE(handle->logfile);
> FREE(handle->lockfile);
> FREE(handle->arch);
> @@ -207,6 +208,12 @@ const char SYMEXPORT
> *alpm_option_get_dbpath(alpm_handle_t *handle)
> return handle->dbpath;
> }
>
> +alpm_list_t SYMEXPORT *alpm_option_get_hookdirs(alpm_handle_t *handle)
> +{
> + CHECK_HANDLE(handle, return NULL);
> + return handle->hookdirs;
> +}
> +
> alpm_list_t SYMEXPORT *alpm_option_get_cachedirs(alpm_handle_t *handle)
> {
> CHECK_HANDLE(handle, return NULL);
> @@ -387,6 +394,58 @@ alpm_errno_t _alpm_set_directory_option(const char
> *value,
> return 0;
> }
>
> +int SYMEXPORT alpm_option_add_hookdir(alpm_handle_t *handle, const char
> *hookdir)
> +{
> + char *newhookdir;
> +
> + CHECK_HANDLE(handle, return -1);
> + ASSERT(hookdir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
> +
> + newhookdir = canonicalize_path(hookdir);
> + if(!newhookdir) {
> + RET_ERR(handle, ALPM_ERR_MEMORY, -1);
> + }
> + handle->hookdirs = alpm_list_add(handle->hookdirs, newhookdir);
> + _alpm_log(handle, ALPM_LOG_DEBUG, "option 'hookdir' = %s\n",
> newhookdir);
> + return 0;
> +}
> +
> +int SYMEXPORT alpm_option_set_hookdirs(alpm_handle_t *handle, alpm_list_t
> *hookdirs)
> +{
> + alpm_list_t *i;
> + CHECK_HANDLE(handle, return -1);
> + if(handle->hookdirs) {
> + FREELIST(handle->hookdirs);
> + }
> + for(i = hookdirs; i; i = i->next) {
> + int ret = alpm_option_add_hookdir(handle, i->data);
> + if(ret) {
> + return ret;
> + }
> + }
> + return 0;
> +}
> +
> +int SYMEXPORT alpm_option_remove_hookdir(alpm_handle_t *handle, const char
> *hookdir)
> +{
> + char *vdata = NULL;
> + char *newhookdir;
> + CHECK_HANDLE(handle, return -1);
> + ASSERT(hookdir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
> +
> + newhookdir = canonicalize_path(hookdir);
> + if(!newhookdir) {
> + RET_ERR(handle, ALPM_ERR_MEMORY, -1);
> + }
> + handle->hookdirs = alpm_list_remove_str(handle->hookdirs, newhookdir,
> &vdata);
> + FREE(newhookdir);
> + if(vdata != NULL) {
> + FREE(vdata);
> + return 1;
> + }
> + return 0;
> +}
> +
> int SYMEXPORT alpm_option_add_cachedir(alpm_handle_t *handle, const char
> *cachedir)
> {
> char *newcachedir;
OK.
> diff --git a/lib/libalpm/handle.h b/lib/libalpm/handle.h
> index 315d987..e252fbf 100644
> --- a/lib/libalpm/handle.h
> +++ b/lib/libalpm/handle.h
> @@ -82,6 +82,7 @@ struct __alpm_handle_t {
> char *lockfile; /* Name of the lock file */
> char *gpgdir; /* Directory where GnuPG files are stored */
> alpm_list_t *cachedirs; /* Paths to pacman cache directories */
> + alpm_list_t *hookdirs; /* Paths to hook directories */
>
> /* package lists */
> alpm_list_t *noupgrade; /* List of packages NOT to be upgraded */
OK.
> diff --git a/lib/libalpm/hook.c b/lib/libalpm/hook.c
> new file mode 100644
> index 0000000..66cedaa
> --- /dev/null
> +++ b/lib/libalpm/hook.c
> @@ -0,0 +1,443 @@
> +/*
> + * hook.c
> + *
> + * Copyright (c) 2015 Pacman Development Team <[email protected]>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program. If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include <string.h>
> +#include <errno.h>
> +#include <dirent.h>
> +#include <fcntl.h>
> +
> +#include "alpm.h"
> +#include "handle.h"
> +#include "hook.h"
> +#include "ini.h"
> +#include "util.h"
> +#include "trans.h"
> +#include "log.h"
> +
> +enum alpm_hook_op_t {
> + ALPM_HOOK_OP_SYNC = 1,
> + ALPM_HOOK_OP_REMOVE,
> +};
> +
> +enum alpm_hook_type_t {
> + ALPM_HOOK_TYPE_PACKAGE = 1,
> + ALPM_HOOK_TYPE_FILE,
> +};
> +
> +struct alpm_trigger_t {
> + enum alpm_hook_op_t op;
> + enum alpm_hook_type_t type;
> + alpm_list_t *targets;
> +};
> +
OK.
> +struct alpm_hook_t {
> + char *name;
> + alpm_list_t *triggers;
> + alpm_list_t *depends;
> + char *cmd;
> + enum _alpm_hook_when_t when;
> + int abort_on_fail;
> +};
OK.
> +struct _alpm_hook_cb_ctx {
> + alpm_handle_t *handle;
> + struct alpm_hook_t *hook;
> +};
> +
> +static void _alpm_trigger_free(struct alpm_trigger_t *trigger)
> +{
> + if(trigger) {
> + FREELIST(trigger->targets);
> + free(trigger);
> + }
> +}
> +
OK
> +static void _alpm_hook_free(struct alpm_hook_t *hook)
> +{
> + if(hook) {
> + free(hook->name);
> + free(hook->cmd);
> + alpm_list_free_inner(hook->triggers, (alpm_list_fn_free)
> _alpm_trigger_free);
> + alpm_list_free(hook->triggers);
> + FREELIST(hook->depends);
> + free(hook);
> + }
> +}
OK
> +static int _alpm_trigger_validate(alpm_handle_t *handle,
> + struct alpm_trigger_t *trigger, const char *file)
> +{
> + int ret = 0;
> +
> + if(trigger->targets == NULL) {
> + ret = -1;
> + _alpm_log(handle, ALPM_LOG_ERROR,
> + _("Missing trigger targets in hook: %s\n"),
> file);
> + }
> +
> + if(trigger->type == 0) {
> + ret = -1;
> + _alpm_log(handle, ALPM_LOG_ERROR,
> + _("Missing trigger type in hook: %s\n"), file);
> + }
> +
> + if(trigger->op == 0) {
> + ret = -1;
> + _alpm_log(handle, ALPM_LOG_ERROR,
> + _("Missing trigger operation in hook: %s\n"),
> file);
> + }
> +
> + return ret;
> +}
> +
OK
> +static int _alpm_hook_validate(alpm_handle_t *handle,
> + struct alpm_hook_t *hook, const char *file)
> +{
> + alpm_list_t *i;
> + int ret = 0;
> +
> + if(hook->triggers == NULL) {
> + /* special case: empty trigger section */
> + return 0;
> + }
> +
Why do we need this?
> + for(i = hook->triggers; i; i = i->next) {
> + if(_alpm_trigger_validate(handle, i->data, file) != 0) {
> + ret = -1;
> + }
> + }
> +
> + if(hook->cmd == NULL) {
> + ret = -1;
> + _alpm_log(handle, ALPM_LOG_ERROR,
> + _("Missing Exec option in hook: %s\n"), file);
> + }
> +
> + if(hook->when == 0) {
> + ret = -1;
> + _alpm_log(handle, ALPM_LOG_ERROR,
> + _("Missing When option in hook: %s\n"), file);
> + } else if(hook->when != ALPM_HOOK_PRE_TRANSACTION &&
> hook->abort_on_fail) {
> + _alpm_log(handle, ALPM_LOG_WARNING,
> + _("AbortOnFail set for PostTransaction hook:
> %s\n"), file);
> + }
> +
> + return ret;
> +}
> +
OK
> +static int _alpm_hook_parse_cb(const char *file, UNUSED int line,
> + const char *section, char *key, char *value, void *data)
> +{
> + struct _alpm_hook_cb_ctx *ctx = data;
> + alpm_handle_t *handle = ctx->handle;
> + struct alpm_hook_t *hook = ctx->hook;
> +
> +#define error(...) _alpm_log(handle, ALPM_LOG_ERROR, __VA_ARGS__); return 1;
> +
> + if(!section && !key) {
> + error(_("error while reading file %s: %s\n"), file,
> strerror(errno));
> + } else if(!section) {
> + error(_("error parsing hook file %s: invalid option %s\n"),
> file, key);
> + } else if(!key) {
> + /* beginning a new section */
> + if(strcmp(section, "Trigger") == 0) {
> + struct alpm_trigger_t *t;
> + CALLOC(t, sizeof(struct alpm_trigger_t), 1, return 1);
> + hook->triggers = alpm_list_add(hook->triggers, t);
> + } else if(strcmp(section, "Action") == 0) {
> + /* no special processing required */
> + } else {
> + error(_("error parsing hook file %s: invalid section
> %s\n"), file, section);
> + }
> + } else if(strcmp(section, "Trigger") == 0) {
> + struct alpm_trigger_t *t = hook->triggers->prev->data;
> + if(strcmp(key, "Operation") == 0) {
> + if(strcmp(value, "Sync") == 0) {
> + t->op = ALPM_HOOK_OP_SYNC;
> + } else if(strcmp(value, "Remove") == 0) {
> + t->op = ALPM_HOOK_OP_REMOVE;
> + } else {
> + error(_("error parsing hook file %s: invalid
> value %s\n"), file, value);
> + }
> + } else if(strcmp(key, "Type") == 0) {
> + if(strcmp(value, "Package") == 0) {
> + t->type = ALPM_HOOK_TYPE_PACKAGE;
> + } else if(strcmp(value, "File") == 0) {
> + t->type = ALPM_HOOK_TYPE_FILE;
> + } else {
> + error(_("error parsing hook file %s: invalid
> value %s\n"), file, value);
> + }
> + } else if(strcmp(key, "Target") == 0) {
> + char *val;
> + STRDUP(val, value, return 1);
> + t->targets = alpm_list_add(t->targets, val);
> + } else {
> + error(_("error parsing hook file %s: invalid option
> %s\n"), file, key);
> + }
> + } else if(strcmp(section, "Action") == 0) {
> + if(strcmp(key, "When") == 0) {
> + if(strcmp(value, "PreTransaction") == 0) {
> + hook->when = ALPM_HOOK_PRE_TRANSACTION;
> + } else if(strcmp(value, "PostTransaction") == 0) {
> + hook->when = ALPM_HOOK_POST_TRANSACTION;
> + } else {
> + error(_("error parsing hook file %s: invalid
> value %s\n"), file, value);
> + }
> + } else if(strcmp(key, "Depends") == 0) {
> + char *val;
> + STRDUP(val, value, return 1);
> + hook->depends = alpm_list_add(hook->depends, val);
> + } else if(strcmp(key, "AbortOnFail") == 0) {
> + hook->abort_on_fail = 1;
> + } else if(strcmp(key, "Exec") == 0) {
> + STRDUP(hook->cmd, value, return 1);
> + } else {
> + error(_("error parsing hook file %s: invalid option
> %s\n"), file, value);
> + }
> + }
> +
> +#undef error
> +
> + return 0;
> +}
> +
OK
> +static int _alpm_hook_trigger_match_file(alpm_handle_t *handle, struct
> alpm_trigger_t *t)
> +{
> + alpm_list_t *i;
> + alpm_db_t *localdb = handle->db_local;
> +
> + for(i = handle->trans->add; i; i = i->next) {
> + alpm_pkg_t *pkg = i->data;
> + alpm_filelist_t filelist = pkg->files;
> + size_t j;
> + for(j = 0; j < filelist.count; j++) {
> + if(alpm_option_match_noextract(handle,
> filelist.files[j].name) == 0) {
> + continue;
> + }
Nest the above within the if() below
> + if(_alpm_fnmatch_patterns(t->targets,
> filelist.files[j].name) == 0) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "matched file
> %s\n",
> + filelist.files[j].name);
> + return t->op == ALPM_HOOK_OP_SYNC ? 1 : 0;
> + }
> + }
> + }
> +
> + if(t->op == ALPM_HOOK_OP_REMOVE) {
> + for(i = handle->trans->add; i; i = i->next) {
trans->remove?
> + alpm_pkg_t *spkg = i->data;
> + alpm_pkg_t *pkg = alpm_db_get_pkg(localdb, spkg->name);
> + alpm_filelist_t filelist = pkg->files;
> + size_t j;
> + for(j = 0; j < filelist.count; j++) {
> + if(_alpm_fnmatch_patterns(t->targets,
> filelist.files[j].name) == 0) {
> + _alpm_log(handle, ALPM_LOG_DEBUG,
> "matched file %s\n",
> + filelist.files[j].name);
> + return 1;
> + }
> + }
> + }
> + for(i = handle->trans->remove; i; i = i->next) {
> + alpm_pkg_t *pkg = i->data;
> + alpm_filelist_t filelist = pkg->files;
> + size_t j;
> + for(j = 0; j < filelist.count; j++) {
> + if(_alpm_fnmatch_patterns(t->targets,
> filelist.files[j].name) == 0) {
> + _alpm_log(handle, ALPM_LOG_DEBUG,
> "matched file %s\n",
> + filelist.files[j].name);
> + return 1;
> + }
> + }
> + }
> + }
> +
> + return 0;
> +}
> +
I don't understand what is going on here...
First for loop is over trans->add and then does ALPM_HOOK_O_SYNC ? 1 :
0. What is that doing?
What are the two loops for ALPM_HOOK_OP_REMOVE?
Comments to explain this would be helpful.
> +static int _alpm_hook_trigger_match_pkg(alpm_handle_t *handle, struct
> alpm_trigger_t *t)
> +{
> + alpm_list_t *i;
> +
> + for(i = handle->trans->add; i; i = i->next) {
> + alpm_pkg_t *pkg = i->data;
> + if(_alpm_fnmatch_patterns(t->targets, pkg->name) == 0) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "matched package
> %s\n", pkg->name);
> + return t->op == ALPM_HOOK_OP_SYNC ? 1 : 0;
> + }
> + }
> +
> + if(t->op == ALPM_HOOK_OP_REMOVE) {
> + for(i = handle->trans->remove; i; i = i->next) {
> + alpm_pkg_t *pkg = i->data;
> + if(pkg && _alpm_fnmatch_patterns(t->targets, pkg->name)
> == 0) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "matched
> package %s\n", pkg->name);
> + return 1;
> + }
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int _alpm_hook_trigger_match(alpm_handle_t *handle, struct
> alpm_trigger_t *t)
> +{
> + return t->type == ALPM_HOOK_TYPE_PACKAGE
> + ? _alpm_hook_trigger_match_pkg(handle, t)
> + : _alpm_hook_trigger_match_file(handle, t);
> +}
> +
OK.
> +static int _alpm_hook_triggered(alpm_handle_t *handle, struct alpm_hook_t
> *hook)
> +{
> + alpm_list_t *i;
> + for(i = hook->triggers; i; i = i->next) {
> + if(_alpm_hook_trigger_match(handle, i->data)) {
> + return 1;
> + }
> + }
> + return 0;
> +}
> +
OK
> +static alpm_list_t *find_hook(alpm_list_t *haystack, const void *needle)
> +{
> + while(haystack) {
> + struct alpm_hook_t *h = haystack->data;
> + if(h && strcmp(h->name, needle) == 0) {
> + return haystack;
> + }
> + haystack = haystack->next;
> + }
> + return NULL;
> +}
OK.
> +static int _alpm_hook_run_hook(alpm_handle_t *handle, struct alpm_hook_t
> *hook)
> +{
> + alpm_list_t *i, *pkgs = _alpm_db_get_pkgcache(handle->db_local);
> + char *const argv[] = { hook->cmd, NULL };
> +
> + for(i = hook->depends; i; i = i->next) {
> + if(!alpm_find_satisfier(pkgs, i->data)) {
> + _alpm_log(handle, ALPM_LOG_ERROR, _("unable to run hook
> %s: %s\n"),
> + hook->name, _("could not satisfy
> dependencies"));
> + return -1;
> + }
> + }
> +
> + return _alpm_run_chroot(handle, hook->cmd, argv);
> +}
OK
> +
> +int _alpm_hook_run(alpm_handle_t *handle, enum _alpm_hook_when_t when)
> +{
> + alpm_list_t *i, *hooks = NULL;
> + const char *suffix = ".hook";
> + size_t suflen = strlen(suffix);
> + int ret = 0;
> +
> + for(i = alpm_list_last(handle->hookdirs); i; i = alpm_list_previous(i))
> {
> + int err;
> + char path[PATH_MAX];
> + size_t dirlen;
> + struct dirent entry, *result;
> + DIR *d;
> +
> + if(!(d = opendir(i->data))) {
> + if(errno == ENOENT) {
> + continue;
> + } else {
> + _alpm_log(handle, ALPM_LOG_ERROR, _("could not
> open directory: %s: %s\n"),
> + (char *)i->data,
> strerror(errno));
> + ret = -1;
> + continue;
> + }
> + }
> +
OK
> + strncpy(path, i->data, PATH_MAX);
> + dirlen = strlen(i->data);
> +
> + while((err = readdir_r(d, &entry, &result)) == 0 && result) {
> + struct _alpm_hook_cb_ctx ctx = { handle, NULL };
> + struct stat buf;
> + size_t name_len = strlen(entry.d_name);
> +
> + strncpy(path + dirlen, entry.d_name, PATH_MAX - dirlen);
> +
> + if(name_len < suflen
> + || strcmp(entry.d_name + name_len -
> suflen, suffix) != 0) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "skipping
> non-hook file %s\n", path);
> + continue;
> + }
> +
OK
> + if(find_hook(hooks, entry.d_name)) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "skipping
> overridden hook %s\n", path);
> + continue;
> + }
> +
OK
> + if(fstatat(dirfd(d), entry.d_name, &buf, 0) != 0) {
> + _alpm_log(handle, ALPM_LOG_ERROR,
> + _("could not stat file %s:
> %s\n"), path, strerror(errno));
> + ret = -1;
> + continue;
> + }
> +
> + if(S_ISDIR(buf.st_mode)) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "skipping
> directory %s\n", path);
> + continue;
> + }
> +
> + CALLOC(ctx.hook, sizeof(struct alpm_hook_t), 1,
> + ret = -1; closedir(d); goto cleanup);
> +
> + _alpm_log(handle, ALPM_LOG_DEBUG, "parsing hook file
> %s\n", path);
> + if(parse_ini(path, _alpm_hook_parse_cb, &ctx) != 0
> + || _alpm_hook_validate(handle,
> ctx.hook, path)) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "parsing hook
> file %s failed\n", path);
> + _alpm_hook_free(ctx.hook);
> + ret = -1;
> + continue;
> + }
> +
> + STRDUP(ctx.hook->name, entry.d_name, ret = -1;
> closedir(d); goto cleanup);
> + hooks = alpm_list_add(hooks, ctx.hook);
> + }
OK.
> +
> + if(err != 0) {
> + _alpm_log(handle, ALPM_LOG_ERROR, _("could not read
> directory: %s: %s\n"),
> + (char *) i->data, strerror(errno));
> + ret = -1;
> + }
> +
> + closedir(d);
> + }
> +
OK.
> + for(i = hooks; i; i = i->next) {
> + struct alpm_hook_t *hook = i->data;
> + if(hook && hook->when == when && _alpm_hook_triggered(handle,
> hook)) {
> + _alpm_log(handle, ALPM_LOG_DEBUG, "running hook %s\n",
> hook->name);
> + if(_alpm_hook_run_hook(handle, hook) != 0 &&
> hook->abort_on_fail) {
> + ret = -1;
> + }
> + }
> + }
> +
OK.
> +cleanup:
> + alpm_list_free_inner(hooks, (alpm_list_fn_free) _alpm_hook_free);
> + alpm_list_free(hooks);
> +
> + return ret;
> +}
> +
> +/* vim: set noet: */
> diff --git a/lib/libalpm/hook.h b/lib/libalpm/hook.h
> new file mode 100644
> index 0000000..4894a19
> --- /dev/null
> +++ b/lib/libalpm/hook.h
> @@ -0,0 +1,34 @@
> +/*
> + * hook.h
> + *
> + * Copyright (c) 2015 Pacman Development Team <[email protected]>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program. If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#ifndef _ALPM_HOOK_H
> +#define _ALPM_HOOK_H
> +
> +#include "alpm.h"
> +
> +enum _alpm_hook_when_t {
> + ALPM_HOOK_PRE_TRANSACTION = 1,
> + ALPM_HOOK_POST_TRANSACTION
> +};
> +
> +int _alpm_hook_run(alpm_handle_t *handle, enum _alpm_hook_when_t when);
> +
> +#endif /* _ALPM_HOOK_H */
> +
> +/* vim: set noet: */
OK
> diff --git a/lib/libalpm/trans.c b/lib/libalpm/trans.c
> index ed073c0..a6b1aef 100644
> --- a/lib/libalpm/trans.c
> +++ b/lib/libalpm/trans.c
> @@ -40,6 +40,7 @@
> #include "sync.h"
> #include "alpm.h"
> #include "deps.h"
> +#include "hook.h"
>
> /** \addtogroup alpm_trans Transaction Functions
> * @brief Functions to manipulate libalpm transactions
> @@ -189,6 +190,10 @@ int SYMEXPORT alpm_trans_commit(alpm_handle_t *handle,
> alpm_list_t **data)
> }
> }
>
> + if(_alpm_hook_run(handle, ALPM_HOOK_PRE_TRANSACTION) != 0) {
> + RET_ERR(handle, ALPM_ERR_TRANS_HOOK_FAILED, -1);
> + }
> +
> trans->state = STATE_COMMITING;
>
> alpm_logaction(handle, ALPM_CALLER_PREFIX, "transaction started\n");
> @@ -215,6 +220,7 @@ int SYMEXPORT alpm_trans_commit(alpm_handle_t *handle,
> alpm_list_t **data)
> alpm_logaction(handle, ALPM_CALLER_PREFIX, "transaction
> interrupted\n");
> } else {
> alpm_logaction(handle, ALPM_CALLER_PREFIX, "transaction
> completed\n");
> + _alpm_hook_run(handle, ALPM_HOOK_POST_TRANSACTION);
> }
>
> trans->state = STATE_COMMITED;
>
OK
