Remove a fixed bug from the list. Fix some nasty formatting

[fwd] / file.c

/* -*-c-*-
 *
 * $Id: file.c,v 1.1 1999/07/26 23:33:32 mdw Exp $
 *
 * File source and target
 *
 * (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: file.c,v $
 * Revision 1.1  1999/07/26 23:33:32  mdw
 * New sources and targets.
 *
 */

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

#include "config.h"

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

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

#include <mLib/alloc.h>
#include <mLib/dstr.h>
#include <mLib/fdflags.h>
#include <mLib/sub.h>

#include "conf.h"
#include "endpt.h"
#include "fattr.h"
#include "file.h"
#include "fw.h"
#include "reffd.h"
#include "scan.h"
#include "source.h"
#include "target.h"

/*----- Data structures ---------------------------------------------------*/

/* --- File specification --- */

typedef struct fspec {
  unsigned type;
  union {
    reffd *fd;
    char *name;
  } u;
} fspec;

#define FTYPE_GUESS 0u
#define FTYPE_FD 1u
#define FTYPE_NAME 2u
#define FTYPE_NULL 3u

/* --- File options --- */

typedef struct fopts {
  unsigned of;
} fopts;

/* --- File data block --- */

typedef struct fdata {
  fspec in, out;
  fattr fa;
  fopts fo;
} fdata;

/* --- File source block --- */

typedef struct fsource {
  source s;
  fdata f;
} fsource;  

/* --- File target block --- */

typedef struct ftarget {
  target t;
  fdata f;
} ftarget;

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

static fopts file_opts = { O_TRUNC };

static reffd *rstdin, *rstdout;
static reffd *rnull;

/*----- File endpoint operations ------------------------------------------*/

/* --- @wclose@ --- */

static void fept_wclose(endpt *e)
{
  if (e->out) {
    REFFD_DEC(e->out);
    e->out = 0;
  }
}

/* --- @close@ --- */

static void fept_close(endpt *e)
{
  if (e->in)
    REFFD_DEC(e->in);
  if (e->out)
    REFFD_DEC(e->out);
  fw_dec();
  DESTROY(e);
}

/* --- Endpoint operations table --- */

static endpt_ops fept_ops = { 0, fept_wclose, fept_close };

/*----- General operations on sources and targets -------------------------*/

/* --- @file_null@ --- *
 *
 * Arguments:	@void *p@ = an uninteresting argument
 *
 * Returns:	---
 *
 * Use:		Removes the reference to @rnull@ when the file closes.
 */

static void file_null(void *p)
{
  rnull = 0;
}

/* --- @file_nullref@ --- *
 *
 * Arguments:	---
 *
 * Returns:	A reference to a file descriptor open on /dev/null.
 *
 * Use:		Obtains a file descriptor for /dev/null.  The reference
 *		@rnull@ is `weak', so that I only have a descriptor open when
 *		I actually need one.
 */

static reffd *file_nullref(void)
{
  if (rnull)
    REFFD_INC(rnull);
  else {
    int n;
    if ((n = open("/dev/null", O_RDWR)) < 0) {
      fw_log(-1, "couldn't open `/dev/null': %s", strerror(errno));
      return (0);
    }
    fdflags(n, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
    rnull = reffd_init(n);
    reffd_handler(rnull, file_null, 0);
  }
  return (rnull);
}  

/* --- @file_fspec@ --- *
 *
 * Arguments:	@fspec *f@ = pointer to filespec to fill in
 *		@scanner *sc@ = pointer to scanner to read from
 *
 * Returns:	---
 *
 * Use:		Reads in a file spec.
 */

static void file_fspec(fspec *f, scanner *sc)
{
  int c = 0;
  unsigned type = FTYPE_GUESS;
  reffd *fd = 0;

  /* --- Set up references to @stdin@ and @stdout@ --- */

  if (!rstdin) {
    fdflags(STDIN_FILENO, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
    fdflags(STDOUT_FILENO, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
    rstdin = reffd_init(STDIN_FILENO);
    rstdout = reffd_init(STDOUT_FILENO);
  }

  /* --- Try to get an access type --- */

  if (sc->t == ':') {
    c = 1;
    token(sc);
  }

  if (sc->t == CTOK_WORD) {
    int i = conf_enum(sc, "fd,name,null", c ? ENUM_ABBREV : ENUM_NONE,
		      "file access type");
    type = i + 1;
    if (type && sc->t == ':')
      token(sc);
  }

  /* --- Check for a valid file descriptor name --- */

  if (sc->t == CTOK_WORD && type != FTYPE_NAME && type != FTYPE_NULL) {
    if (strcmp(sc->d.buf, "stdin") == 0) {
      fd = rstdin;
      REFFD_INC(rstdin);
    } else if (strcmp(sc->d.buf, "stdout") == 0) {
      fd = rstdout;
      REFFD_INC(rstdout);
    }
    if (fd)
      REFFD_INC(fd);
    else if (isdigit((unsigned char)*sc->d.buf)) {
      int nfd = atoi(sc->d.buf);
      switch (nfd) {
	case STDIN_FILENO: fd = rstdin; REFFD_INC(rstdin); break;
	case STDOUT_FILENO: fd = rstdout; REFFD_INC(rstdout); break;
	default:
	  fd = reffd_init(nfd);
	  fdflags(nfd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
	  break;
      }
    }
  }

  /* --- Sort out what to do as a result --- */

  if (type == FTYPE_NULL)
    f->type = FTYPE_NULL;
  else if (fd) {
    f->type = FTYPE_FD;
    f->u.fd = fd;
    token(sc);  
  } else if (type == FTYPE_FD) {
    if (sc->t == CTOK_WORD)
      error(sc, "bad file descriptor `%s'", sc->d.buf);
    else
      error(sc, "parse error, expected file descriptor");
  } else {
    dstr d = DSTR_INIT;
    conf_name(sc, '/', &d);
    f->type = FTYPE_NAME;
    f->u.name = xstrdup(d.buf);
    dstr_destroy(&d);
  }
}

/* --- @read@ --- */

static void file_read(fdata *f, scanner *sc)
{
  file_fspec(&f->in, sc);
  if (sc->t != ',') {
    f->out = f->in;
    if (f->out.type == FTYPE_FD && f->out.u.fd == rstdin)
      f->out.u.fd = rstdout;
  } else {
    token(sc);
    file_fspec(&f->out, sc);
  }
  f->fa = fattr_global;
  f->fo = file_opts;
}

/* --- @print@ --- */

static void file_pfspec(fspec *f, dstr *d)
{
  switch (f->type) {
    case FTYPE_FD:
      switch (f->u.fd->fd) {
	case STDIN_FILENO:
	  dstr_puts(d, "stdin");
	  break;
	case STDOUT_FILENO:
	  dstr_puts(d, "stdout");
	  break;
	default:
	  dstr_putf(d, "fd:%i", f->u.fd->fd);
	  break;
      }
      break;
    case FTYPE_NAME:
      dstr_putf(d, "name:%s", f->u.name);
      break;
    case FTYPE_NULL:
      dstr_puts(d, "null");
      break;
  }	  
}

static void file_desc(fdata *f, dstr *d)
{
  dstr_puts(d, "file ");
  file_pfspec(&f->in, d);
  dstr_puts(d, ", ");
  file_pfspec(&f->out, d);
}

/* --- @option@ --- */

static int file_option(fdata *f, scanner *sc)
{
  fopts *fo = f ? &f->fo : &file_opts;

  CONF_BEGIN(sc, "file", "file")

  /* --- Handle file-specific options --- */

  if (strcmp(sc->d.buf, "create") == 0) {
    token(sc);
    if (sc->t == '=')
      token(sc);
    switch (conf_enum(sc, "no,yes", ENUM_ABBREV, "create status")) {
      case 0: fo->of &= ~O_CREAT; break;
      case 1: fo->of |= O_CREAT; break;
    }
    CONF_ACCEPT;
  }

  else if (strcmp(sc->d.buf, "open") == 0) {
    token(sc);
    if (sc->t == '=')
      token(sc);
    fo->of &= ~(O_TRUNC | O_APPEND | O_EXCL);
    switch (conf_enum(sc, "no,truncate,append",
		      ENUM_ABBREV, "open status")) {
      case 0: fo->of |= O_EXCL; break;
      case 1: fo->of |= O_TRUNC; break;
      case 2: fo->of |= O_APPEND; break;
    }
    CONF_ACCEPT;
  }

  /* --- See if it's a file attribute --- */

  {
    fattr *fa = f ? &f->fa : &fattr_global;
    if (fattr_option(sc, fa))
      CONF_ACCEPT;
  }

  /* --- Nobody understood it --- */

  CONF_END;
}

/* --- @endpt@ --- */

static endpt *file_endpt(fdata *f, const char *desc)
{
  reffd *in = 0, *out = 0;
  endpt *e;

  /* --- Make the input file first --- */

  switch (f->in.type) {
    case FTYPE_NULL:
      in = file_nullref();
      break;
    case FTYPE_FD:
      in = f->in.u.fd;
      REFFD_INC(in);
      break;
    case FTYPE_NAME: {
      int fd;
      if ((fd = open(f->in.u.name, O_RDONLY | O_NONBLOCK)) < 0) {
	fw_log(-1, "[%s] couldn't open `%s' for reading: %s",
	       desc, f->in.u.name, strerror(errno));
	return (0);
      }
      in = reffd_init(fd);
    } break;
  }

  /* --- Make the output file second --- */

  switch (f->out.type) {
    case FTYPE_NULL:
      out = file_nullref();
      break;
    case FTYPE_FD:
      out = f->out.u.fd;
      REFFD_INC(out);
      break;
    case FTYPE_NAME: {
      int m = f->fo.of | O_WRONLY | O_NONBLOCK;
      int fd = -1;

      /* --- First try creating the file --- *
       *
       * This lets me know whether to set the file attributes or not.  It
       * also stands a chance of noticing people playing silly beggars with
       * dangling symlinks.
       */

      if ((m & O_CREAT) &&
	  (fd = open(f->out.u.name, m | O_EXCL, f->fa.mode)) < 0 &&
	  (errno != EEXIST || (m & O_EXCL))) {
	fw_log(-1, "[%s] couldn't create `%s': %s",
	       desc, f->out.u.name, strerror(errno));
	REFFD_DEC(in);
	return (0);
      }

      if (fd != -1) {
	if (fattr_apply(f->out.u.name, &f->fa)) {
	  fw_log(-1, "[%s] couldn't apply file attributes: %s",
		 desc, f->out.u.name, strerror(errno));
	}
      } else if ((fd = open(f->out.u.name, m & ~O_CREAT)) < 0) {
	fw_log(-1, "[%s] couldn't open `%s': %s",
	       desc, f->out.u.name, strerror(errno));
	REFFD_DEC(in);
	return (0);
      }

      fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
      out = reffd_init(fd);
    } break;
  }

  /* --- Set up the endpoint --- */

  e = CREATE(endpt);
  e->ops = &fept_ops;
  e->other = 0;
  e->f = EPF_FILE;
  e->t = 0;
  e->in = in;
  e->out = out;
  fw_inc();
  return (e);
}

/* --- @destroy@ --- */

static void file_destroy(fdata *f)
{
  if (f->in.type == FTYPE_NAME)
    free(f->in.u.name);
  if (f->out.type == FTYPE_NAME)
    free(f->out.u.name);
}

/*----- File source description -------------------------------------------*/

/* --- @option@ --- */

static int fsource_option(source *s, scanner *sc)
{
  fsource *fs = (fsource *)s;
  return (file_option(fs ? &fs->f : 0, sc));
}

/* --- @read@ --- */

static source *fsource_read(scanner *sc)
{
  fsource *fs;

  if (!conf_prefix(sc, "file"))
    return (0);
  fs = CREATE(fsource);
  fs->s.ops = &fsource_ops;
  fs->s.desc = 0;
  file_read(&fs->f, sc);
  return (&fs->s);
}

/* --- @attach@ --- */

static void fsource_destroy(source */*s*/);

static void fsource_attach(source *s, scanner *sc, target *t)
{
  fsource *fs = (fsource *)s;
  endpt *e, *ee;

  /* --- Set up the source description string --- */

  {
    dstr d = DSTR_INIT;
    file_desc(&fs->f, &d);
    dstr_puts(&d, " -> ");
    dstr_puts(&d, t->desc);
    fs->s.desc = xstrdup(d.buf);
    dstr_destroy(&d);
  }

  /* --- And then create the endpoints --- */

  if ((ee = t->ops->create(t, fs->s.desc)) == 0)
    goto tidy;
  if ((e = file_endpt(&fs->f, fs->s.desc)) == 0) {
    ee->ops->close(ee);
    goto tidy;
  }
  endpt_join(e, ee);

  /* --- Dispose of the source and target now --- */

tidy:
  t->ops->destroy(t);
  fsource_destroy(&fs->s);
}

/* --- @destroy@ --- */

static void fsource_destroy(source *s)
{
  fsource *fs = (fsource *)s;

  /* free(fs->s.desc); */
  file_destroy(&fs->f);
  DESTROY(fs);
}

/* --- File source operations --- */

source_ops fsource_ops = {
  "file",
  fsource_option, fsource_read, fsource_attach, fsource_destroy
};

/*----- File target description -------------------------------------------*/

/* --- @option@ --- */

static int ftarget_option(target *t, scanner *sc)
{
  ftarget *ft = (ftarget *)t;
  return (file_option(ft ? &ft->f : 0, sc));
}

/* --- @read@ --- */

static target *ftarget_read(scanner *sc)
{
  ftarget *ft;
  dstr d = DSTR_INIT;

  if (!conf_prefix(sc, "file"))
    return (0);
  ft = CREATE(ftarget);
  ft->t.ops = &ftarget_ops;
  file_read(&ft->f, sc);
  file_desc(&ft->f, &d);
  ft->t.desc = xstrdup(d.buf);
  dstr_destroy(&d);
  return (&ft->t);
}

/* --- @create@ --- */

static endpt *ftarget_create(target *t, const char *desc)
{
  ftarget *ft = (ftarget *)t;
  endpt *e = file_endpt(&ft->f, desc);
  return (e);
}

/* --- @destroy@ --- */

static void ftarget_destroy(target *t)
{
  ftarget *ft = (ftarget *)t;
  file_destroy(&ft->f);
  /* free(ft->t.desc); */
  DESTROY(ft);
}

/* --- File target operations --- */

target_ops ftarget_ops = {
  "file",
  ftarget_option, ftarget_read, ftarget_create, ftarget_destroy
};

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