bird/client/commands.c

/*
 *	BIRD Client -- Command Handling
 *
 *	(c) 1999--2000 Martin Mares <mj@ucw.cz>
 *
 *	Can be freely distributed and used under the terms of the GNU GPL.
 */

#include <stdio.h>
#include <ctype.h>

#include "nest/bird.h"
#include "lib/resource.h"
#include "lib/string.h"
#include "client/client.h"

struct cmd_info {
  /* use for build tree and command cli */
  char *command;
  char *args;
  char *help;

  /* only for build tree */
  int is_real_cmd;
  u32 flags;			/* Mask of (CLI_SF_*) */
};

static struct cmd_info command_table[] = {
#include "conf/commands.h"
};

struct cmd_node {
  struct cmd_node *sibling;
  struct cmd_node *son;
  struct cmd_node **plastson;	/* Helping pointer to son */
  struct cmd_info *cmd;		/* Short info */
  struct cmd_info *help;	/* Detailed info */
  signed char prio; 		/* Priority */
  u32 flags;			/* Mask of (CLI_SF_*) */
  int len; 			/* Length of string in token */
  char token[1];		/* Name of command */
};

static struct cmd_node cmd_root;

void
cmd_build_tree(void)
{
  uint i;

  cmd_root.plastson = &cmd_root.son;

  for(i=0; i<ARRAY_SIZE(command_table); i++)
    {
      struct cmd_info *cmd = &command_table[i];
      struct cmd_node *old, *new;
      char *c = cmd->command;

      old = &cmd_root;
      while (*c)
	{
	  char *d = c;
	  while (*c && !isspace(*c))
	    c++;
	  for(new=old->son; new; new=new->sibling)
	    if (new->len == c-d && !memcmp(new->token, d, c-d))
	      break;
	  if (!new)
	    {
	      int size = sizeof(struct cmd_node) + c-d;
	      new = xmalloc(size);
	      bzero(new, size);
	      *old->plastson = new;
	      old->plastson = &new->sibling;
	      new->plastson = &new->son;
	      new->len = c-d;
	      memcpy(new->token, d, c-d);
	      new->prio = (new->len == 3 && (!memcmp(new->token, "roa", 3) || !memcmp(new->token, "rip", 3))) ? 0 : 1; /* Hack */
	    }
	  old = new;
	  while (isspace(*c))
	    c++;
	}
      if (cmd->is_real_cmd)
	old->cmd = cmd;
      else
	old->help = cmd;
      old->flags |= cmd->flags;
    }
}

static void
cmd_do_display_help(struct cmd_info *c)
{
  char buf[strlen(c->command) + strlen(c->args) + 4];

  sprintf(buf, "%s %s", c->command, c->args);
  printf("%-45s  %s\n", buf, c->help);
}

static void
cmd_display_help(struct cmd_info *c1, struct cmd_info *c2)
{
  if (c1)
    cmd_do_display_help(c1);
  else if (c2)
    cmd_do_display_help(c2);
}

static struct cmd_node *
cmd_find_abbrev(struct cmd_node *root, char *cmd, int len, int *pambiguous)
{
  struct cmd_node *m, *best = NULL, *best2 = NULL;
  list *l_syms = cli_get_symbol_list();
  struct cli_symbol *sym;

  *pambiguous = 0;
  for(m=root->son; m; m=m->sibling)
    {
      if (m->len == len && !memcmp(m->token, cmd, len))
	return m;
      if (m->len > len && !memcmp(m->token, cmd, len))
	{
	  if (best && best->prio > m->prio)
	    continue;
	  if (best && best->prio == m->prio)
	    best2 = best;
	  best = m;
	}
    }
  if (best2)
    {
      *pambiguous = 1;
      return NULL;
    }
  return best;
}

static void
cmd_list_ambiguous(struct cmd_node *root, char *cmd, int len)
{
  struct cmd_node *m;

  for(m=root->son; m; m=m->sibling)
    if (m->len > len && !memcmp(m->token, cmd, len))	
      cmd_display_help(m->help, m->cmd);

  struct cli_symbol *sym;
  list *syms = cli_get_symbol_list();
  WALK_LIST(sym, *syms)
  {
    if ((sym->flags & root->flags) && sym->len > len && memcmp(sym->name, cmd, len) == 0)
      printf("%s\n", sym->name);
  }
}

void
cmd_help(char *cmd, int len)
{
  char *end = cmd + len;
  struct cmd_node *n, *m;
  char *z;
  int ambig;

  n = &cmd_root;
  while (cmd < end)
    {
      if (isspace(*cmd))
	{
	  cmd++;
	  continue;
	}
      z = cmd;
      while (cmd < end && !isspace(*cmd))
	cmd++;
      m = cmd_find_abbrev(n, z, cmd-z, &ambig);
      if (ambig)
	{
	  cmd_list_ambiguous(n, z, cmd-z);
	  return;
	}
      if (!m)
	break;
      n = m;
    }
  cmd_display_help(n->cmd, NULL);
  for (m=n->son; m; m=m->sibling)
    cmd_display_help(m->help, m->cmd);
}

/*
 * Return length of common prefix of all matches,
 * Write common prefix string into buf
 */
static int
cmd_merge_match_with_others(int max_common_len, const char *token_name, int token_len, char *buf, int from)
{
  if (max_common_len < 0)
  {
    /* For a case that we'll have exactly one match */
    strcpy(buf, token_name + from);
    max_common_len = token_len - from;
  }
  else
  {
    int i = 0;
    while (i < max_common_len && i < token_len - from && buf[i] == token_name[from+i])
      i++;
    max_common_len = i;
  }
  return max_common_len;
}

/*
 * Return length of common prefix of all matches,
 * Write count of all matches into pcount,
 * Write common prefix string into buf
 */
static int
cmd_find_common_match(struct cmd_node *root, char *cmd, int len, int *pcount, char *buf)
{
  struct cmd_node *m;
  int max_common_len;
  int best_prio, i;

  *pcount = 0;
  max_common_len = -1;
  best_prio = -1;
  for(m=root->son; m; m=m->sibling)
    {
      if (m->len < len || memcmp(m->token, cmd, len))
	continue;

      if (best_prio > m->prio)
	continue;

      if (best_prio < m->prio)
	{
	  *pcount = 0;
	  max_common_len = -1;
	}

      if (max_common_len < 0)
	best_prio = m->prio;

      (*pcount)++;
      max_common_len = cmd_merge_match_with_others(max_common_len, m->token, m->len, buf, len);
    }

  list *syms = cli_get_symbol_list();
  struct cli_symbol *sym;
  WALK_LIST(sym, *syms)
  {
    if (!(sym->flags & root->flags))
      continue;

    if (sym->len < len || memcmp(sym->name, cmd, len))
      continue;

    (*pcount)++;
    max_common_len = cmd_merge_match_with_others(max_common_len, sym->name, sym->len, buf, len);
  }

  return max_common_len;
}

int
cmd_complete(char *cmd, int len, char *buf, int again)
{
  char *start = cmd;
  char *end = cmd + len;
  char *fin;
  struct cmd_node *n, *m = NULL;
  char *z;
  int ambig, cnt = 0, common;

  /* Find the last word we want to complete */
  for(fin=end; fin > start && !isspace(fin[-1]); fin--)
    ;

  /* Find the context */
  n = &cmd_root;
  while (cmd < fin)
    {
      if (isspace(*cmd))
	{
	  cmd++;
	  continue;
	}
      z = cmd;
      while (cmd < fin && !isspace(*cmd))
	cmd++;
      m = cmd_find_abbrev(n, z, cmd-z, &ambig);
      if (ambig)
	{
	  if (!again)
	    return -1;
	  input_start_list();
	  cmd_list_ambiguous(n, z, cmd-z);
	  input_stop_list();
	  return 0;
	}
      if (!m)
	return -1;

      /* Try skip a parameter/word */
      if (m->flags & CLI_SF_PARAMETER)
      {
	z = cmd;

	/* Skip spaces before parameter */
	while (cmd < fin && isspace(*cmd))
	  cmd++;

	/* Skip one parameter/word */
	while (cmd < fin && !isspace(*cmd))
	  cmd++;

	/* Check ending of parameter */
	if (isspace(*cmd))
	{
	  if (m->flags & CLI_SF_OPTIONAL)
	    m = n;
	  continue;
	}
	else
	  cmd = z;
      }

      /* Do not enter to optional command nodes */
      if (!(m->flags & CLI_SF_OPTIONAL))
	n = m;
    }

  /* Enter to the last command node */
  if (m && (m->flags & CLI_SF_PARAMETER))
    n = m;

  /* We know the context, let's try to complete */
  common = cmd_find_common_match(n, fin, end-fin, &cnt, buf);
  if (!cnt)
    return -1;
  if (cnt == 1)
    {
      buf[common++] = ' ';
      buf[common] = 0;
      return 1;
    }
  if (common > 0)
    {
      buf[common] = 0;
      return 1;
    }
  if (!again)
    return -1;
  input_start_list();
  cmd_list_ambiguous(n, fin, end-fin);
  input_stop_list();
  return 0;
}

char *
cmd_expand(char *cmd)
{
  struct cmd_node *n, *m, *last_real_cmd = NULL;
  char *c, *b, *args, *lrc_args = NULL;
  int ambig;

  args = c = cmd;
  n = &cmd_root;
  while (*c)
    {
      if (isspace(*c))
	{
	  c++;
	  continue;
	}
      b = c;
      while (*c && !isspace(*c))
	c++;
      m = cmd_find_abbrev(n, b, c-b, &ambig);
      if (!m)
	{
	  if (!ambig)
	    break;
	  puts("Ambiguous command, possible expansions are:");
	  cmd_list_ambiguous(n, b, c-b);
	  return NULL;
	}

      args = c;
      n = m;

      if (m->cmd)
      {
	last_real_cmd = m;
	lrc_args = c;
      }
    }

  if (!n->cmd && !last_real_cmd)
    {
      puts("No such command. Press `?' for help.");
      return NULL;
    }
  if (last_real_cmd && last_real_cmd != n)
  {
    n = last_real_cmd;
    args = lrc_args;
  }
  b = xmalloc(strlen(n->cmd->command) + strlen(args) + 1);
  sprintf(b, "%s%s", n->cmd->command, args);
  return b;
}