Describe new socket connection options.

[fwd] / conf.c

/* -*-c-*-
 *
 * $Id: conf.c,v 1.4 1999/10/15 21:12:36 mdw Exp $
 *
 * Configuration parsing
 *
 * (c) 1999 Straylight/Edgeware
 */

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

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: conf.c,v $
 * Revision 1.4  1999/10/15 21:12:36  mdw
 * Remove redundant debugging code.
 *
 * Revision 1.3  1999/08/19 18:32:48  mdw
 * Improve lexical analysis.  In particular, `chmod' patterns don't have to
 * be quoted any more.
 *
 * Revision 1.2  1999/07/26 23:28:39  mdw
 * Major reconstruction work for new design.
 *
 * Revision 1.1.1.1  1999/07/01 08:56:23  mdw
 * Initial revision.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

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

#include <mLib/dstr.h>
#include <mLib/quis.h>
#include <mLib/report.h>

#include "conf.h"
#include "scan.h"
#include "source.h"
#include "target.h"

#include "exec.h"
#include "file.h"
#include "socket.h"

/*----- Source and target tables ------------------------------------------*/

static source_ops *sources[] = { &xsource_ops, &fsource_ops, &ssource_ops };
static target_ops *targets[] = { &xtarget_ops, &ftarget_ops, &starget_ops };

static const char *notword = 0;
static const char *notdelim = 0;

/*----- Main code ---------------------------------------------------------*/

/* --- @undelim@ --- *
 *
 * Arguments:	@const char *d, dd@ = pointer to characters to escape
 *
 * Returns:	---
 *
 * Use:		Modifies the tokenizer.  Characters in the first list will
 *		always be considered to begin a word.  Characters in the
 *		second list will always be allowed to continue a word.
 */

void undelim(const char *d, const char *dd) { notword = d; notdelim = dd; }

/* --- @token@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner definition
 *
 * Returns:	Type of token scanned.
 *
 * Use:		Reads the next token from the character scanner.
 */

int token(scanner *sc)
{
#define SELFDELIM \
  '{': case '}': case '/': case ',': \
  case '=': case ':': case ';': \
  case '.': case '[': case ']'

  int ch;

  DRESET(&sc->d);

  /* --- Main tokenization --- */

  for (;;) {
    ch = scan(sc);

    /* --- Deal with pushed-back tokens --- */

    if (sc->head->tok) {
      dstr_puts(&sc->d, sc->head->tok);
      free(sc->head->tok);
      sc->head->tok = 0;
      sc->t = sc->head->t;
      goto done;
    }

    else if (isspace((unsigned char)ch))
      ;
    else switch (ch) {

      /* --- End of file --- */

      case EOF:
	sc->t = CTOK_EOF;
	goto done;

      /* --- Comment character --- */

      case '#':
	do ch = scan(sc); while (ch != EOF && ch != '\n');
	break;

      /* --- Various self-delimiting characters --- */

      case SELFDELIM:
	if (!notword || strchr(notword, ch) == 0) {
	  dstr_putc(&sc->d, ch);
	  dstr_putz(&sc->d);
	  sc->t = ch;
	  goto done;
	}

      /* --- Bare words --- *
       *
       * These aren't as bare any more.  You can now backslash-escape
       * individual characters, and enclose sections in double-quotes.
       */

      default: {
	int q = 0;

	for (;;) {
	  switch (ch) {
	    case EOF:
	      goto word;
	    case '\\':
	      ch = scan(sc);
	      if (ch == EOF)
		goto word;
	      DPUTC(&sc->d, ch);
	      break;
	    case '\"':
	      q = !q;
	      break;
	    case SELFDELIM:
	      if (q || (notdelim && strchr(notdelim, ch)))
		goto insert;
	      goto word;
	    default:
	      if (!q && isspace((unsigned char)(ch)))
		goto word;
	    insert:
	      DPUTC(&sc->d, ch);
	      break;
	  }
	  ch = scan(sc);
	}
      word:
	unscan(sc, ch);
	DPUTZ(&sc->d);
	sc->t = CTOK_WORD;
	goto done;
      }
    }
  }

done:
  return (sc->t);
}

/* --- @pushback@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner definition
 *
 * Returns:	---
 *
 * Use:		Pushes the current token back.  This is normally a precursor
 *		to pushing a new scanner source.
 */

static void pushback(scanner *sc)
{
  sc->head->tok = xstrdup(sc->d.buf);
  sc->head->t = sc->t;
}

/* --- @error@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner definition
 *		@const char *msg@ = message skeleton string
 *		@...@ = extra arguments for the skeleton
 *
 * Returns:	Doesn't
 *
 * Use:		Reports an error at the current scanner location.
 */

void error(scanner *sc, const char *msg, ...)
{
  va_list ap;
  va_start(ap, msg);
  fprintf(stderr, "%s: %s:%i: ", QUIS, sc->head->src, sc->head->line);
  vfprintf(stderr, msg, ap);
  fputc('\n', stderr);
  exit(1);
}

/* --- @conf_enum@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to a scanner object
 *		@const char *list@ = comma-separated things to allow
 *		@unsigned f@ = flags for the search
 *		@const char *err@ = error message if not found
 *
 * Returns:	Index into list, zero-based, or @-1@.
 *
 * Use:		Checks whether the current token is a string which matches
 *		one of the comma-separated items given.  If not, an error is
 *		reported; otherwise the index of the matched item is
 *		returned.
 */

int conf_enum(scanner *sc, const char *list, unsigned f, const char *err)
{
  const char *p, *q;
  int chosen = -1;
  int ok;
  int index;

  /* --- Make sure it's a string --- */

  if (sc->t != CTOK_WORD)
    error(sc, "parse error, expected %s", err);

  /* --- Grind through the list --- */

  q = sc->d.buf;
  ok = 1;
  index = 0;
  p = list;
  for (;;) {
    switch (*p) {
      case 0:
	if (ok && !*q) {
	  token(sc);
	  return (index);
	} else if (chosen != -1) {
	  token(sc);
	  return (chosen);
	}
	else if (f & ENUM_NONE)
	  return (-1);
	else
	  error(sc, "unknown %s `%s'", err, sc->d.buf);
	break;
      case ',':
	if (ok && !*q) {
	  token(sc);
	  return (index);
	}
	ok = 1;
	q = sc->d.buf;
	index++;
	break;
      default:
	if (!ok)
	  break;
	if ((f & ENUM_ABBREV) && !*q) {
	  if (chosen != -1)
	    error(sc, "ambiguous %s `%s'", err, sc->d.buf);
	  chosen = index;
	  ok = 0;
	}
	if (*p == *q)
	  q++;
	else
	  ok = 0;
	break;
    }
    p++;
  }
}

/* --- @conf_prefix@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to a scanner object
 *		@const char *p@ = pointer to prefix string to check
 *
 * Returns:	Nonzero if the prefix matches.
 *
 * Use:		If the current token is a word matching the given prefix
 *		string, then it and an optional `.' character are removed and
 *		a nonzero result is returned.  Otherwise the current token is
 *		left as it is, and zero is returned.
 *
 *		Typical options parsing code would remove an expected prefix,
 *		scan an option anyway (since qualifying prefixes are
 *		optional) and if a match is found, claim the option.  If no
 *		match is found, and a prefix was stripped, then an error
 *		should be reported.
 */

int conf_prefix(scanner *sc, const char *p)
{
  if (sc->t == CTOK_WORD && strcmp(p, sc->d.buf) == 0) {
    token(sc);
    if (sc->t == '.')
      token(sc);
    return (1);
  }
  return (0);
}

/* --- @conf_name@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner
 *		@char delim@ = delimiter character to look for
 *		@dstr *d@ = pointer to dynamic string for output
 *
 * Returns:	---
 *
 * Use:		Reads in a compound name consisting of words separated by
 *		delimiters.  Leading and trailing delimiters are permitted,
 *		although they'll probably cause confusion if used.  The name
 *		may be enclosed in square brackets if that helps at all.
 *
 *		Examples of compound names are filenames (delimited by `/')
 *		and IP addresses (delimited by `.').
 */

void conf_name(scanner *sc, char delim, dstr *d)
{
  unsigned f = 0;
  enum {
    f_ok = 1,
    f_bra = 2
  };

  /* --- Read an optional opening bracket --- */

  if (sc->t == '[') {
    token(sc);
    f |= f_bra;
  }

  /* --- Do the main reading sequence --- */

  do {
    if (sc->t == delim) {
      DPUTC(d, delim);
      f |= f_ok;
      token(sc);
    }
    if (sc->t == CTOK_WORD) {
      DPUTD(d, &sc->d);
      f |= f_ok;
      token(sc);
    }
  } while (sc->t == delim);

  /* --- Check that the string was OK --- */

  if (!(f & f_ok))
    error(sc, "parse error, name expected");

  /* --- Read a closing bracket --- */

  if (f & f_bra) {
    if (sc->t == ']')
      token(sc);
    else
      error(sc, "parse error, missing `]'");
  }
  DPUTZ(d);
}

/* --- @conf_parse@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner definition
 *
 * Returns:	---
 *
 * Use:		Parses a configuration file from the scanner.
 */

void conf_parse(scanner *sc)
{
  token(sc);

  for (;;) {
    if (sc->t == CTOK_EOF)
      break;
    if (sc->t != CTOK_WORD)
      error(sc, "parse error, keyword expected");

    /* --- Handle a forwarding request --- */

    if (strcmp(sc->d.buf, "forward") == 0 ||
	strcmp(sc->d.buf, "fw") == 0 ||
        strcmp(sc->d.buf, "from") == 0) {
      source *s;
      target *t;

      token(sc);

      /* --- Read a source description --- */

      {
	source_ops **sops;

	/* --- Try to find a source type which understands --- */

	s = 0;
	for (sops = sources; *sops; sops++) {
	  if ((s = (*sops)->read(sc)) != 0)
	    goto found_source;
	}
	error(sc, "unknown source name `%s'", sc->d.buf);

	/* --- Read any source-specific options --- */

      found_source:
	if (sc->t == '{') {
	  token(sc);
	  while (sc->t == CTOK_WORD) {
	    if (!s->ops->option || !s->ops->option(s, sc)) {
	      error(sc, "unknown %s source option `%s'",
		    s->ops->name, sc->d.buf);
	    }
	    if (sc->t == ';')
	      token(sc);
	  }
	  if (sc->t != '}')
	    error(sc, "parse error, missing `}'");
	  token(sc);
	}
      }

      /* --- Read a destination description --- */

      if (sc->t == CTOK_WORD && (strcmp(sc->d.buf, "to") == 0 ||
				 strcmp(sc->d.buf, "->") == 0))
	token(sc);

      {
	target_ops **tops;

	/* --- Try to find a target which understands --- */

	t = 0;
	for (tops = targets; *tops; tops++) {
	  if ((t = (*tops)->read(sc)) != 0)
	    goto found_target;
	}
	error(sc, "unknown target name `%s'", sc->d.buf);

	/* --- Read any target-specific options --- */

      found_target:
	if (sc->t == '{') {
	  token(sc);
	  while (sc->t == CTOK_WORD) {
	    if (!t->ops->option || !t->ops->option(t, sc)) {
	      error(sc, "unknown %s target option `%s'",
		    t->ops->name, sc->d.buf);
	    }
	    if (sc->t == ';')
	      token(sc);
	  }
	  if (sc->t != '}')
	    error(sc, "parse error, `}' expected");
	  token(sc);
	}
      }

      /* --- Combine the source and target --- */

      s->ops->attach(s, sc, t);
    }

    /* --- Include configuration from a file --- *
     *
     * Slightly tricky.  Scan the optional semicolon from the including
     * stream, not the included one.
     */

    else if (strcmp(sc->d.buf, "include") == 0) {
      FILE *fp;
      dstr d = DSTR_INIT;

      token(sc);
      conf_name(sc, '/', &d);
      if ((fp = fopen(d.buf, "r")) == 0)
	error(sc, "can't include `%s': %s", d.buf, strerror(errno));
      if (sc->t == ';')
	token(sc);
      pushback(sc);
      scan_push(sc, scan_file(fp, xstrdup(d.buf), SCF_FREENAME));
      token(sc);
      dstr_destroy(&d);
      continue;				/* Don't parse a trailing `;' */
    }

    /* --- Other configuration is handled elsewhere --- */

    else {

      /* --- First try among the sources --- */

      {
	source_ops **sops;

	for (sops = sources; *sops; sops++) {
	  if ((*sops)->option && (*sops)->option(0, sc))
	    goto found_option;
	}
      }

      /* --- Then try among the targets --- */

      {
	target_ops **tops;

	for (tops = targets; *tops; tops++) {
	  if ((*tops)->option && (*tops)->option(0, sc))
	    goto found_option;
	}
      }

      /* --- Nobody wants the option --- */

      error(sc, "unknown global option or prefix `%s'", sc->d.buf);

    found_option:;
    }

    if (sc->t == ';')
      token(sc);
  }
}

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