On 09/19/15 at 05:55pm, Allan McRae wrote:
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 <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; +}; +
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?
This is to allow masking. Despite what the documentation says, at the moment hooks can be disabled by a similarly named file without any trigger sections, not just a symlink to /dev/null. This may change before the final version.
+ 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 it's a SYNC hook then we have a match, if it's a REMOVE hook then we know the file won't actually be removed even if one of the subsequent loops would have matched.
+ } + } + } + + if(t->op == ALPM_HOOK_OP_REMOVE) { + for(i = handle->trans->add; i; i = i->next) {
trans->remove?
This is looking for files that are being removed because an upgraded package no longer contains them.
+ 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) {
This is looking for files removed by a package removal.
+ 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.
See above.
+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 <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: */
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