Setting the maximum interface count now does the right thing.

[unet] / unetcfg.c

/* -*-c-*-
 *
 * $Id: unetcfg.c,v 1.2 2001/02/03 18:39:59 mdw Exp $
 *
 * User-space network device support.
 *
 * (c) 1998 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of Usernet.
 *
 * Usernet 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.
 *
 * Usernet 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 Usernet; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------*
 *
 * $Log: unetcfg.c,v $
 * Revision 1.2  2001/02/03 18:39:59  mdw
 * Setting the maximum interface count now does the right thing.
 *
 * Revision 1.1  2001/01/25 22:03:39  mdw
 * Initial check-in (somewhat belated).
 *
 */

/*----- Include files -----------------------------------------------------*/

#include <errno.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <linux/if_ether.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/ioctl.h>

#include <fcntl.h>
#include <unistd.h>

#include "unet.h"

/*----- Static variables --------------------------------------------------*/

#define VERSION "1.00"
#define ETH_P_HELP 0xffffu

static const char *quis = "unetcfg";	/* My program's name */
static int flags = 0;			/* Various useful status flags */
static const char *current = "<stdin>";	/* Current Usernet device */
static int fd = 0;			/* Default to @stdin@ */

#define f_verbose 1u
#define f_duff 2u
#define f_check 4u
#define f_close 8u

/*----- Common routines ---------------------------------------------------*/

/* --- @die@ --- *
 *
 * Arguments:	@const char *format@ = format string to print
 *		@...@ = values for the placeholders
 *
 * Returns:	Doesn't
 *
 * Use:		Reports a fatal error message.
 */

static void die(const char *format, ...)
{
  va_list ap;
  va_start(ap, format);
  fputs(quis, stderr);
  fputs(": ", stderr);
  vfprintf(stderr, format, ap);
  fputc('\n', stderr);
  va_end(ap);
  exit(EXIT_FAILURE);
}

/* --- @whiiter@ --- *
 *
 * Arguments:	@const char *format@ = format string to print
 *		@...@ = values for the placeholders
 *
 * Returns:	Doesn't
 *
 * Use:		Reports a non-fatal error message.
 */

static void whitter(const char *format, ...)
{
  va_list ap;

  if ((flags & f_verbose) == 0)
    return;

  va_start(ap, format);
  fputs(quis, stderr);
  fputs(": ", stderr);
  vfprintf(stderr, format, ap);
  fputc('\n', stderr);
  va_end(ap);
}

/* --- @lookup@ --- *
 *
 * Arguments:	@void *p@ = pointer to a table
 *		@size_t sz@ = size of the table items
 *		@const char *s@ = pointer to string to match
 *
 * Returns:	Pointer to the matching block.
 *
 * Use:		Finds an item in a table.
 */

static void *lookup(const void *p, size_t sz, const char *s)
{
  const char **q = (const char **)p;
  const void *e = 0;

  while (*q) {
    const char *x = *q, *y = s;

    for (;;) {
      if (!*y) {
	if (!*x)
	  return ((void *)q);
	if (e)
	  die("ambiguous name `%s'", s);
	e = q;
	break;
      } else if (*x == *y) {
	x++;
	y++;
	continue;
      } else
	break;
    }
    q = (const char **)((const char *)q + sz);
  }
  return ((void *)e);
}

#define LOOKUP(tbl, key) lookup((tbl), sizeof((tbl)[0]), (key))

/* --- @check@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Ensures that the current device really is a Usernet device.
 */

static void check(void)
{
  if (flags & f_check)
    return;
  if (ioctl(fd, UNIOCGINFO, 0) < 0)
    die("file `%s' is not a Usernet device", current);
  flags |= f_check;
}

/*----- Command implementations -------------------------------------------*/

/* --- Forward declarations --- */

struct command {
  const char *cmd;			/* Command name */
  int minarg;				/* Minimum number of args */
  int (*func)(char **av);		/* Command handler function */
  const char *syn, *shelp, *vhelp;	/* Short and verbose help */
};

static struct command cmdtab[];

struct eth_proto {
  const char *name;			/* User-level protocol name */
  unsigned short proto;			/* Protocol number */
  const char *desc;			/* Readable description */
};

static struct eth_proto eth_prototab[];

#define YNQ_YES 1
#define YNQ_NO 0
#define YNQ_QUERY (-1)

static struct ynq {
  const char *s;
  int val;
} ynqtab[] = {
  { "query",	YNQ_QUERY },
  { "show",	YNQ_QUERY },
  { "?",	YNQ_QUERY },
  { "yes",	YNQ_YES },
  { "on",	YNQ_YES },
  { "no",	YNQ_NO },
  { "off",	YNQ_NO },
  { 0,		0 }
};

static int run(char **av);

/* --- @ynq@ --- *
 *
 * Arguments:	@const char *p@ = pointer to string to decode
 *
 * Returns:	One of the @YNQ@ codes.
 *
 * Use:		Decodes a `yes/no/query' response.
 */

static int ynq(const char *p)
{
  struct ynq *ynq = LOOKUP(ynqtab, p);
  if (!ynq)
    die("unknown setting `%s': I understand `on', `off' and `query'", p);
  return (ynq->val);
}

/* --- @cmd_help@ --- */

static int cmd_help(char **av)
{
  struct command *c;

  if (!*av) {
    puts("Commands provided:\n");
    for (c = cmdtab; c->cmd; c++)
      printf("%-30s%s\n", c->syn, c->shelp);
  } else if ((c = LOOKUP(cmdtab, *av)) == 0)
    die("unknown command: `%s'", *av);
  else {
    fputs(c->syn, stdout);
    fputs("\n\n", stdout);
    fputs(c->vhelp, stdout);
    av++;
  }
  return (run(av));
}

/* --- @cmd_select@ --- */

static int cmd_select(char **av)
{
  const char *fn = *av++;
  if (flags & f_close) {
    close(fd);
    whitter("closed previous device `%s'", current);
  }
  fd = open(fn, O_RDWR);
  if (fd < 0)
    die("couldn't open Usernet device `%s': %s", fn, strerror(errno));
  current = fn;
  flags &= ~f_check;
  check();
  whitter("opened new device: `%s'", fn);
  flags |= f_close;
  return (run(av));
}

/* --- @cmd_fd@ --- */

static int cmd_fd(char **av)
{
  const char *p;
  static char namebuf[20]; /* XXX Big enough? */

  static struct {
    const char *name;
    int fd;
    const char *desc;
  } *fdp, fdtab[] = {
    { "stdin",	0, "<stdin>" },
    { "stdout",	1, "<stdout>" },
    { "stderr",	2, "<stderr>" },
    { 0,	0, 0 }
  };

  if (flags & f_close) {
    close(fd);
    whitter("closed previous device `%s'", current);
  }

  p = *av++;
  if ((fdp = LOOKUP(fdtab, p)) != 0)
    fd = fdp->fd;
  else if (sscanf(p, "%i", &fd) < 1 || fd < 0)
    die("bad file descriptor name: `%s'", p);

  flags &= ~f_check | f_close;
  if (fd < 3)
    current = fdtab[fd].desc;
  else
    current = namebuf, sprintf(namebuf, "<fd %i>", fd);

  check();
  whitter("opened device on `%s'", current);

  return (run(av));
}

/* --- @cmd_show@ --- */

static int cmd_show(char **av)
{
  struct unet_info uni;
  const char *af, *proto;

  /* --- Name table for address families --- */

  static const char *aftab[] = {
    "Unspecified",
    "Unix file domain (!)",
    "Internet (IPv4)",
    "Amateur radio AX.25",
    "Novell IPX",
    "Appletalk",
    "Amateur radio NetROM",
    "Multiprotocol bridge (!)",
    "Reserved (for ATM)",
    "Reserved (for X.25)",
    "Internet (IPv6)",
  };

  /* --- Name table for Usernet flags --- */

  static struct {
    const char *name;
    unsigned int f;
  } *flp, fltab[] = {
    { "trans", UNIF_TRANS },
    /* @{ "open", UNIF_OPEN }@ -- ignore: this flag always appears on */
    { "debug", UNIF_DEBUG },
    { 0, 0 }
  };

  /* --- Read the attachment information --- */

  check();
  if (ioctl(fd, UNIOCGINFO, &uni) < 0)
    die("couldn't read information about attachment: %s", strerror(errno));

  /* --- Look the address family up --- */

  if (uni.uni_family < sizeof(aftab) / sizeof(aftab[0]))
    af = aftab[uni.uni_family];
  else
    af = "Unknown family";

  /* --- Look the protocol up --- */

  {
    struct eth_proto *ep;

    proto = "unknown";
    for (ep = eth_prototab; ep->name; ep++) {
      if (ep->proto == uni.uni_proto) {
	proto = ep->desc;
	break;
      }
    }
  }

  /* --- Display appropriate information --- */

  printf("Interface name: %s\n", uni.uni_ifname);
  printf("MTU: %u\n", uni.uni_mtu);
  printf("Address family: %s\n", af);
  printf("Protocol: %s\n", proto);
  printf("Flags:");

  for (flp = fltab; flp->name; flp++) {
    if (uni.uni_flags & flp->f) {
      putchar(' ');
      fputs(flp->name, stdout);
    }
  }
  putchar('\n');

  /* --- Done --- */

  return (run(av));
}

/* --- @cmd_ifname@ --- */

static int cmd_ifname(char **av)
{
  struct unet_info uni;

  check();
  if (ioctl(fd, UNIOCGINFO, &uni) < 0)
    die("couldn't read attachment information: %s", strerror(errno));
  puts(uni.uni_ifname);
  return (run(av));
}

/* --- @cmd_protocol@ --- */

static int cmd_protocol(char **av)
{
  const char *pn = *av++;
  const struct eth_proto *ep;

  if ((ep = LOOKUP(eth_prototab, pn)) == 0)
    die("unknown protocol name `%s'", pn);

  if (ep->proto == ETH_P_HELP) {
    for (ep = eth_prototab; ep->name; ep++) {
      if (ep->proto != ETH_P_HELP)
	printf("%s -- %s\n", ep->name, ep->desc);
    }
  } else {
    check();
    if (ioctl(fd, UNIOCSPROTO, ep->proto) < 0)
      die("couldn't set protocol `%s': %s", ep->name, strerror(errno));
    whitter("set protocol `%s' for `%s'", ep->name, current);
  }

  return (run(av));
}

/* --- @cmd_debug@ --- */

static int cmd_debug(char **av)
{
  check();
  switch (ynq(*av++)) {

    case YNQ_QUERY: {
      struct unet_info uni;

      if (ioctl(fd, UNIOCGINFO, &uni))
	die("error reading debug state: %s", strerror(errno));
      printf("debugging for `%s' is %s\n", current,
	     uni.uni_flags & UNIF_DEBUG ? "enabled" : "disabled");
    } break;

    case YNQ_YES:
      if (ioctl(fd, UNIOCSDEBUG, 1) < 0)
	die("error setting debug state: %s", strerror(errno));
      whitter("set debugging for `%s'", current);
      break;

    case YNQ_NO:
      if (ioctl(fd, UNIOCSDEBUG, 0) < 0)
	die("error clearing debug state: %s", strerror(errno));
      whitter("cleared debugging for `%s'", current);
      break;
  }

  return (run(av));
}
      
/* --- @cmd_gdebug@ --- */

static int cmd_gdebug(char **av)
{
  check();
  switch (ynq(*av++)) {

    case YNQ_QUERY: {
      int i = ioctl(fd, UNIOCGGDEBUG);
      if (i < 0)
	die("error reading global debug state: %s", strerror(errno));
      else
	printf("global debugging is %s\n", i ? "enabled" : "disabled");
    } break;

    case YNQ_YES:
      if (ioctl(fd, UNIOCSGDEBUG, 1) < 0)
	die("error setting global debug state: %s", strerror(errno));
      whitter("set global debugging");
      break;

    case YNQ_NO:
      if (ioctl(fd, UNIOCSGDEBUG, 0) < 0)
	die("error clearing global debug state: %s", strerror(errno));
      whitter("cleared global debugging");
      break;
  }

  return (run(av));
}

/* --- @cmd_maxif@ --- */

static int cmd_maxif(char **av)
{
  check();
  if (!*av) {
    int i = ioctl(fd, UNIOCGMAXIF);
    if (i < 0)
      die("error reading maxif: %s", strerror(errno));
    else
      printf("interface maximum is %d\n", i);
  } else {
    char *p = *av++, *q;
    long i = strtol(p, &q, 0);
    if (*q)
      die("malformed integer: %s", p);
    if (ioctl(fd, UNIOCSMAXIF, i))
      die("error setting maxif: %s", strerror(errno));
  }

  return (run(av));
}

/* --- @run@ --- *
 *
 * Arguments:	@char **av@ = array of command line arguments
 *
 * Returns:	Zero for success, nonzero for failure
 *
 * Use:		Handles a sequence of commands.
 */

static int run(char **av)
{
  struct command *c;
  int i;

  if (!*av)
    return (EXIT_SUCCESS);
  if ((c = LOOKUP(cmdtab, *av)) == 0)
    c = &cmdtab[0];
  else
    av++;
  if (!c->func)
    die("command `%s' not implemented", c->cmd);
  for (i = 0; i < c->minarg; i++) {
    if (!av[i])
      die("Usage: %s", c->syn);
  }
  return (c->func(av));
}

/* --- The command definition block --- */

static struct command cmdtab[] = {

  { "select", 1, cmd_select,
    "[select] FILE", "select a Usernet device", "\
Selects FILE as the current device.  Each command acts only on the current\n\
device.  The word `select' may be omitted if desired.\n\
" },

  {
    "fd", 1, cmd_fd,
    "fd NUMBER", "select Usernet device from a file descriptor", "\
Selects the file descriptor NUMBER as the current device.  This allows\n\
configuration of already existing transient attachments which would\n\
otherwise be unnecessarily awkward.\n\
" },

  { "show", 0, cmd_show,
    "show", "show status of device", "\
Displays status information about the current device.\n\
" },

  { "ifname", 0, cmd_ifname,
    "ifname", "print attached network interface name", "\
Displays the name of the network interface attached to the current device.\n\
This is useful in configuration scripts, for example.\n\
" },

  { "protocol", 1, cmd_protocol,
    "protocol PROT", "selects PROT as the device's protocol", "\
Sets PROT as the current device's protocol.  All packets received by the\n\
device are stamped with this protocol tag.  To see a list of currently\n\
known protocols, use the `help' protocol.\n\
" },

  { "debug", 1, cmd_debug,
    "debug on|off|query", "set attachment debugging state", "\
Set the current debugging state for the attachment.  When debugging is\n\
enabled, all packets flowing through the attachment are logged, along with\n\
a large number of other informative messages.  Note: the logs generated\n\
tend to be very large, so don't flood the interface with data while\n\
debugging is enabled!\n\
" },

  { "gdebug", 1, cmd_gdebug,
    "gdebug on|off|query", "set global debugging state", "\
Set the global debugging state for Usernet.  This controls the emission\n\
emission of various non-attachment-specific message.  Also, new\n\
attachments inherit their debug flags from the global flag.\n\
" },

  { "maxif", 0, cmd_maxif,
    "maxif [MAX]", "set maximum number of interfaces allowed", "\
Configures the maximum number of interfaces allowed.\n\
" },

  { "help", 0, cmd_help,
    "help [COMMAND]", "display help about COMMAND", "\
If COMMAND is given, display help about it.  If no COMAMND is specified,\n\
provide general help.\n\
" },

  { 0, 0, 0, 0 }
};

/* --- Protocol description table --- */

static struct eth_proto eth_prototab[] = {
  { "loop",		ETH_P_LOOP,	"Ethernet loopback" },
  { "echo",		ETH_P_ECHO,	"Ethernet echo" },
  { "pup",		ETH_P_PUP,	"Xerox PUP" },
  { "ip",		ETH_P_IP,	"Internet IP" },
  { "x25",		ETH_P_X25,	"CCITT X.25" },
  { "arp",		ETH_P_ARP,	"Address resolution protocol" },
  { "bpq",		ETH_P_BPQ,	"G8BPQ AX.25" },
  { "dec",		ETH_P_DEC,	"DEC assigned" },
  { "dna-dl",		ETH_P_DNA_DL,	"DEC DNA dump/load" },
  { "dna-rcon",		ETH_P_DNA_RC,	"DEC DNA remote console" },
  { "dna-route",	ETH_P_DNA_RT,	"DEC DNA routing" },
  { "lat",		ETH_P_LAT,	"DEC LAT" },
  { "diag",		ETH_P_DIAG,	"DEC diagnostics" },
  { "cust",		ETH_P_CUST,	"DEC customer user" },
  { "sca",		ETH_P_SCA,	"DEC Systems Comminications "
                                           "Architecture" },
  { "rarp",		ETH_P_RARP,	"Reverse address resolution" },
  { "atalk",		ETH_P_ATALK,	"Appletalk DDP" },
  { "aarp",		ETH_P_AARP,	"Appletalk AARP" },
  { "ipx",		ETH_P_IPX,	"Novell IPX" },
  { "ipv6",		ETH_P_IPV6,	"Internet IPv6" },
  { "help",		ETH_P_HELP,	"<magical help token>" },
  { 0,			0,		0 }
};

/*----- Informative messages ----------------------------------------------*/

/* --- @usage@ --- *
 *
 * Arguments:	@FILE *fp@ = stream to write on
 *
 * Returns:	---
 *
 * Use:		Displays usage information for the program.
 */

static void usage(FILE *fp)
{
  fprintf(fp, "Usage: %s [-v] command ...\n", quis);
}

/* --- @version@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Displays the system's version number.
 */

static void version(void)
{
  printf("%s version %s\n", quis, VERSION);
}

/* --- @help@ --- *
 *
 * Arguments:	---
 *
 * Returns:	Doesn't
 *
 * Use:		Displays some help and quits.
 */

static void help(void)
{
  struct command *c;
  version();
  putchar('\n');
  usage(stdout);
  putchar('\n');
  puts("Commands provided:\n");
  for (c = cmdtab; c->cmd; c++)
    printf("%-30s%s\n", c->syn, c->shelp);
  exit(0);
}

/* --- @main@ --- *
 *
 * Arguments:	@int argc@ = number of command line arguments received
 *		@char *argv[]@ = pointers to the command line arguments
 *
 * Returns:	Zero for success, nonzero for failure
 *
 * Use:		Dumps and manipulates Usernet attachments.
 */

int main(int argc, char *argv[])
{
  /* --- Set the program name properly --- */

  if (argc >= 1) {
    if ((quis = strrchr(argv[0], '/')) == 0)
      quis = argv[0];
    else
      quis++;
  }

  /* --- Now start parsing options --- */

  for (;;) {
    int i;

    static struct option opt[] = {
      { "help",			0,	0,	'h' },
      { "usage",		0,	0,	'U' },
      { "version",		0,	0,	'V' },
      { "verbose",		0,	0,	'v' },
      { 0,			0,	0,	0 }
    };

    if ((i = getopt_long(argc, argv, "hVv", opt, 0)) < 0)
      break;
    switch (i) {
      case 'h':
	help();
	break;
      case 'U':
	usage(stdout);
	exit(0);
	break;
      case 'V':
	version();
	break;
      case 'v':
	flags |= f_verbose;
	break;
      default:
	flags |= f_duff;
	break;
    }
  }

  if (flags & f_duff) {
    usage(stderr);
    printf("(Type `%s --help' for more information.)\n", quis);
    exit(EXIT_FAILURE);
  }

  return (run(argv + optind));
}

/*----- That's all, folks -------------------------------------------------*/