chan.c (chan_open): Actually initialize the error indicator.

[fwd] / conf.c

/* -*-c-*-
 *
 * Configuration parsing
 *
 * (c) 1999 Straylight/Edgeware
 */

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

#include "fwd.h"

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

/* --- @conf_undelim@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner definition
 *		@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 conf_undelim(scanner *sc, const char *d, const char *dd)
{
  sc->wbegin = d;
  sc->wcont = 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);
      xfree(sc->head->tok);
      sc->head->tok = 0;
      sc->t = sc->head->t;
      goto done;
    }

    else if (isspace(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 (!sc->wbegin || strchr(sc->wbegin, 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 || (sc->wcont && strchr(sc->wcont, ch)))
		goto insert;
	      goto word;
	    default:
	      if (!q && isspace(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.
 */

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.  The return value is
 *		the index (zero-based) of the matched string in the list.
 *
 *		The flags control the behaviour if no exact match is found.
 *		If @ENUM_ABBREV@ is set, and the current token is a left
 *		substring of exactly one of the possibilities, then that one
 *		is chosen.  If @ENUM_NONE@ is set, the value @-1@ is
 *		returned; otherwise an error is reported and the program is
 *		terminated.
 */

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;

#define f_ok 1u
#define f_bra 2u

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

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

  /* --- 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);

#undef f_ok
#undef f_bra
}

/* --- @conf_fname@ --- *
 *
 * Arguments:	@scanner *sc@ = pointer to scanner
 *		@dstr *d@ = pointer to dynamic string for output
 *
 * Returns:	---
 *
 * Use:		Reads a file name from the input and stores it in @d@.
 */

void conf_fname(scanner *sc, dstr *d)
{
  const char fnchars[] = ".-+";
  conf_undelim(sc, fnchars, fnchars);
  conf_name(sc, '/', d);
  conf_undelim(sc, 0, 0);
}

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