/* $OpenBSD: hooks.c,v 1.17 2026/10/15 08:21:11 nicm Exp $ */

/*

 * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>

 * Copyright (c) 2012 George Nachman <tmux@georgester.com>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER

 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/types.h>

#include <stdlib.h>

#include <string.h>

#include "tmux.h"

/* Hook monitor state owned by an option entry. */

struct hooks_monitor {

  struct options    *oo;

  struct monitor_set  *set;

  struct events_sink  *sink;

  struct cmd_find_state  fs;

  enum monitor_type  type;

  int      id;

  char      *format;

};

/* Hook command data built from an event payload. */

struct hooks_data {

  const char    *name;

  struct cmd_find_state  fs;

  struct format_tree  *formats;

  struct options    *oo;

  struct client   *client;

  int      expand;

};

/* Hook event sink registered for a notify event name. */

struct hooks_event {

  char      *name;

  struct events_sink  *sink;

  TAILQ_ENTRY(hooks_event) entry;

};

TAILQ_HEAD(hooks_events, hooks_event);

static struct hooks_events hooks_events = TAILQ_HEAD_INITIALIZER(hooks_events);

/* Insert one hook command list. */

static struct cmdq_item *

hooks_insert_one(struct cmdq_item *item, struct hooks_data *hd,

    struct cmd_list *cmdlist, struct cmdq_state *state)

{

  struct cmdq_item  *new_item;

  char      *s;

  if (cmdlist == NULL)

    return (item);

  if (log_get_level() != 0) {

    s = cmd_list_print(cmdlist, 0);

    log_debug("%s: hook %s is: %s", __func__, hd->name, s);

    free(s);

  }

  new_item = cmdq_get_command(cmdlist, state);

  if (item != NULL)

    return (cmdq_insert_after(item, new_item));

  return (cmdq_append(NULL, new_item));

}

/* Parse a hook command. */

static struct cmd_parse_result *

hooks_parse(struct hooks_data *hd, struct cmd_find_state *fs,

    const char *value)

{

  struct cmd_parse_result *pr;

  struct format_tree  *ft;

  char      *expanded;

  if (!hd->expand)

    return (cmd_parse_from_string(value, NULL));

  ft = format_create_defaults(NULL, hd->client, fs->s, fs->wl, fs->wp);

  if (hd->formats != NULL)

    format_merge(ft, hd->formats);

  expanded = format_expand(ft, value);

  format_free(ft);

  pr = cmd_parse_from_string(expanded, NULL);

  free(expanded);

  return (pr);

}

/* Insert commands for a hook. */

static void

hooks_insert(struct cmdq_item *item, struct hooks_data *hd)

{

  struct cmd_find_state    fs;

  struct options      *oo;

  struct cmdq_state   *state;

  struct options_entry    *o;

  struct options_array_item *a;

  struct cmd_list     *cmdlist;

  const char      *value;

  struct cmd_parse_result   *pr;

  log_debug("%s: inserting hook %s", __func__, hd->name);

  cmd_find_clear_state(&fs, 0);

  if (cmd_find_empty_state(&hd->fs) || !cmd_find_valid_state(&hd->fs))

    cmd_find_from_nothing(&fs, 0);

  else

    cmd_find_copy_state(&fs, &hd->fs);

  if (hd->oo != NULL) {

    oo = hd->oo;

    o = options_get_only(oo, hd->name);

  } else {

    if (fs.s == NULL)

      oo = global_s_options;

    else

      oo = fs.s->options;

    o = options_get(oo, hd->name);

    if (o == NULL && fs.wp != NULL) {

      oo = fs.wp->options;

      o = options_get(oo, hd->name);

    }

    if (o == NULL && fs.wl != NULL) {

      oo = fs.wl->window->options;

      o = options_get(oo, hd->name);

    }

  }

  if (o == NULL) {

    log_debug("%s: hook %s not found", __func__, hd->name);

    return;

  }

  options_hook_fired(o);

  if (item == NULL)

    state = cmdq_new_state(&fs, NULL, CMDQ_STATE_NOHOOKS);

  else {

    state = cmdq_new_state(&fs, cmdq_get_event(item),

        CMDQ_STATE_NOHOOKS);

  }

  cmdq_add_formats(state, hd->formats);

  if (*hd->name == '@') {

    value = options_get_string(oo, hd->name);

    pr = hooks_parse(hd, &fs, value);

    switch (pr->status) {

    case CMD_PARSE_ERROR:

      log_debug("%s: can't parse hook %s: %s", __func__,

          hd->name, pr->error);

      free(pr->error);

      break;

    case CMD_PARSE_SUCCESS:

      hooks_insert_one(item, hd, pr->cmdlist, state);

      cmd_list_free(pr->cmdlist);

      break;

    }

  } else {

    a = options_array_first(o);

    while (a != NULL) {

      if (hd->expand) {

        value = options_array_item_value(a)->string;

        pr = hooks_parse(hd, &fs, value);

        switch (pr->status) {

        case CMD_PARSE_ERROR:

          if (pr->error != NULL) {

            cmdq_error(item, "%s",

                pr->error);

          }

          free(pr->error);

          break;

        case CMD_PARSE_SUCCESS:

          item = hooks_insert_one(item, hd,

              pr->cmdlist, state);

          cmd_list_free(pr->cmdlist);

          break;

        }

      } else {

        cmdlist = options_array_item_value(a)->cmdlist;

        item = hooks_insert_one(item, hd, cmdlist,

            state);

      }

      a = options_array_next(a);

    }

  }

  cmdq_free_state(state);

}

/* Insert commands for a hook event. */

static void

hooks_insert_event(struct cmdq_item *item, const char *name,

    struct event_payload *ep, struct options *oo, int expand)

{

  struct hooks_data  hd;

  struct format_tree  *ft;

  struct client   *c;

  if (item != NULL && (cmdq_get_flags(item) & CMDQ_STATE_NOHOOKS))

    return;

  c = event_payload_get_client(ep, "client");

  ft = format_create(c, item, FORMAT_NONE, FORMAT_NOJOBS);

  event_payload_add_formats(ep, ft, "hook_");

  format_add(ft, "hook", "%s", name);

  format_log_debug(ft, __func__);

  memset(&hd, 0, sizeof hd);

  hd.name = name;

  cmd_find_clear_state(&hd.fs, 0);

  event_payload_get_target(ep, &hd.fs);

  hd.formats = ft;

  hd.oo = oo;

  hd.client = c;

  hd.expand = expand;

  hooks_insert(item, &hd);

  format_free(ft);

}

/* Handle an event for hooks. */

static void

hooks_event_cb(const char *name, struct event_payload *ep,

    __unused void *sink_data)

{

  struct cmdq_item  *item;

  if (event_payload_get_pointer(ep, "_hooks_monitor") != NULL)

    return;

  item = event_payload_get_pointer(ep, "_cmdq_item");

  if (item != NULL) {

    hooks_insert_event(item, name, ep, NULL, 0);

    return;

  }

  item = cmdq_running(NULL);

  if (item == NULL || (~cmdq_get_flags(item) & CMDQ_STATE_NOHOOKS))

    hooks_insert_event(NULL, name, ep, NULL, 0);

}

/* Add a hook event sink. */

void

hooks_add_event(const char *name)

{

  struct hooks_event  *he;

  TAILQ_FOREACH(he, &hooks_events, entry) {

    if (strcmp(he->name, name) == 0)

      return;

  }

  he = xcalloc(1, sizeof *he);

  he->name = xstrdup(name);

  he->sink = events_add_sink(name, hooks_event_cb, NULL);

  TAILQ_INSERT_TAIL(&hooks_events, he, entry);

}

/* Return if a hook event sink exists. */

int

hooks_is_event(const char *name)

{

  struct hooks_event  *he;

  TAILQ_FOREACH(he, &hooks_events, entry) {

    if (strcmp(he->name, name) == 0)

      return (1);

  }

  return (0);

}

/* Return if an event name can be fired through the hooks path. */

int

hooks_valid_event_name(const char *name)

{

  const struct options_table_entry  *oe;

  if (*name == '@')

    return (1);

  oe = options_search(name);

  return (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_HOOK));

}

/* Add hook event sinks for all built-in hooks. */

void

hooks_build_events(void)

{

  const struct options_table_entry  *oe;

  for (oe = options_table; oe->name != NULL; oe++) {

    if (oe->flags & OPTIONS_TABLE_IS_HOOK)

      hooks_add_event(oe->name);

  }

}

/* Run a hook immediately. */

void

hooks_run(struct cmdq_item *item, const char *name)

{

  struct cmd_find_state *target = cmdq_get_target(item);

  struct hooks_data  hd = { 0 };

  hd.name = name;

  cmd_find_copy_state(&hd.fs, target);

  hd.client = cmdq_get_client(item);

  hd.formats = format_create(NULL, NULL, 0, FORMAT_NOJOBS);

  format_add(hd.formats, "hook", "%s", name);

  format_log_debug(hd.formats, __func__);

  hooks_insert(item, &hd);

  format_free(hd.formats);

}

/* Free a hook monitor. */

void

hooks_monitor_free(void *data)

{

  struct hooks_monitor  *hm = data;

  events_remove_sink(hm->sink);

  monitor_destroy(hm->set);

  free(hm->format);

  free(hm);

}

/* Remove a hook monitor. */

void

hooks_monitor_remove(struct options *oo, const char *name)

{

  struct options_entry  *o;

  struct hooks_monitor  *hm;

  o = options_get_only(oo, name);

  if (o == NULL)

    return;

  hm = options_get_monitor_data(o);

  if (hm != NULL) {

    options_set_monitor_data(o, NULL);

    hooks_monitor_free(hm);

  }

}

/* Handle a hook monitor event. */

static void

hooks_monitor_hook_cb(const char *name, struct event_payload *ep,

    void *sink_data)

{

  struct hooks_monitor  *hm = sink_data;

  if (event_payload_get_pointer(ep, "_hooks_monitor") == hm)

    hooks_insert_event(cmdq_running(NULL), name, ep, hm->oo, 1);

}

/* Fire a hook monitor event. */

static void

hooks_monitor_cb(struct monitor_change *change, void *data)

{

  struct hooks_monitor  *hm = data;

  struct event_payload  *ep;

  struct winlink    *wl = change->wl;

  struct window_pane  *wp = change->wp;

  struct cmd_find_state  fs;

  ep = event_payload_create();

  event_payload_set_pointer(ep, "_hooks_monitor", data, NULL, NULL);

  cmd_find_clear_state(&fs, 0);

  if (wl != NULL && wp != NULL && wp->window == wl->window)

    cmd_find_from_winlink_pane(&fs, wl, wp, 0);

  else if (wl != NULL)

    cmd_find_from_winlink(&fs, wl, 0);

  else if (wp != NULL)

    cmd_find_from_pane(&fs, wp, 0);

  else if (change->s != NULL)

    cmd_find_from_session(&fs, change->s, 0);

  else

    cmd_find_copy_state(&fs, &hm->fs);

  event_payload_set_target(ep, &fs);

  if (change->value != NULL)

    event_payload_set_string(ep, "value", "%s", change->value);

  else

    event_payload_set_string(ep, "value", "%s", "");

  if (change->last != NULL)

    event_payload_set_string(ep, "last", "%s", change->last);

  else

    event_payload_set_string(ep, "last", "%s", "");

  if (change->c != NULL)

    event_payload_set_client(ep, "client", change->c);

  if (change->s != NULL)

    event_payload_set_session(ep, "session", change->s);

  if (wl != NULL) {

    if (change->s == NULL)

      event_payload_set_session(ep, "session", wl->session);

    event_payload_set_window(ep, "window", wl->window);

    event_payload_set_int(ep, "window_index", wl->idx);

  }

  if (wp != NULL) {

    event_payload_set_pane(ep, "pane", wp);

    if (wl == NULL)

      event_payload_set_window(ep, "window", wp->window);

  }

  events_fire(change->name, ep);

}

/* Add a hook monitor. */

void

hooks_monitor_add(__unused struct cmdq_item *item, struct options *oo,

    const char *name, enum monitor_type type, int id, const char *format,

    int flags, struct cmd_find_state *fs, struct session *s)

{

  struct options_entry  *o;

  struct hooks_monitor  *hm;

  hooks_monitor_remove(oo, name);

  o = options_get_only(oo, name);

  if (o == NULL)

    o = options_set_string(oo, name, 0, "%s", "");

  hm = xcalloc(1, sizeof *hm);

  hm->oo = oo;

  cmd_find_copy_state(&hm->fs, fs);

  hm->type = type;

  hm->id = id;

  hm->format = xstrdup(format);

  hm->set = monitor_create_session(s, hooks_monitor_cb, hm);

  hm->sink = events_add_sink(name, hooks_monitor_hook_cb, hm);

  options_set_monitor_data(o, hm);

  monitor_add(hm->set, name, type, id, format, flags);

}

/* Convert a hook monitor to its value. */

char *

hooks_monitor_to_string(struct options_entry *o)

{

  struct hooks_monitor  *hm = options_get_monitor_data(o);

  const char    *name = options_name(o);

  char      *s;

  if (hm == NULL)

    return (NULL);

  switch (hm->type) {

  case MONITOR_SESSION:

    xasprintf(&s, "%s::%s", name, hm->format);

    break;

  case MONITOR_PANE:

    xasprintf(&s, "%s:%%%d:%s", name, hm->id, hm->format);

    break;

  case MONITOR_ALL_PANES:

    xasprintf(&s, "%s:%%*:%s", name, hm->format);

    break;

  case MONITOR_WINDOW:

    xasprintf(&s, "%s:@%d:%s", name, hm->id, hm->format);

    break;

  case MONITOR_ALL_WINDOWS:

    xasprintf(&s, "%s:@*:%s", name, hm->format);

    break;

  }

  return (s);

}

/* Get the parts of a hook monitor. */

int

hooks_monitor_get(struct options_entry *o, enum monitor_type *type, int *id,

    const char **format)

{

  struct hooks_monitor  *hm = options_get_monitor_data(o);

  if (hm == NULL)

    return (0);

  *type = hm->type;

  *id = hm->id;

  *format = hm->format;

  return (1);

}

/* Get hook monitor firing count. */

u_int

hooks_monitor_get_fire_count(struct options_entry *o)

{

  struct hooks_monitor  *hm = options_get_monitor_data(o);

  if (hm == NULL)

    return (0);

  return (monitor_get_fire_count(hm->set, options_name(o)));

}

/* Get hook monitor firing time. */

time_t

hooks_monitor_get_fire_time(struct options_entry *o)

{

  struct hooks_monitor  *hm = options_get_monitor_data(o);

  if (hm == NULL)

    return (0);

  return (monitor_get_fire_time(hm->set, options_name(o)));

}