src/tee.c

   1 /* tee - read from standard input and write to standard output and files.
   2    Copyright (C) 1985, 1990, 1991 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 /* Mike Parker, Richard M. Stallman, and David MacKenzie */
  19
  20 #include <stdio.h>
  21 #include <sys/types.h>
  22 #include <signal.h>
  23 #include <getopt.h>
  24 #include "system.h"
  25
  26 char *xmalloc ();
  27 void error ();
  28 void xwrite ();
  29
  30 static int tee ();
  31
  32 /* If nonzero, append to output files rather than truncating them. */
  33 static int append;
  34
  35 /* If nonzero, ignore interrupts. */
  36 static int ignore_interrupts;
  37
  38 /* The name that this program was run with. */
  39 char *program_name;
  40
  41 static struct option const long_options[] =
  42 {
  43   {"append", 0, NULL, 'a'},
  44   {"ignore-interrupts", 0, NULL, 'i'},
  45   {NULL, 0, NULL, 0}
  46 };
  47
  48 void
  49 main (argc, argv)
  50      int argc;
  51      char **argv;
  52 {
  53   int errs;
  54   int optc;
  55
  56   program_name = argv[0];
  57   append = 0;
  58   ignore_interrupts = 0;
  59
  60   while ((optc = getopt_long (argc, argv, "ai", long_options, (int *) 0))
  61          != EOF)
  62     {
  63       switch (optc)
  64         {
  65         case 'a':
  66           append = 1;
  67           break;
  68         case 'i':
  69           ignore_interrupts = 1;
  70           break;
  71         default:
  72           fprintf (stderr, "\
  73 Usage: %s [-ai] [--append] [--ignore-interrupts] [file...]\n",
  74                    program_name);
  75           exit (1);
  76         }
  77     }
  78
  79   if (ignore_interrupts)
  80 #ifdef _POSIX_VERSION
  81     {
  82       struct sigaction sigact;
  83
  84       sigact.sa_handler = SIG_IGN;
  85       sigemptyset (&sigact.sa_mask);
  86       sigact.sa_flags = 0;
  87       sigaction (SIGINT, &sigact, NULL);
  88     }
  89 #else                           /* !_POSIX_VERSION */
  90     signal (SIGINT, SIG_IGN);
  91 #endif                          /* _POSIX_VERSION */
  92
  93   errs = tee (argc - optind, &argv[optind]);
  94   if (close (0) == -1)
  95     error (1, errno, "standard input");
  96   if (close (1) == -1)
  97     error (1, errno, "standard output");
  98   exit (errs);
  99 }
 100
 101 /* Copy the standard input into each of the NFILES files in FILES
 102    and into the standard output.
 103    Return 0 if successful, 1 if any errors occur. */
 104
 105 static int
 106 tee (nfiles, files)
 107      int nfiles;
 108      char **files;
 109 {
 110   int *descriptors;
 111   char buffer[BUFSIZ];
 112   register int bytes_read, i, ret = 0, mode;
 113
 114   if (nfiles)
 115     descriptors = (int *) xmalloc (nfiles * sizeof (int));
 116   mode = O_WRONLY | O_CREAT;
 117   if (append)
 118     mode |= O_APPEND;
 119   else
 120     mode |= O_TRUNC;
 121
 122   for (i = 0; i < nfiles; i++)
 123     {
 124       descriptors[i] = open (files[i], mode, 0666);
 125       if (descriptors[i] == -1)
 126         {
 127           error (0, errno, "%s", files[i]);
 128           ret = 1;
 129         }
 130     }
 131
 132   while ((bytes_read = read (0, buffer, sizeof buffer)) > 0)
 133     {
 134       xwrite (1, buffer, bytes_read);
 135       for (i = 0; i < nfiles; i++)
 136         if (descriptors[i] != -1)
 137           xwrite (descriptors[i], buffer, bytes_read);
 138     }
 139   if (bytes_read == -1)
 140     {
 141       error (0, errno, "read error");
 142       ret = 1;
 143     }
 144
 145   for (i = 0; i < nfiles; i++)
 146     if (descriptors[i] != -1 && close (descriptors[i]) == -1)
 147       {
 148         error (0, errno, "%s", files[i]);
 149         ret = 1;
 150       }
 151
 152   if (nfiles)
 153     free (descriptors);
 154
 155   return ret;
 156 }