chiark - git - mdw - fwd/blob - file.c

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