[fwd] / file.c

/* -*-c-*-
 *
 * $Id: file.c,v 1.6 2003/11/29 20:36:07 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.6  2003/11/29 20:36:07  mdw
 * Privileged outgoing connections.
 *
 * Revision 1.5  2002/02/22 23:43:32  mdw
 * Call @xfree@ rather than @free@.
 *
 * Revision 1.4  2001/02/03 20:30:03  mdw
 * Support re-reading config files on SIGHUP.
 *
 * Revision 1.3  1999/12/22 15:43:47  mdw
 * Fix log messages.
 *
 * Revision 1.2  1999/10/22 22:47:13  mdw
 * New (empty) endpoint method required.
 *
 * 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, 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 to `%s': %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)
    xfree(f->in.u.name);
  if (f->out.type == FTYPE_NAME)
    xfree(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;
  xfree(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);
  xfree(ft->t.desc);
  DESTROY(ft);
}

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

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

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
48bb1f76	1	/* --c--
48bb1f76	2	*
ee599f55	3	* $Id: file.c,v 1.6 2003/11/29 20:36:07 mdw Exp $
48bb1f76	4	*
	5	* File source and target
	6	*
	7	* (c) 1999 Straylight/Edgeware
	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of the `fw' port forwarder.
	13	*
	14	* `fw' is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* `fw' is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with `fw'; if not, write to the Free Software Foundation,
	26	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27	*/
	28
	29	/----- Revision history --------------------------------------------------
	30	*
	31	* $Log: file.c,v $
ee599f55	32	* Revision 1.6 2003/11/29 20:36:07 mdw
	33	* Privileged outgoing connections.
	34	*
b0805b27	35	* Revision 1.5 2002/02/22 23:43:32 mdw
	36	* Call @xfree@ rather than @free@.
	37	*
372a98e2	38	* Revision 1.4 2001/02/03 20:30:03 mdw
	39	* Support re-reading config files on SIGHUP.
	40	*
59571fdf	41	* Revision 1.3 1999/12/22 15:43:47 mdw
	42	* Fix log messages.
	43	*
268f6af4	44	* Revision 1.2 1999/10/22 22:47:13 mdw
	45	* New (empty) endpoint method required.
	46	*
48bb1f76	47	* Revision 1.1 1999/07/26 23:33:32 mdw
	48	* New sources and targets.
	49	*
	50	*/
	51
	52	/----- Header files ------------------------------------------------------/
	53
	54	#include "config.h"
	55
	56	#include <ctype.h>
	57	#include <errno.h>
	58	#include <stdio.h>
	59	#include <stdlib.h>
	60	#include <string.h>
	61
	62	#include <sys/types.h>
	63	#include <sys/stat.h>
	64	#include <unistd.h>
	65	#include <fcntl.h>
	66
	67	#include <mLib/alloc.h>
	68	#include <mLib/dstr.h>
	69	#include <mLib/fdflags.h>
	70	#include <mLib/sub.h>
	71
	72	#include "conf.h"
	73	#include "endpt.h"
	74	#include "fattr.h"
	75	#include "file.h"
	76	#include "fw.h"
	77	#include "reffd.h"
	78	#include "scan.h"
	79	#include "source.h"
	80	#include "target.h"
	81
	82	/----- Data structures ---------------------------------------------------/
	83
	84	/* --- File specification --- */
	85
	86	typedef struct fspec {
	87	unsigned type;
	88	union {
	89	reffd *fd;
	90	char *name;
	91	} u;
	92	} fspec;
	93
	94	#define FTYPE_GUESS 0u
	95	#define FTYPE_FD 1u
	96	#define FTYPE_NAME 2u
	97	#define FTYPE_NULL 3u
	98
	99	/* --- File options --- */
	100
	101	typedef struct fopts {
	102	unsigned of;
	103	} fopts;
	104
	105	/* --- File data block --- */
	106
	107	typedef struct fdata {
	108	fspec in, out;
	109	fattr fa;
	110	fopts fo;
111	} fdata;
112
113	/* --- File source block --- */
114
115	typedef struct fsource {
116	source s;
117	fdata f;
118	} fsource;
119
120	/* --- File target block --- */
121
122	typedef struct ftarget {
123	target t;
124	fdata f;
125	} ftarget;
126
127	/----- Static variables --------------------------------------------------/
128
129	static fopts file_opts = { O_TRUNC };
130
131	static reffd rstdin, rstdout;
132	static reffd *rnull;
133
134	/----- File endpoint operations ------------------------------------------/
135
136	/* --- @wclose@ --- */
137
138	static void fept_wclose(endpt *e)
139	{
140	if (e->out) {
141	REFFD_DEC(e->out);
142	e->out = 0;
143	}
144	}
145
146	/* --- @close@ --- */
147
148	static void fept_close(endpt *e)
149	{
150	if (e->in)
151	REFFD_DEC(e->in);
152	if (e->out)
153	REFFD_DEC(e->out);
154	fw_dec();
155	DESTROY(e);
156	}
157
158	/* --- Endpoint operations table --- */
159
268f6af4	160	static endpt_ops fept_ops = { 0, 0, fept_wclose, fept_close };
48bb1f76	161
	162	/----- General operations on sources and targets -------------------------/
	163
	164	/* --- @file_null@ --- *
	165	*
	166	* Arguments: @void *p@ = an uninteresting argument
	167	*
	168	* Returns: ---
	169	*
	170	* Use: Removes the reference to @rnull@ when the file closes.
	171	*/
	172
	173	static void file_null(void *p)
	174	{
	175	rnull = 0;
	176	}
	177
	178	/* --- @file_nullref@ --- *
	179	*
	180	* Arguments: ---
	181	*
	182	* Returns: A reference to a file descriptor open on /dev/null.
	183	*
	184	* Use: Obtains a file descriptor for /dev/null. The reference
	185	* @rnull@ is `weak', so that I only have a descriptor open when
	186	* I actually need one.
	187	*/
	188
	189	static reffd *file_nullref(void)
	190	{
	191	if (rnull)
	192	REFFD_INC(rnull);
	193	else {
	194	int n;
	195	if ((n = open("/dev/null", O_RDWR)) < 0) {
	196	fw_log(-1, "couldn't open `/dev/null': %s", strerror(errno));
	197	return (0);
	198	}
	199	fdflags(n, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
	200	rnull = reffd_init(n);
	201	reffd_handler(rnull, file_null, 0);
	202	}
	203	return (rnull);
	204	}
	205
	206	/* --- @file_fspec@ --- *
	207	*
	208	* Arguments: @fspec *f@ = pointer to filespec to fill in
	209	* @scanner *sc@ = pointer to scanner to read from
	210	*
	211	* Returns: ---
	212	*
	213	* Use: Reads in a file spec.
	214	*/
	215
	216	static void file_fspec(fspec f, scanner sc)
	217	{
	218	int c = 0;
	219	unsigned type = FTYPE_GUESS;
	220	reffd *fd = 0;
	221
	222	/* --- Set up references to @stdin@ and @stdout@ --- */
	223
	224	if (!rstdin) {
225	fdflags(STDIN_FILENO, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
226	fdflags(STDOUT_FILENO, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
227	rstdin = reffd_init(STDIN_FILENO);
228	rstdout = reffd_init(STDOUT_FILENO);
229	}
230
231	/* --- Try to get an access type --- */
232
233	if (sc->t == ':') {
234	c = 1;
235	token(sc);
236	}
237
238	if (sc->t == CTOK_WORD) {
239	int i = conf_enum(sc, "fd,name,null", c ? ENUM_ABBREV : ENUM_NONE,
240	"file access type");
241	type = i + 1;
242	if (type && sc->t == ':')
243	token(sc);
244	}
245
246	/* --- Check for a valid file descriptor name --- */
247
248	if (sc->t == CTOK_WORD && type != FTYPE_NAME && type != FTYPE_NULL) {
249	if (strcmp(sc->d.buf, "stdin") == 0) {
250	fd = rstdin;
251	REFFD_INC(rstdin);
252	} else if (strcmp(sc->d.buf, "stdout") == 0) {
253	fd = rstdout;
254	REFFD_INC(rstdout);
255	}
256	if (fd)
257	REFFD_INC(fd);
258	else if (isdigit((unsigned char)*sc->d.buf)) {
259	int nfd = atoi(sc->d.buf);
260	switch (nfd) {
261	case STDIN_FILENO: fd = rstdin; REFFD_INC(rstdin); break;
262	case STDOUT_FILENO: fd = rstdout; REFFD_INC(rstdout); break;
263	default:
264	fd = reffd_init(nfd);
265	fdflags(nfd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
266	break;
267	}
268	}
269	}
270
271	/* --- Sort out what to do as a result --- */
272
273	if (type == FTYPE_NULL)
274	f->type = FTYPE_NULL;
275	else if (fd) {
276	f->type = FTYPE_FD;
277	f->u.fd = fd;
278	token(sc);
279	} else if (type == FTYPE_FD) {
280	if (sc->t == CTOK_WORD)
281	error(sc, "bad file descriptor `%s'", sc->d.buf);
282	else
283	error(sc, "parse error, expected file descriptor");
284	} else {
285	dstr d = DSTR_INIT;
286	conf_name(sc, '/', &d);
287	f->type = FTYPE_NAME;
288	f->u.name = xstrdup(d.buf);
289	dstr_destroy(&d);
290	}
291	}
292
293	/* --- @read@ --- */
294
295	static void file_read(fdata f, scanner sc)
296	{
297	file_fspec(&f->in, sc);
298	if (sc->t != ',') {
299	f->out = f->in;
300	if (f->out.type == FTYPE_FD && f->out.u.fd == rstdin)
301	f->out.u.fd = rstdout;
302	} else {
303	token(sc);
304	file_fspec(&f->out, sc);
305	}
306	f->fa = fattr_global;
307	f->fo = file_opts;
308	}
309
310	/* --- @print@ --- */
311
312	static void file_pfspec(fspec f, dstr d)
313	{
314	switch (f->type) {
315	case FTYPE_FD:
316	switch (f->u.fd->fd) {
317	case STDIN_FILENO:
318	dstr_puts(d, "stdin");
319	break;
320	case STDOUT_FILENO:
321	dstr_puts(d, "stdout");
322	break;
323	default:
324	dstr_putf(d, "fd:%i", f->u.fd->fd);
325	break;
326	}
327	break;
328	case FTYPE_NAME:
329	dstr_putf(d, "name:%s", f->u.name);
330	break;
331	case FTYPE_NULL:
332	dstr_puts(d, "null");
333	break;
334	}
335	}
336
337	static void file_desc(fdata f, dstr d)
338	{
339	dstr_puts(d, "file ");
340	file_pfspec(&f->in, d);
341	dstr_puts(d, ", ");
342	file_pfspec(&f->out, d);
343	}
344
345	/* --- @option@ --- */
346
347	static int file_option(fdata f, scanner sc)
348	{
349	fopts *fo = f ? &f->fo : &file_opts;
350
351	CONF_BEGIN(sc, "file", "file")
352
353	/* --- Handle file-specific options --- */
354
355	if (strcmp(sc->d.buf, "create") == 0) {
356	token(sc);
357	if (sc->t == '=')
358	token(sc);
359	switch (conf_enum(sc, "no,yes", ENUM_ABBREV, "create status")) {
360	case 0: fo->of &= ~O_CREAT; break;
361	case 1: fo->of \|= O_CREAT; break;
362	}
363	CONF_ACCEPT;
364	}
365
366	else if (strcmp(sc->d.buf, "open") == 0) {
367	token(sc);
368	if (sc->t == '=')
369	token(sc);
370	fo->of &= ~(O_TRUNC \| O_APPEND \| O_EXCL);
371	switch (conf_enum(sc, "no,truncate,append",
372	ENUM_ABBREV, "open status")) {
373	case 0: fo->of \|= O_EXCL; break;
374	case 1: fo->of \|= O_TRUNC; break;
375	case 2: fo->of \|= O_APPEND; break;
376	}
377	CONF_ACCEPT;
378	}
379
380	/* --- See if it's a file attribute --- */
381
382	{
383	fattr *fa = f ? &f->fa : &fattr_global;
384	if (fattr_option(sc, fa))
385	CONF_ACCEPT;
386	}
387
388	/* --- Nobody understood it --- */
389
390	CONF_END;
391	}
392
393	/* --- @endpt@ --- */
394
395	static endpt file_endpt(fdata f, const char *desc)
396	{
397	reffd in = 0, out = 0;
398	endpt *e;
399
400	/* --- Make the input file first --- */
401
402	switch (f->in.type) {
403	case FTYPE_NULL:
404	in = file_nullref();
405	break;
406	case FTYPE_FD:
407	in = f->in.u.fd;
408	REFFD_INC(in);
409	break;
410	case FTYPE_NAME: {
411	int fd;
412	if ((fd = open(f->in.u.name, O_RDONLY \| O_NONBLOCK)) < 0) {
413	fw_log(-1, "[%s] couldn't open `%s' for reading: %s",
414	desc, f->in.u.name, strerror(errno));
415	return (0);
416	}
417	in = reffd_init(fd);
418	} break;
419	}
420
421	/* --- Make the output file second --- */
422
423	switch (f->out.type) {
424	case FTYPE_NULL:
425	out = file_nullref();
426	break;
427	case FTYPE_FD:
428	out = f->out.u.fd;
429	REFFD_INC(out);
430	break;
431	case FTYPE_NAME: {
432	int m = f->fo.of \| O_WRONLY \| O_NONBLOCK;
433	int fd = -1;
434
435	/* --- First try creating the file --- *
436	*
437	* This lets me know whether to set the file attributes or not. It
438	* also stands a chance of noticing people playing silly beggars with
439	* dangling symlinks.
440	*/
441
442	if ((m & O_CREAT) &&
443	(fd = open(f->out.u.name, m \| O_EXCL, f->fa.mode)) < 0 &&
444	(errno != EEXIST \|\| (m & O_EXCL))) {
445	fw_log(-1, "[%s] couldn't create `%s': %s",
446	desc, f->out.u.name, strerror(errno));
447	REFFD_DEC(in);
448	return (0);
449	}
450
451	if (fd != -1) {
452	if (fattr_apply(f->out.u.name, &f->fa)) {
59571fdf	453	fw_log(-1, "[%s] couldn't apply file attributes to `%s': %s",
48bb1f76	454	desc, f->out.u.name, strerror(errno));
	455	}
	456	} else if ((fd = open(f->out.u.name, m & ~O_CREAT)) < 0) {
	457	fw_log(-1, "[%s] couldn't open `%s': %s",
	458	desc, f->out.u.name, strerror(errno));
	459	REFFD_DEC(in);
	460	return (0);
	461	}
	462
	463	fdflags(fd, O_NONBLOCK, O_NONBLOCK, FD_CLOEXEC, FD_CLOEXEC);
	464	out = reffd_init(fd);
	465	} break;
	466	}
	467
	468	/* --- Set up the endpoint --- */
	469
	470	e = CREATE(endpt);
	471	e->ops = &fept_ops;
	472	e->other = 0;
	473	e->f = EPF_FILE;
	474	e->t = 0;
	475	e->in = in;
	476	e->out = out;
	477	fw_inc();
	478	return (e);
	479	}
	480
	481	/* --- @destroy@ --- */
	482
	483	static void file_destroy(fdata *f)
	484	{
	485	if (f->in.type == FTYPE_NAME)
b0805b27	486	xfree(f->in.u.name);
48bb1f76	487	if (f->out.type == FTYPE_NAME)
b0805b27	488	xfree(f->out.u.name);
48bb1f76	489	}
	490
	491	/----- File source description -------------------------------------------/
	492
	493	/* --- @option@ --- */
	494
	495	static int fsource_option(source s, scanner sc)
	496	{
	497	fsource fs = (fsource )s;
	498	return (file_option(fs ? &fs->f : 0, sc));
	499	}
	500
	501	/* --- @read@ --- */
	502
	503	static source fsource_read(scanner sc)
	504	{
	505	fsource *fs;
	506
	507	if (!conf_prefix(sc, "file"))
	508	return (0);
	509	fs = CREATE(fsource);
	510	fs->s.ops = &fsource_ops;
	511	fs->s.desc = 0;
	512	file_read(&fs->f, sc);
	513	return (&fs->s);
	514	}
	515
	516	/* --- @attach@ --- */
	517
	518	static void fsource_destroy(source /s*/);
	519
	520	static void fsource_attach(source s, scanner sc, target *t)
	521	{
	522	fsource fs = (fsource )s;
	523	endpt e, ee;
	524
	525	/* --- Set up the source description string --- */
	526
	527	{
	528	dstr d = DSTR_INIT;
	529	file_desc(&fs->f, &d);
	530	dstr_puts(&d, " -> ");
	531	dstr_puts(&d, t->desc);
	532	fs->s.desc = xstrdup(d.buf);
	533	dstr_destroy(&d);
	534	}
	535
	536	/* --- And then create the endpoints --- */
	537
	538	if ((ee = t->ops->create(t, fs->s.desc)) == 0)
	539	goto tidy;
	540	if ((e = file_endpt(&fs->f, fs->s.desc)) == 0) {
	541	ee->ops->close(ee);
	542	goto tidy;
	543	}
	544	endpt_join(e, ee);
	545
	546	/* --- Dispose of the source and target now --- */
	547
	548	tidy:
	549	t->ops->destroy(t);
	550	fsource_destroy(&fs->s);
	551	}
	552
553	/* --- @destroy@ --- */
554
555	static void fsource_destroy(source *s)
556	{
557	fsource fs = (fsource )s;
b0805b27	558	xfree(fs->s.desc);
48bb1f76	559	file_destroy(&fs->f);
	560	DESTROY(fs);
	561	}
	562
	563	/* --- File source operations --- */
	564
	565	source_ops fsource_ops = {
	566	"file",
	567	fsource_option, fsource_read, fsource_attach, fsource_destroy
	568	};
	569
	570	/----- File target description -------------------------------------------/
	571
	572	/* --- @option@ --- */
	573
	574	static int ftarget_option(target t, scanner sc)
	575	{
	576	ftarget ft = (ftarget )t;
	577	return (file_option(ft ? &ft->f : 0, sc));
	578	}
	579
	580	/* --- @read@ --- */
	581
	582	static target ftarget_read(scanner sc)
	583	{
	584	ftarget *ft;
	585	dstr d = DSTR_INIT;
	586
	587	if (!conf_prefix(sc, "file"))
	588	return (0);
	589	ft = CREATE(ftarget);
	590	ft->t.ops = &ftarget_ops;
	591	file_read(&ft->f, sc);
	592	file_desc(&ft->f, &d);
	593	ft->t.desc = xstrdup(d.buf);
	594	dstr_destroy(&d);
	595	return (&ft->t);
	596	}
	597
	598	/* --- @create@ --- */
	599
	600	static endpt ftarget_create(target t, const char *desc)
	601	{
	602	ftarget ft = (ftarget )t;
	603	endpt *e = file_endpt(&ft->f, desc);
	604	return (e);
	605	}
	606
	607	/* --- @destroy@ --- */
	608
	609	static void ftarget_destroy(target *t)
	610	{
	611	ftarget ft = (ftarget )t;
	612	file_destroy(&ft->f);
b0805b27	613	xfree(ft->t.desc);
48bb1f76	614	DESTROY(ft);
	615	}
	616
	617	/* --- File target operations --- */
	618
	619	target_ops ftarget_ops = {
	620	"file",
ee599f55	621	ftarget_option, ftarget_read, 0, ftarget_create, ftarget_destroy
48bb1f76	622	};
	623
	624	/----- That's all, folks -------------------------------------------------/