>From b3065d8c0a132c4c52707533014e7bc953d501ae Mon Sep 17 00:00:00 2001
Message-Id:
<b3065d8c0a132c4c52707533014e7bc953d501ae.1442270088.git.andrew.gregor...@gmail.com>
In-Reply-To: <cover.1442270088.git.andrew.gregor...@gmail.com>
References: <1436003967-4737-1-git-send-email-andrew.gregor...@gmail.com>
<cover.1442270088.git.andrew.gregor...@gmail.com>
From: Andrew Gregory <andrew.gregor...@gmail.com>
Date: Sat, 4 Jul 2015 03:35:59 -0400
Subject: [PATCH v2 4/7] wip add hooks
---
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
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/";
+ 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);
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. */
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;
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 */
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 <pacman-dev@archlinux.org>
+ *
+ * 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;
+};
+
+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;
+};
+
+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);
+ }
+}
+
+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);
+ }
+}
+
+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;
+}
+
+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;
+ }
+
+ 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;
+}
+
+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;
+}
+
+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;
+ }
+ 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) {
+ 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;
+}
+
+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);
+}
+
+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;
+}
+
+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;
+}
+
+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);
+}
+
+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;
+ }
+ }
+
+ 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;
+ }
+
+ if(find_hook(hooks, entry.d_name)) {
+ _alpm_log(handle, ALPM_LOG_DEBUG, "skipping
overridden hook %s\n", path);
+ continue;
+ }
+
+ 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);
+ }
+
+ 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);
+ }
+
+ 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;
+ }
+ }
+ }
+
+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 <pacman-dev@archlinux.org>
+ *
+ * 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: */
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;
--
2.5.2
