core: remove "wee-" prefix from source files in src/core and src/core/hook

1 files changed, 952 insertions, 0 deletions

diff --git a/src/core/core-hook.c b/src/core/core-hook.c
new file mode 100644
index 000000000..d89c2f988
--- /dev/null
+++ b/src/core/core-hook.c
@@ -0,0 +1,952 @@
+/*
+ * core-hook.c - WeeChat hooks management
+ *
+ * Copyright (C) 2003-2024 Sébastien Helleu <flashcode@flashtux.org>
+ *
+ * This file is part of WeeChat, the extensible chat client.
+ *
+ * WeeChat 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WeeChat 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 WeeChat.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <errno.h>
+
+#include "weechat.h"
+#include "core-debug.h"
+#include "core-hook.h"
+#include "core-hashtable.h"
+#include "core-infolist.h"
+#include "core-log.h"
+#include "core-signal.h"
+#include "core-string.h"
+#include "core-util.h"
+#include "../gui/gui-chat.h"
+#include "../plugins/plugin.h"
+
+
+char *hook_type_string[HOOK_NUM_TYPES] =
+{ "command", "command_run", "timer", "fd", "process", "connect", "line",
+  "print", "signal", "hsignal", "config", "completion", "modifier",
+  "info", "info_hashtable", "infolist", "hdata", "focus", "url" };
+struct t_hook *weechat_hooks[HOOK_NUM_TYPES];     /* list of hooks          */
+struct t_hook *last_weechat_hook[HOOK_NUM_TYPES]; /* last hook              */
+int hooks_count[HOOK_NUM_TYPES];                  /* number of hooks        */
+int hooks_count_total = 0;                        /* total number of hooks  */
+int hook_exec_recursion = 0;           /* 1 when a hook is executed         */
+int real_delete_pending = 0;           /* 1 if some hooks must be deleted   */
+
+int hook_socketpair_ok = 0;            /* 1 if socketpair() is OK           */
+
+/* hook callbacks */
+t_callback_hook *hook_callback_add[HOOK_NUM_TYPES] =
+{ NULL, NULL, NULL, &hook_fd_add_cb, NULL, NULL, NULL, NULL, NULL, NULL,
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+t_callback_hook *hook_callback_remove[HOOK_NUM_TYPES] =
+{ NULL, NULL, NULL, &hook_fd_remove_cb, NULL, NULL, NULL, NULL, NULL, NULL,
+  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
+t_callback_hook *hook_callback_free_data[HOOK_NUM_TYPES] =
+{
+    &hook_command_free_data,
+    &hook_command_run_free_data,
+    &hook_timer_free_data,
+    &hook_fd_free_data,
+    &hook_process_free_data,
+    &hook_connect_free_data,
+    &hook_line_free_data,
+    &hook_print_free_data,
+    &hook_signal_free_data,
+    &hook_hsignal_free_data,
+    &hook_config_free_data,
+    &hook_completion_free_data,
+    &hook_modifier_free_data,
+    &hook_info_free_data,
+    &hook_info_hashtable_free_data,
+    &hook_infolist_free_data,
+    &hook_hdata_free_data,
+    &hook_focus_free_data,
+    &hook_url_free_data,
+};
+t_callback_hook_get_desc *hook_callback_get_desc[HOOK_NUM_TYPES] =
+{
+    &hook_command_get_description,
+    &hook_command_run_get_description,
+    &hook_timer_get_description,
+    &hook_fd_get_description,
+    &hook_process_get_description,
+    &hook_connect_get_description,
+    &hook_line_get_description,
+    &hook_print_get_description,
+    &hook_signal_get_description,
+    &hook_hsignal_get_description,
+    &hook_config_get_description,
+    &hook_completion_get_description,
+    &hook_modifier_get_description,
+    &hook_info_get_description,
+    &hook_info_hashtable_get_description,
+    &hook_infolist_get_description,
+    &hook_hdata_get_description,
+    &hook_focus_get_description,
+    &hook_url_get_description,
+};
+t_callback_hook_infolist *hook_callback_add_to_infolist[HOOK_NUM_TYPES] =
+{
+    &hook_command_add_to_infolist,
+    &hook_command_run_add_to_infolist,
+    &hook_timer_add_to_infolist,
+    &hook_fd_add_to_infolist,
+    &hook_process_add_to_infolist,
+    &hook_connect_add_to_infolist,
+    &hook_line_add_to_infolist,
+    &hook_print_add_to_infolist,
+    &hook_signal_add_to_infolist,
+    &hook_hsignal_add_to_infolist,
+    &hook_config_add_to_infolist,
+    &hook_completion_add_to_infolist,
+    &hook_modifier_add_to_infolist,
+    &hook_info_add_to_infolist,
+    &hook_info_hashtable_add_to_infolist,
+    &hook_infolist_add_to_infolist,
+    &hook_hdata_add_to_infolist,
+    &hook_focus_add_to_infolist,
+    &hook_url_add_to_infolist,
+};
+t_callback_hook *hook_callback_print_log[HOOK_NUM_TYPES] =
+{
+    &hook_command_print_log,
+    &hook_command_run_print_log,
+    &hook_timer_print_log,
+    &hook_fd_print_log,
+    &hook_process_print_log,
+    &hook_connect_print_log,
+    &hook_line_print_log,
+    &hook_print_print_log,
+    &hook_signal_print_log,
+    &hook_hsignal_print_log,
+    &hook_config_print_log,
+    &hook_completion_print_log,
+    &hook_modifier_print_log,
+    &hook_info_print_log,
+    &hook_info_hashtable_print_log,
+    &hook_infolist_print_log,
+    &hook_hdata_print_log,
+    &hook_focus_print_log,
+    &hook_url_print_log,
+};
+
+
+/*
+ * Initializes hooks.
+ */
+
+void
+hook_init ()
+{
+    int type, sock[2], rc;
+
+    /* initialize list of hooks and callbacks */
+    for (type = 0; type < HOOK_NUM_TYPES; type++)
+    {
+        weechat_hooks[type] = NULL;
+        last_weechat_hook[type] = NULL;
+        hooks_count[type] = 0;
+    }
+    hooks_count_total = 0;
+    hook_last_system_time = time (NULL);
+
+    /*
+     * Set a flag to 0 if socketpair() function is not available.
+     *
+     * For the connect hook, when this is defined an array of sockets will
+     * be passed from the parent process to the child process instead of using
+     * SCM_RIGHTS to pass a socket back from the child process to parent
+     * process.
+     *
+     * This allows connections to work on Windows but it limits the number of
+     * IPs that can be attempted each time.
+     */
+    hook_socketpair_ok = 1;
+
+#if defined(__CYGWIN__) || defined(__APPLE__) || defined(__MACH__)
+    hook_socketpair_ok = 0;
+    (void) sock;
+    (void) rc;
+#else
+    /*
+     * Test if socketpair() function is working fine: this is NOT the case
+     * on Windows with Ubuntu bash
+     * (errno == 94: ESOCKTNOSUPPORT: socket type not supported)
+     */
+    rc = socketpair (AF_LOCAL, SOCK_DGRAM, 0, sock);
+    if (rc < 0)
+    {
+        /* Windows/Ubuntu */
+        hook_socketpair_ok = 0;
+    }
+    else
+    {
+        close (sock[0]);
+        close (sock[1]);
+    }
+#endif
+}
+
+/*
+ * Searches for a hook type.
+ *
+ * Returns index of type in enum t_hook_type, -1 if type is not found.
+ */
+
+int
+hook_search_type (const char *type)
+{
+    int i;
+
+    if (!type)
+        return -1;
+
+    for (i = 0; i < HOOK_NUM_TYPES; i++)
+    {
+        if (strcmp (hook_type_string[i], type) == 0)
+            return i;
+    }
+
+    /* type not found */
+    return -1;
+}
+
+/*
+ * Searches for position of hook in list (to keep hooks sorted).
+ *
+ * Hooks are sorted by priority, except commands which are sorted by command
+ * name, and then priority.
+ */
+
+struct t_hook *
+hook_find_pos (struct t_hook *hook)
+{
+    struct t_hook *ptr_hook;
+    int rc_cmp;
+
+    if (hook->type == HOOK_TYPE_COMMAND)
+    {
+        /* for command hook, sort on command name + priority */
+        for (ptr_hook = weechat_hooks[hook->type]; ptr_hook;
+             ptr_hook = ptr_hook->next_hook)
+        {
+            if (!ptr_hook->deleted)
+            {
+                rc_cmp = string_strcmp (HOOK_COMMAND(hook, command),
+                                        HOOK_COMMAND(ptr_hook, command));
+                if (rc_cmp < 0)
+                    return ptr_hook;
+                if ((rc_cmp == 0) && (hook->priority > ptr_hook->priority))
+                    return ptr_hook;
+            }
+        }
+    }
+    else
+    {
+        /* for other types, sort on priority */
+        for (ptr_hook = weechat_hooks[hook->type]; ptr_hook;
+             ptr_hook = ptr_hook->next_hook)
+        {
+            if (!ptr_hook->deleted && (hook->priority > ptr_hook->priority))
+                return ptr_hook;
+        }
+    }
+
+    /* position not found, add at the end */
+    return NULL;
+}
+
+/*
+ * Adds a hook to list.
+ */
+
+void
+hook_add_to_list (struct t_hook *new_hook)
+{
+    struct t_hook *pos_hook;
+
+    if (weechat_hooks[new_hook->type])
+    {
+        pos_hook = hook_find_pos (new_hook);
+        if (pos_hook)
+        {
+            /* add hook before "pos_hook" */
+            new_hook->prev_hook = pos_hook->prev_hook;
+            new_hook->next_hook = pos_hook;
+            if (pos_hook->prev_hook)
+                (pos_hook->prev_hook)->next_hook = new_hook;
+            else
+                weechat_hooks[new_hook->type] = new_hook;
+            pos_hook->prev_hook = new_hook;
+        }
+        else
+        {
+            /* add hook to end of list */
+            new_hook->prev_hook = last_weechat_hook[new_hook->type];
+            new_hook->next_hook = NULL;
+            last_weechat_hook[new_hook->type]->next_hook = new_hook;
+            last_weechat_hook[new_hook->type] = new_hook;
+        }
+    }
+    else
+    {
+        new_hook->prev_hook = NULL;
+        new_hook->next_hook = NULL;
+        weechat_hooks[new_hook->type] = new_hook;
+        last_weechat_hook[new_hook->type] = new_hook;
+    }
+
+    hooks_count[new_hook->type]++;
+    hooks_count_total++;
+
+    if (hook_callback_add[new_hook->type])
+        (hook_callback_add[new_hook->type]) (new_hook);
+}
+
+/*
+ * Removes a hook from list.
+ */
+
+void
+hook_remove_from_list (struct t_hook *hook)
+{
+    struct t_hook *new_hooks;
+    int type;
+
+    type = hook->type;
+
+    if (last_weechat_hook[hook->type] == hook)
+        last_weechat_hook[hook->type] = hook->prev_hook;
+    if (hook->prev_hook)
+    {
+        (hook->prev_hook)->next_hook = hook->next_hook;
+        new_hooks = weechat_hooks[hook->type];
+    }
+    else
+        new_hooks = hook->next_hook;
+
+    if (hook->next_hook)
+        (hook->next_hook)->prev_hook = hook->prev_hook;
+
+    weechat_hooks[type] = new_hooks;
+
+    hooks_count[type]--;
+    hooks_count_total--;
+
+    if (hook_callback_remove[hook->type])
+        (hook_callback_remove[hook->type]) (hook);
+
+    free (hook);
+}
+
+/*
+ * Removes hooks marked as "deleted" from list.
+ */
+
+void
+hook_remove_deleted ()
+{
+    int type;
+    struct t_hook *ptr_hook, *next_hook;
+
+    if (real_delete_pending)
+    {
+        for (type = 0; type < HOOK_NUM_TYPES; type++)
+        {
+            ptr_hook = weechat_hooks[type];
+            while (ptr_hook)
+            {
+                next_hook = ptr_hook->next_hook;
+
+                if (ptr_hook->deleted)
+                    hook_remove_from_list (ptr_hook);
+
+                ptr_hook = next_hook;
+            }
+        }
+        real_delete_pending = 0;
+    }
+}
+
+/*
+ * Initializes a new hook with default values.
+ */
+
+void
+hook_init_data (struct t_hook *hook, struct t_weechat_plugin *plugin,
+                int type, int priority,
+                const void *callback_pointer, void *callback_data)
+{
+    hook->plugin = plugin;
+    hook->subplugin = NULL;
+    hook->type = type;
+    hook->deleted = 0;
+    hook->running = 0;
+    hook->priority = priority;
+    hook->callback_pointer = callback_pointer;
+    hook->callback_data = callback_data;
+    hook->hook_data = NULL;
+
+    if (weechat_debug_core >= 2)
+    {
+        gui_chat_printf (NULL,
+                         "debug: adding hook: type=%d (%s), plugin=\"%s\", "
+                         "priority=%d",
+                         hook->type,
+                         hook_type_string[hook->type],
+                         plugin_get_name (hook->plugin),
+                         hook->priority);
+    }
+}
+
+/*
+ * Checks if a hook pointer is valid.
+ *
+ * Returns:
+ *   1: hook exists
+ *   0: hook does not exist
+ */
+
+int
+hook_valid (struct t_hook *hook)
+{
+    int type;
+    struct t_hook *ptr_hook;
+
+    if (!hook)
+        return 0;
+
+    for (type = 0; type < HOOK_NUM_TYPES; type++)
+    {
+        for (ptr_hook = weechat_hooks[type]; ptr_hook;
+             ptr_hook = ptr_hook->next_hook)
+        {
+            if (!ptr_hook->deleted && (ptr_hook == hook))
+                return 1;
+        }
+    }
+
+    /* hook not found */
+    return 0;
+}
+
+/*
+ * Starts a hook exec.
+ */
+
+void
+hook_exec_start ()
+{
+    hook_exec_recursion++;
+}
+
+/*
+ * Ends a hook_exec.
+ */
+
+void
+hook_exec_end ()
+{
+    if (hook_exec_recursion > 0)
+        hook_exec_recursion--;
+
+    if (hook_exec_recursion == 0)
+        hook_remove_deleted ();
+}
+
+/*
+ * Starts execution of a hook callback.
+ */
+
+void
+hook_callback_start (struct t_hook *hook, struct t_hook_exec_cb *hook_exec_cb)
+{
+    if (hook->type == HOOK_TYPE_COMMAND)
+        hook->running++;
+    else
+        hook->running = 1;
+
+    if (debug_long_callbacks > 0)
+    {
+        gettimeofday (&hook_exec_cb->start_time, NULL);
+    }
+    else
+    {
+        hook_exec_cb->start_time.tv_sec = 0;
+        hook_exec_cb->start_time.tv_usec = 0;
+    }
+}
+
+/*
+ * Ends execution of a hook callback.
+ */
+
+void
+hook_callback_end (struct t_hook *hook, struct t_hook_exec_cb *hook_exec_cb)
+{
+    struct timeval end_time;
+    long long time_diff;
+    char *str_diff;
+
+    if (hook->type == HOOK_TYPE_COMMAND)
+        hook->running--;
+    else
+        hook->running = 0;
+
+    if ((debug_long_callbacks > 0)
+        && (hook_exec_cb->start_time.tv_sec > 0))
+    {
+        gettimeofday (&end_time, NULL);
+        time_diff = util_timeval_diff (&hook_exec_cb->start_time, &end_time);
+        if (time_diff >= debug_long_callbacks)
+        {
+            str_diff = util_get_microseconds_string (time_diff);
+            log_printf (
+                _("debug: long callback: hook %s (%s), plugin: %s, "
+                  "subplugin: %s, time elapsed: %s"),
+                hook_type_string[hook->type],
+                hook_get_description (hook),
+                plugin_get_name (hook->plugin),
+                (hook->subplugin) ? hook->subplugin : "-",
+                str_diff);
+            if (str_diff)
+                free (str_diff);
+        }
+    }
+}
+
+/*
+ * Returns description of hook.
+ *
+ * Note: result must be freed after use.
+ */
+
+char *
+hook_get_description (struct t_hook *hook)
+{
+    return (hook_callback_get_desc[hook->type]) (hook);
+}
+
+/*
+ * Sets a hook property (string).
+ */
+
+void
+hook_set (struct t_hook *hook, const char *property, const char *value)
+{
+    ssize_t num_written;
+    char *error;
+    long number;
+    int rc;
+
+    /* invalid hook? */
+    if (!hook_valid (hook))
+        return;
+
+    if (!property)
+        return;
+
+    if (strcmp (property, "subplugin") == 0)
+    {
+        if (hook->subplugin)
+            free (hook->subplugin);
+        hook->subplugin = strdup (value);
+    }
+    else if (strcmp (property, "stdin") == 0)
+    {
+        if (!hook->deleted
+            && (hook->type == HOOK_TYPE_PROCESS)
+            && (HOOK_PROCESS(hook, child_write[HOOK_PROCESS_STDIN]) >= 0))
+        {
+            /* send data on child's stdin */
+            num_written = write (HOOK_PROCESS(hook, child_write[HOOK_PROCESS_STDIN]),
+                                 value, strlen (value));
+            (void) num_written;
+        }
+    }
+    else if (strcmp (property, "stdin_close") == 0)
+    {
+        if (!hook->deleted
+            && (hook->type == HOOK_TYPE_PROCESS)
+            && (HOOK_PROCESS(hook, child_write[HOOK_PROCESS_STDIN]) >= 0))
+        {
+            /* close stdin pipe */
+            close (HOOK_PROCESS(hook, child_write[HOOK_PROCESS_STDIN]));
+            HOOK_PROCESS(hook, child_write[HOOK_PROCESS_STDIN]) = -1;
+        }
+    }
+    else if (strcmp (property, "signal") == 0)
+    {
+        if (!hook->deleted
+            && (hook->type == HOOK_TYPE_PROCESS)
+            && (HOOK_PROCESS(hook, child_pid) > 0))
+        {
+            error = NULL;
+            number = strtol (value, &error, 10);
+            if (!error || error[0])
+            {
+                /* not a number? look for signal by name */
+                number = signal_search_name (value);
+            }
+            if (number >= 0)
+            {
+                rc = kill (HOOK_PROCESS(hook, child_pid), (int)number);
+                if (rc < 0)
+                {
+                    gui_chat_printf (NULL,
+                                     _("%sError sending signal %d to pid %d: %s"),
+                                     gui_chat_prefix[GUI_CHAT_PREFIX_ERROR],
+                                     (int)number,
+                                     HOOK_PROCESS(hook, child_pid),
+                                     strerror (errno));
+                }
+            }
+        }
+    }
+}
+
+/*
+ * Callback used to clean a process (forked processes) by acknowledging its end.
+ */
+
+int
+hook_timer_clean_process_cb (const void *pointer, void *data,
+                             int remaining_calls)
+{
+    /* make C compiler happy */
+    (void) pointer;
+    (void) data;
+    (void) remaining_calls;
+
+    waitpid (*((pid_t *)data), NULL, WNOHANG);
+
+    return WEECHAT_RC_OK;
+}
+
+/*
+ * Schedule a cleanup timer to clean children (forked processes).
+ */
+
+void
+hook_schedule_clean_process (pid_t pid)
+{
+    pid_t *temp_pid;
+
+    /* temp_pid will be freed when the timer is removed */
+    temp_pid = malloc (sizeof (*temp_pid));
+    if (temp_pid)
+    {
+        *temp_pid = pid;
+        hook_timer (NULL, 100, 0, 1,
+                    &hook_timer_clean_process_cb, NULL, temp_pid);
+    }
+}
+
+/*
+ * Unhooks something.
+ */
+
+void
+unhook (struct t_hook *hook)
+{
+    /* invalid hook? */
+    if (!hook_valid (hook))
+        return;
+
+    /* hook already deleted? */
+    if (hook->deleted)
+        return;
+
+    if (weechat_debug_core >= 2)
+    {
+        gui_chat_printf (NULL,
+                         "debug: removing hook: type=%d (%s), plugin=\"%s\"",
+                         hook->type,
+                         hook_type_string[hook->type],
+                         plugin_get_name (hook->plugin));
+    }
+
+    /* free data specific to the hook */
+    (hook_callback_free_data[hook->type]) (hook);
+
+    /* free data common to all hooks */
+    if (hook->subplugin)
+    {
+        free (hook->subplugin);
+        hook->subplugin = NULL;
+    }
+    if (hook->callback_data)
+    {
+        free (hook->callback_data);
+        hook->callback_data = NULL;
+    }
+
+    /* remove hook from list (if there's no hook exec pending) */
+    if (hook_exec_recursion == 0)
+    {
+        hook_remove_from_list (hook);
+    }
+    else
+    {
+        /* there is one or more hook exec, then delete later */
+        hook->deleted = 1;
+        real_delete_pending = 1;
+    }
+}
+
+/*
+ * Unhooks everything for a plugin/subplugin.
+ */
+
+void
+unhook_all_plugin (struct t_weechat_plugin *plugin, const char *subplugin)
+{
+    int type;
+    struct t_hook *ptr_hook, *next_hook;
+
+    for (type = 0; type < HOOK_NUM_TYPES; type++)
+    {
+        ptr_hook = weechat_hooks[type];
+        while (ptr_hook)
+        {
+            next_hook = ptr_hook->next_hook;
+            if (ptr_hook->plugin == plugin)
+            {
+                if (!subplugin
+                    || (ptr_hook->subplugin &&
+                        strcmp (ptr_hook->subplugin, subplugin) == 0))
+                {
+                    unhook (ptr_hook);
+                }
+            }
+            ptr_hook = next_hook;
+        }
+    }
+}
+
+/*
+ * Unhooks everything.
+ */
+
+void
+unhook_all ()
+{
+    int type;
+    struct t_hook *ptr_hook, *next_hook;
+
+    for (type = 0; type < HOOK_NUM_TYPES; type++)
+    {
+        ptr_hook = weechat_hooks[type];
+        while (ptr_hook)
+        {
+            next_hook = ptr_hook->next_hook;
+            unhook (ptr_hook);
+            ptr_hook = next_hook;
+        }
+    }
+}
+
+/*
+ * Adds a hook in an infolist.
+ *
+ * Returns:
+ *   1: OK
+ *   0: error
+ */
+
+int
+hook_add_to_infolist_pointer (struct t_infolist *infolist, struct t_hook *hook)
+{
+    struct t_infolist_item *ptr_item;
+
+    ptr_item = infolist_new_item (infolist);
+    if (!ptr_item)
+        return 0;
+
+    if (!infolist_new_var_pointer (ptr_item, "pointer", hook))
+        return 0;
+    if (!infolist_new_var_pointer (ptr_item, "plugin", hook->plugin))
+        return 0;
+    if (!infolist_new_var_string (ptr_item, "plugin_name",
+                                  (hook->plugin) ?
+                                  hook->plugin->name : NULL))
+        return 0;
+    if (!infolist_new_var_string (ptr_item, "subplugin", hook->subplugin))
+        return 0;
+    if (!infolist_new_var_string (ptr_item, "type", hook_type_string[hook->type]))
+        return 0;
+    if (!infolist_new_var_integer (ptr_item, "deleted", hook->deleted))
+        return 0;
+    if (!infolist_new_var_integer (ptr_item, "running", hook->running))
+        return 0;
+    if (!infolist_new_var_integer (ptr_item, "priority", hook->priority))
+        return 0;
+    if (!infolist_new_var_pointer (ptr_item, "callback_pointer", (void *)hook->callback_pointer))
+        return 0;
+    if (!infolist_new_var_pointer (ptr_item, "callback_data", (void *)hook->callback_data))
+        return 0;
+
+    /* hook deleted? return only hook info above */
+    if (hook->deleted)
+        return 1;
+
+    /* hook not deleted: add extra hook info */
+    if (!(hook_callback_add_to_infolist[hook->type]) (ptr_item, hook))
+        return 0;
+
+    return 1;
+}
+
+/*
+ * Adds hooks of a type in an infolist.
+ *
+ * Returns:
+ *   1: OK
+ *   0: error
+ */
+
+int
+hook_add_to_infolist_type (struct t_infolist *infolist, int type,
+                           const char *arguments)
+{
+    struct t_hook *ptr_hook;
+    int match;
+
+    for (ptr_hook = weechat_hooks[type]; ptr_hook;
+         ptr_hook = ptr_hook->next_hook)
+    {
+        match = 1;
+        if (arguments && !ptr_hook->deleted)
+        {
+            switch (ptr_hook->type)
+            {
+                case HOOK_TYPE_COMMAND:
+                    match = string_match (HOOK_COMMAND(ptr_hook, command), arguments, 1);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        if (!match)
+            continue;
+
+        hook_add_to_infolist_pointer (infolist, ptr_hook);
+    }
+
+    return 1;
+}
+
+/*
+ * Adds hooks in an infolist.
+ *
+ * Argument "arguments" can be a hook type with optional comma + name after.
+ *
+ * Returns:
+ *   1: OK
+ *   0: error
+ */
+
+int
+hook_add_to_infolist (struct t_infolist *infolist, struct t_hook *pointer,
+                      const char *arguments)
+{
+    const char *pos_arguments;
+    char *type;
+    int i, type_int;
+
+    if (!infolist)
+        return 0;
+
+    if (pointer)
+        return hook_add_to_infolist_pointer (infolist, pointer);
+
+    type = NULL;
+    pos_arguments = NULL;
+
+    if (arguments && arguments[0])
+    {
+        pos_arguments = strchr (arguments, ',');
+        if (pos_arguments)
+        {
+            type = string_strndup (arguments, pos_arguments - arguments);
+            pos_arguments++;
+        }
+        else
+            type = strdup (arguments);
+    }
+
+    type_int = (type) ? hook_search_type (type) : -1;
+
+    for (i = 0; i < HOOK_NUM_TYPES; i++)
+    {
+        if ((type_int < 0) || (type_int == i))
+            hook_add_to_infolist_type (infolist, i, pos_arguments);
+    }
+
+    if (type)
+        free (type);
+
+    return 1;
+}
+
+/*
+ * Prints hooks in WeeChat log file (usually for crash dump).
+ */
+
+void
+hook_print_log ()
+{
+    int type;
+    struct t_hook *ptr_hook;
+
+    for (type = 0; type < HOOK_NUM_TYPES; type++)
+    {
+        for (ptr_hook = weechat_hooks[type]; ptr_hook;
+             ptr_hook = ptr_hook->next_hook)
+        {
+            log_printf ("");
+            log_printf ("[hook (addr:0x%lx)]", ptr_hook);
+            log_printf ("  plugin. . . . . . . . . : 0x%lx ('%s')",
+                        ptr_hook->plugin, plugin_get_name (ptr_hook->plugin));
+            log_printf ("  subplugin . . . . . . . : '%s'",  ptr_hook->subplugin);
+            log_printf ("  type. . . . . . . . . . : %d (%s)",
+                        ptr_hook->type, hook_type_string[ptr_hook->type]);
+            log_printf ("  deleted . . . . . . . . : %d",    ptr_hook->deleted);
+            log_printf ("  running . . . . . . . . : %d",    ptr_hook->running);
+            log_printf ("  priority. . . . . . . . : %d",    ptr_hook->priority);
+            log_printf ("  callback_pointer. . . . : 0x%lx", ptr_hook->callback_pointer);
+            log_printf ("  callback_data . . . . . : 0x%lx", ptr_hook->callback_data);
+            if (ptr_hook->deleted)
+                continue;
+
+            (hook_callback_print_log[ptr_hook->type]) (ptr_hook);
+
+            log_printf ("  prev_hook . . . . . . . : 0x%lx", ptr_hook->prev_hook);
+            log_printf ("  next_hook . . . . . . . : 0x%lx", ptr_hook->next_hook);
+        }
+    }
+}