/src/tmux/arguments.c

Source
/* $OpenBSD: arguments.c,v 1.66 2026/06/26 09:54:56 nicm Exp $ */

/*
 * Copyright (c) 2010 Nicholas Marriott <nicholas.marriott@gmail.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 <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "tmux.h"

/*
 * Manipulate command arguments.
 */

/* List of argument values. */
TAILQ_HEAD(args_values, args_value);

/* Single arguments flag. */
struct args_entry {
  u_char       flag;
  struct args_values   values;
  u_int      count;

  int      flags;
#define ARGS_ENTRY_OPTIONAL_VALUE 0x1

  RB_ENTRY(args_entry)   entry;
};

/* Parsed argument flags and values. */
struct args {
  struct args_tree   tree;
  u_int      count;
  struct args_value *values;
};

/* Prepared command state. */
struct args_command_state {
  struct cmd_list   *cmdlist;
  char      *cmd;
  struct cmd_parse_input   pi;
};

static struct args_entry  *args_find(struct args *, u_char);

static int  args_cmp(struct args_entry *, struct args_entry *);
RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp);

/* Arguments tree comparison function. */
static int
args_cmp(struct args_entry *a1, struct args_entry *a2)
{
  return (a1->flag - a2->flag);
}

/* Find a flag in the arguments tree. */
static struct args_entry *
args_find(struct args *args, u_char flag)
{
  struct args_entry entry;

  entry.flag = flag;
  return (RB_FIND(args_tree, &args->tree, &entry));
}

/* Copy value. */
static void
args_copy_value(struct args_value *to, struct args_value *from)
{
  to->type = from->type;
  switch (from->type) {
  case ARGS_NONE:
    break;
  case ARGS_COMMANDS:
    to->cmdlist = from->cmdlist;
    to->cmdlist->references++;
    break;
  case ARGS_STRING:
    to->string = xstrdup(from->string);
    break;
  }
}

/* Type to string. */
static const char *
args_type_to_string (enum args_type type)
{
  switch (type)
  {
  case ARGS_NONE:
    return "NONE";
  case ARGS_STRING:
    return "STRING";
  case ARGS_COMMANDS:
    return "COMMANDS";
  }
  return "INVALID";
}

/* Get value as string. */
static const char *
args_value_as_string(struct args_value *value)
{
  switch (value->type) {
  case ARGS_NONE:
    return ("");
  case ARGS_COMMANDS:
    if (value->cached == NULL)
      value->cached = cmd_list_print(value->cmdlist, 0);
    return (value->cached);
  case ARGS_STRING:
    return (value->string);
  }
  fatalx("unexpected argument type");
}

/* Create an empty arguments set. */
struct args *
args_create(void)
{
  struct args  *args;

  args = xcalloc(1, sizeof *args);
  RB_INIT(&args->tree);
  return (args);
}

/* Parse a single flag. */
static int
args_parse_flag_argument(struct args_value *values, u_int count, char **cause,
    struct args *args, u_int *i, const char *string, int flag,
    int optional_argument)
{
  struct args_value *argument, *new;
  const char    *s, *as;

  new = xcalloc(1, sizeof *new);
  if (*string != '\0') {
    new->type = ARGS_STRING;
    new->string = xstrdup(string);
    goto out;
  }

  if (*i == count)
    argument = NULL;
  else {
    argument = &values[*i];
    if (argument->type != ARGS_STRING) {
      xasprintf(cause, "-%c argument must be a string", flag);
      args_free_value(new);
      free(new);
      return (-1);
    }
  }
  if (argument == NULL) {
    args_free_value(new);
    free(new);
    if (optional_argument) {
      log_debug("%s: -%c (optional)", __func__, flag);
      args_set(args, flag, NULL, ARGS_ENTRY_OPTIONAL_VALUE);
      return (0); /* either - or end */
    }
    xasprintf(cause, "-%c expects an argument", flag);
    return (-1);
  }

  if (optional_argument && argument->type == ARGS_STRING) {
    as = argument->string;
    if (as[0] == '-' && (as[1] == '-' || isalpha((u_char)as[1]))) {
      args_free_value(new);
      free(new);
      log_debug("%s: -%c (optional)", __func__, flag);
      args_set(args, flag, NULL, ARGS_ENTRY_OPTIONAL_VALUE);
      return (0);
    }
  }
  args_copy_value(new, argument);
  (*i)++;

out:
  s = args_value_as_string(new);
  log_debug("%s: -%c = %s", __func__, flag, s);

  args_set(args, flag, new, 0);
  return (0);
}

/* Parse flags argument. */
static int
args_parse_flags(const struct args_parse *parse, struct args_value *values,
    u_int count, char **cause, struct args *args, u_int *i)
{
  struct args_value *value;
  u_char       flag;
  const char    *found, *string;
  int      optional_argument;

  value = &values[*i];
  if (value->type != ARGS_STRING)
    return (1);

  string = value->string;
  log_debug("%s: next %s", __func__, string);
  if (*string++ != '-' || *string == '\0')
    return (1);
  (*i)++;
  if (string[0] == '-' && string[1] == '\0')
    return (1);

  for (;;) {
    flag = *string++;
    if (flag == '\0')
      return (0);
    if (flag == '?')
      return (-1);
    if (!isalnum(flag)) {
      xasprintf(cause, "invalid flag -%c", flag);
      return (-1);
    }

    found = strchr(parse->template, flag);
    if (found == NULL) {
      xasprintf(cause, "unknown flag -%c", flag);
      return (-1);
    }
    if (found[1] != ':') {
      log_debug("%s: -%c", __func__, flag);
      args_set(args, flag, NULL, 0);
      continue;
    }
    optional_argument = (found[2] == ':');
    return (args_parse_flag_argument(values, count, cause, args, i,
        string, flag, optional_argument));
  }
}

/* Parse arguments into a new argument set. */
struct args *
args_parse(const struct args_parse *parse, struct args_value *values,
    u_int count, char **cause)
{
  struct args   *args;
  u_int      i;
  enum args_parse_type   type;
  struct args_value *value, *new;
  const char    *s;
  int      stop;

  if (count == 0)
    return (args_create());

  args = args_create();
  for (i = 1; i < count; /* nothing */) {
    stop = args_parse_flags(parse, values, count, cause, args, &i);
    if (stop == -1) {
      args_free(args);
      return (NULL);
    }
    if (stop == 1)
      break;
  }
  log_debug("%s: flags end at %u of %u", __func__, i, count);
  if (i != count) {
    for (/* nothing */; i < count; i++) {
      value = &values[i];

      s = args_value_as_string(value);
      log_debug("%s: %u = %s (type %s)", __func__, i, s,
          args_type_to_string (value->type));

      if (parse->cb != NULL) {
        type = parse->cb(args, args->count, cause);
        if (type == ARGS_PARSE_INVALID) {
          args_free(args);
          return (NULL);
        }
      } else
        type = ARGS_PARSE_STRING;

      args->values = xrecallocarray(args->values,
          args->count, args->count + 1, sizeof *args->values);
      new = &args->values[args->count++];

      switch (type) {
      case ARGS_PARSE_INVALID:
        fatalx("unexpected argument type");
      case ARGS_PARSE_STRING:
        if (value->type != ARGS_STRING) {
          xasprintf(cause,
              "argument %u must be \"string\"",
              args->count);
          args_free(args);
          return (NULL);
        }
        args_copy_value(new, value);
        break;
      case ARGS_PARSE_COMMANDS_OR_STRING:
        args_copy_value(new, value);
        break;
      case ARGS_PARSE_COMMANDS:
        if (value->type != ARGS_COMMANDS) {
          xasprintf(cause,
              "argument %u must be { commands }",
              args->count);
          args_free(args);
          return (NULL);
        }
        args_copy_value(new, value);
        break;
      }
    }
  }

  if (parse->lower != -1 && args->count < (u_int)parse->lower) {
    xasprintf(cause,
        "too few arguments (need at least %u)",
        parse->lower);
    args_free(args);
    return (NULL);
  }
  if (parse->upper != -1 && args->count > (u_int)parse->upper) {
    xasprintf(cause,
        "too many arguments (need at most %u)",
        parse->upper);
    args_free(args);
    return (NULL);
  }
  return (args);
}

/* Copy and expand a value. */
static void
args_copy_copy_value(struct args_value *to, struct args_value *from, int argc,
    char **argv)
{
  char  *s, *expanded;
  int  i;

  to->type = from->type;
  switch (from->type) {
  case ARGS_NONE:
    break;
  case ARGS_STRING:
    expanded = xstrdup(from->string);
    for (i = 0; i < argc; i++) {
      s = cmd_template_replace(expanded, argv[i], i + 1);
      free(expanded);
      expanded = s;
    }
    to->string = expanded;
    break;
  case ARGS_COMMANDS:
    to->cmdlist = cmd_list_copy(from->cmdlist, argc, argv);
    break;
  }
}

/* Copy an arguments set. */
struct args *
args_copy(struct args *args, int argc, char **argv)
{
  struct args   *new_args;
  struct args_entry *entry;
  struct args_value *value, *new_value;
  u_int      i;

  cmd_log_argv(argc, argv, "%s", __func__);

  new_args = args_create();
  RB_FOREACH(entry, args_tree, &args->tree) {
    if (TAILQ_EMPTY(&entry->values)) {
      for (i = 0; i < entry->count; i++)
        args_set(new_args, entry->flag, NULL, 0);
      continue;
    }
    TAILQ_FOREACH(value, &entry->values, entry) {
      new_value = xcalloc(1, sizeof *new_value);
      args_copy_copy_value(new_value, value, argc, argv);
      args_set(new_args, entry->flag, new_value, 0);
    }
  }
  if (args->count == 0)
    return (new_args);
  new_args->count = args->count;
  new_args->values = xcalloc(args->count, sizeof *new_args->values);
  for (i = 0; i < args->count; i++) {
    new_value = &new_args->values[i];
    args_copy_copy_value(new_value, &args->values[i], argc, argv);
  }
  return (new_args);
}

/* Free a value. */
void
args_free_value(struct args_value *value)
{
  switch (value->type) {
  case ARGS_NONE:
    break;
  case ARGS_STRING:
    free(value->string);
    break;
  case ARGS_COMMANDS:
    cmd_list_free(value->cmdlist);
    break;
  }
  free(value->cached);
}

/* Free values. */
void
args_free_values(struct args_value *values, u_int count)
{
  u_int i;

  for (i = 0; i < count; i++)
    args_free_value(&values[i]);
}

/* Free an arguments set. */
void
args_free(struct args *args)
{
  struct args_entry *entry;
  struct args_entry *entry1;
  struct args_value *value;
  struct args_value *value1;

  args_free_values(args->values, args->count);
  free(args->values);

  RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) {
    RB_REMOVE(args_tree, &args->tree, entry);
    TAILQ_FOREACH_SAFE(value, &entry->values, entry, value1) {
      TAILQ_REMOVE(&entry->values, value, entry);
      args_free_value(value);
      free(value);
    }
    free(entry);
  }

  free(args);
}

/* Convert arguments to vector. */
void
args_to_vector(struct args *args, int *argc, char ***argv)
{
  char  *s;
  u_int  i;

  *argc = 0;
  *argv = NULL;

  for (i = 0; i < args->count; i++) {
    switch (args->values[i].type) {
    case ARGS_NONE:
      break;
    case ARGS_STRING:
      cmd_append_argv(argc, argv, args->values[i].string);
      break;
    case ARGS_COMMANDS:
      s = cmd_list_print(args->values[i].cmdlist, 0);
      cmd_append_argv(argc, argv, s);
      free(s);
      break;
    }
  }
}

/* Convert arguments from vector. */
struct args_value *
args_from_vector(int argc, char **argv)
{
  struct args_value *values;
  int      i;

  values = xcalloc(argc, sizeof *values);
  for (i = 0; i < argc; i++) {
    values[i].type = ARGS_STRING;
    values[i].string = xstrdup(argv[i]);
  }
  return (values);
}

/* Add to string. */
static void printflike(3, 4)
args_print_add(char **buf, size_t *len, const char *fmt, ...)
{
  va_list  ap;
  char  *s;
  size_t   slen;

  va_start(ap, fmt);
  slen = xvasprintf(&s, fmt, ap);
  va_end(ap);

  *len += slen;
  *buf = xrealloc(*buf, *len);

  strlcat(*buf, s, *len);
  free(s);
}

/* Add value to string. */
static void
args_print_add_value(char **buf, size_t *len, struct args_value *value)
{
  char  *expanded = NULL;

  if (**buf != '\0')
    args_print_add(buf, len, " ");

  switch (value->type) {
  case ARGS_NONE:
    break;
  case ARGS_COMMANDS:
    expanded = cmd_list_print(value->cmdlist, 0);
    args_print_add(buf, len, "{ %s }", expanded);
    break;
  case ARGS_STRING:
    expanded = args_escape(value->string);
    args_print_add(buf, len, "%s", expanded);
    break;
  }
  free(expanded);
}

/* Print a set of arguments. */
char *
args_print(struct args *args)
{
  size_t       len;
  char      *buf;
  u_int      i, j;
  struct args_entry *entry;
  struct args_entry *last = NULL;
  struct args_value *value;

  len = 1;
  buf = xcalloc(1, len);

  /* Process the flags first. */
  RB_FOREACH(entry, args_tree, &args->tree) {
    if (entry->flags & ARGS_ENTRY_OPTIONAL_VALUE)
      continue;
    if (!TAILQ_EMPTY(&entry->values))
      continue;

    if (*buf == '\0')
      args_print_add(&buf, &len, "-");
    for (j = 0; j < entry->count; j++)
      args_print_add(&buf, &len, "%c", entry->flag);
  }

  /* Then the flags with arguments. */
  RB_FOREACH(entry, args_tree, &args->tree) {
    if (entry->flags & ARGS_ENTRY_OPTIONAL_VALUE) {
      if (*buf != '\0')
        args_print_add(&buf, &len, " -%c", entry->flag);
      else
        args_print_add(&buf, &len, "-%c", entry->flag);
      last = entry;
      continue;
    }
    if (TAILQ_EMPTY(&entry->values))
      continue;
    TAILQ_FOREACH(value, &entry->values, entry) {
      if (*buf != '\0')
        args_print_add(&buf, &len, " -%c", entry->flag);
      else
        args_print_add(&buf, &len, "-%c", entry->flag);
      args_print_add_value(&buf, &len, value);
    }
    last = entry;
  }
  if (last && (last->flags & ARGS_ENTRY_OPTIONAL_VALUE))
    args_print_add(&buf, &len, " --");

  /* And finally the argument vector. */
  for (i = 0; i < args->count; i++)
    args_print_add_value(&buf, &len, &args->values[i]);

  return (buf);
}

/* Escape an argument. */
char *
args_escape(const char *s)
{
  static const char  dquoted[] = " #';${}%";
  static const char  squoted[] = " \"";
  char      *escaped, *result;
  int      flags, quotes = 0;

  if (*s == '\0') {
    xasprintf(&result, "''");
    return (result);
  }
  if (s[strcspn(s, dquoted)] != '\0')
    quotes = '"';
  else if (s[strcspn(s, squoted)] != '\0')
    quotes = '\'';

  if (s[0] != ' ' &&
      s[1] == '\0' &&
      (quotes != 0 || s[0] == '~')) {
    xasprintf(&escaped, "\\%c", s[0]);
    return (escaped);
  }

  flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
  if (quotes == '"')
    flags |= VIS_DQ;
  utf8_stravis(&escaped, s, flags);

  if (quotes == '\'')
    xasprintf(&result, "'%s'", escaped);
  else if (quotes == '"') {
    if (*escaped == '~')
      xasprintf(&result, "\"\\%s\"", escaped);
    else
      xasprintf(&result, "\"%s\"", escaped);
  } else {
    if (*escaped == '~')
      xasprintf(&result, "\\%s", escaped);
    else
      result = xstrdup(escaped);
  }
  free(escaped);
  return (result);
}

/* Return if an argument is present. */
int
args_has(struct args *args, u_char flag)
{
  struct args_entry *entry;

  entry = args_find(args, flag);
  if (entry == NULL)
    return (0);
  return (entry->count);
}

/* Set argument value in the arguments tree. */
void
args_set(struct args *args, u_char flag, struct args_value *value, int flags)
{
  struct args_entry *entry;

  entry = args_find(args, flag);
  if (entry == NULL) {
    entry = xcalloc(1, sizeof *entry);
    entry->flag = flag;
    entry->count = 1;
    entry->flags = flags;
    TAILQ_INIT(&entry->values);
    RB_INSERT(args_tree, &args->tree, entry);
  } else
    entry->count++;
  if (value != NULL && value->type != ARGS_NONE)
    TAILQ_INSERT_TAIL(&entry->values, value, entry);
  else
    free(value);
}

/* Get argument value. Will be NULL if it isn't present. */
const char *
args_get(struct args *args, u_char flag)
{
  struct args_entry *entry;

  if ((entry = args_find(args, flag)) == NULL)
    return (NULL);
  if (TAILQ_EMPTY(&entry->values))
    return (NULL);
  return (TAILQ_LAST(&entry->values, args_values)->string);
}

/* Get first argument. */
u_char
args_first(struct args *args, struct args_entry **entry)
{
  *entry = RB_MIN(args_tree, &args->tree);
  if (*entry == NULL)
    return (0);
  return ((*entry)->flag);
}

/* Get next argument. */
u_char
args_next(struct args_entry **entry)
{
  *entry = RB_NEXT(args_tree, &args->tree, *entry);
  if (*entry == NULL)
    return (0);
  return ((*entry)->flag);
}

/* Get argument count. */
u_int
args_count(struct args *args)
{
  return (args->count);
}

/* Get argument values. */
struct args_value *
args_values(struct args *args)
{
  return (args->values);
}

/* Get argument value. */
struct args_value *
args_value(struct args *args, u_int idx)
{
  if (idx >= args->count)
    return (NULL);
  return (&args->values[idx]);
}

/* Return argument as string. */
const char *
args_string(struct args *args, u_int idx)
{
  if (idx >= args->count)
    return (NULL);
  return (args_value_as_string(&args->values[idx]));
}

/* Make a command now. */
struct cmd_list *
args_make_commands_now(struct cmd *self, struct cmdq_item *item, u_int idx,
    int expand)
{
  struct args_command_state *state;
  char        *error;
  struct cmd_list     *cmdlist;

  state = args_make_commands_prepare(self, item, idx, NULL, 0, expand);
  cmdlist = args_make_commands(state, 0, NULL, &error);
  if (cmdlist == NULL) {
    cmdq_error(item, "%s", error);
    free(error);
  }
  else
    cmdlist->references++;
  args_make_commands_free(state);
  return (cmdlist);
}

/* Save bits to make a command later. */
struct args_command_state *
args_make_commands_prepare(struct cmd *self, struct cmdq_item *item, u_int idx,
    const char *default_command, int wait, int expand)
{
  struct args     *args = cmd_get_args(self);
  struct cmd_find_state   *target = cmdq_get_target(item);
  struct client     *tc = cmdq_get_target_client(item);
  struct args_value   *value;
  struct args_command_state *state;
  const char      *cmd;
  const char      *file;

  state = xcalloc(1, sizeof *state);

  if (idx < args->count) {
    value = &args->values[idx];
    if (value->type == ARGS_COMMANDS) {
      state->cmdlist = value->cmdlist;
      state->cmdlist->references++;
      return (state);
    }
    cmd = value->string;
  } else {
    if (default_command == NULL)
      fatalx("argument out of range");
    cmd = default_command;
  }


  if (expand)
    state->cmd = format_single_from_target(item, cmd);
  else
    state->cmd = xstrdup(cmd);
  log_debug("%s: %s", __func__, state->cmd);

  if (wait)
    state->pi.item = item;
  cmd_get_source(self, &file, &state->pi.line);
  if (file != NULL)
    state->pi.file = xstrdup(file);
  state->pi.c = tc;
  if (state->pi.c != NULL)
    state->pi.c->references++;
  cmd_find_copy_state(&state->pi.fs, target);

  return (state);
}

/* Return argument as command. */
struct cmd_list *
args_make_commands(struct args_command_state *state, int argc, char **argv,
    char **error)
{
  struct cmd_parse_result *pr;
  char      *cmd, *new_cmd;
  int      i;

  if (state->cmdlist != NULL) {
    if (argc == 0)
      return (state->cmdlist);
    return (cmd_list_copy(state->cmdlist, argc, argv));
  }

  cmd = xstrdup(state->cmd);
  log_debug("%s: %s", __func__, cmd);
  cmd_log_argv(argc, argv, __func__);
  for (i = 0; i < argc; i++) {
    new_cmd = cmd_template_replace(cmd, argv[i], i + 1);
    log_debug("%s: %%%u %s: %s", __func__, i + 1, argv[i], new_cmd);
    free(cmd);
    cmd = new_cmd;
  }
  log_debug("%s: %s", __func__, cmd);

  pr = cmd_parse_from_string(cmd, &state->pi);
  free(cmd);
  switch (pr->status) {
  case CMD_PARSE_ERROR:
    *error = pr->error;
    return (NULL);
  case CMD_PARSE_SUCCESS:
    return (pr->cmdlist);
  }
  fatalx("invalid parse return state");
}

/* Free commands state. */
void
args_make_commands_free(struct args_command_state *state)
{
  if (state->cmdlist != NULL)
    cmd_list_free(state->cmdlist);
  if (state->pi.c != NULL)
    server_client_unref(state->pi.c);
  free((void *)state->pi.file);
  free(state->cmd);
  free(state);
}

/* Get prepared command. */
char *
args_make_commands_get_command(struct args_command_state *state)
{
  struct cmd  *first;
  int    n;
  char    *s;

  if (state->cmdlist != NULL) {
    first = cmd_list_first(state->cmdlist);
    if (first == NULL)
      return (xstrdup(""));
    return (xstrdup(cmd_get_entry(first)->name));
  }
  n = strcspn(state->cmd, " ,");
  xasprintf(&s, "%.*s", n, state->cmd);
  return (s);
}

/* Get first value in argument. */
struct args_value *
args_first_value(struct args *args, u_char flag)
{
  struct args_entry *entry;

  if ((entry = args_find(args, flag)) == NULL)
    return (NULL);
  return (TAILQ_FIRST(&entry->values));
}

/* Get next value in argument. */
struct args_value *
args_next_value(struct args_value *value)
{
  return (TAILQ_NEXT(value, entry));
}

/* Convert an argument value to a number. */
long long
args_strtonum(struct args *args, u_char flag, long long minval,
    long long maxval, char **cause)
{
  const char    *errstr;
  long long    ll;
  struct args_entry *entry;
  struct args_value *value;

  if ((entry = args_find(args, flag)) == NULL) {
    *cause = xstrdup("missing");
    return (0);
  }
  value = TAILQ_LAST(&entry->values, args_values);
  if (value == NULL ||
      value->type != ARGS_STRING ||
      value->string == NULL) {
    *cause = xstrdup("missing");
    return (0);
  }

  ll = strtonum(value->string, minval, maxval, &errstr);
  if (errstr != NULL) {
    *cause = xstrdup(errstr);
    return (0);
  }

  *cause = NULL;
  return (ll);
}

/* Convert an argument value to a number, and expand formats. */
long long
args_strtonum_and_expand(struct args *args, u_char flag, long long minval,
    long long maxval, struct cmdq_item *item, char **cause)
{
  const char    *errstr;
  char      *formatted;
  long long    ll;
  struct args_entry *entry;
  struct args_value *value;

  if ((entry = args_find(args, flag)) == NULL) {
    *cause = xstrdup("missing");
    return (0);
  }
  value = TAILQ_LAST(&entry->values, args_values);
  if (value == NULL ||
      value->type != ARGS_STRING ||
      value->string == NULL) {
    *cause = xstrdup("missing");
    return (0);
  }

  formatted = format_single_from_target(item, value->string);
  ll = strtonum(formatted, minval, maxval, &errstr);
  free(formatted);
  if (errstr != NULL) {
    *cause = xstrdup(errstr);
    return (0);
  }

  *cause = NULL;
  return (ll);
}

/* Convert an argument to a number which may be a percentage. */
long long
args_percentage(struct args *args, u_char flag, long long minval,
    long long maxval, long long curval, char **cause)
{
  const char    *value;
  struct args_entry *entry;

  if ((entry = args_find(args, flag)) == NULL) {
    *cause = xstrdup("missing");
    return (0);
  }
  if (TAILQ_EMPTY(&entry->values)) {
    *cause = xstrdup("empty");
    return (0);
  }
  value = TAILQ_LAST(&entry->values, args_values)->string;
  return (args_string_percentage(value, minval, maxval, curval, cause));
}

/* Convert a string to a number which may be a percentage. */
long long
args_string_percentage(const char *value, long long minval, long long maxval,
    long long curval, char **cause)
{
  const char  *errstr;
  long long  ll;
  size_t     valuelen = strlen(value);
  char    *copy;

  if (valuelen == 0) {
    *cause = xstrdup("empty");
    return (0);
  }
  if (value[valuelen - 1] == '%') {
    copy = xstrdup(value);
    copy[valuelen - 1] = '\0';

    ll = strtonum(copy, 0, 1000, &errstr);
    free(copy);
    if (errstr != NULL) {
      *cause = xstrdup(errstr);
      return (0);
    }
    ll = (curval * ll) / 100;
    if (ll < minval) {
      *cause = xstrdup("too small");
      return (0);
    }
    if (ll > maxval) {
      *cause = xstrdup("too large");
      return (0);
    }
  } else {
    ll = strtonum(value, minval, maxval, &errstr);
    if (errstr != NULL) {
      *cause = xstrdup(errstr);
      return (0);
    }
  }

  *cause = NULL;
  return (ll);
}

/*
 * Convert an argument to a number which may be a percentage, and expand
 * formats.
 */
long long
args_percentage_and_expand(struct args *args, u_char flag, long long minval,
    long long maxval, long long curval, struct cmdq_item *item, char **cause)
{
  const char    *value;
  struct args_entry *entry;

  if ((entry = args_find(args, flag)) == NULL) {
    *cause = xstrdup("missing");
    return (0);
  }
  if (TAILQ_EMPTY(&entry->values)) {
    *cause = xstrdup("empty");
    return (0);
  }
  value = TAILQ_LAST(&entry->values, args_values)->string;
  return (args_string_percentage_and_expand(value, minval, maxval, curval,
        item, cause));
}

/*
 * Convert a string to a number which may be a percentage, and expand formats.
 */
long long
args_string_percentage_and_expand(const char *value, long long minval,
    long long maxval, long long curval, struct cmdq_item *item, char **cause)
{
  const char  *errstr;
  long long  ll;
  size_t     valuelen = strlen(value);
  char    *copy, *f;

  if (value[valuelen - 1] == '%') {
    copy = xstrdup(value);
    copy[valuelen - 1] = '\0';

    f = format_single_from_target(item, copy);
    ll = strtonum(f, 0, 1000, &errstr);
    free(f);
    free(copy);
    if (errstr != NULL) {
      *cause = xstrdup(errstr);
      return (0);
    }
    ll = (curval * ll) / 100;
    if (ll < minval) {
      *cause = xstrdup("too small");
      return (0);
    }
    if (ll > maxval) {
      *cause = xstrdup("too large");
      return (0);
    }
  } else {
    f = format_single_from_target(item, value);
    ll = strtonum(f, minval, maxval, &errstr);
    free(f);
    if (errstr != NULL) {
      *cause = xstrdup(errstr);
      return (0);
    }
  }

  *cause = NULL;
  return (ll);
}

Coverage Report

Created: 2026-07-30 07:05