src/stdbuf.c

   1 /* stdbuf -- setup the standard streams for a command
   2    Copyright (C) 2009-2012 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 3 of the License, or
   7    (at your option) 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, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Pádraig Brady.  */
  18
  19 #include <config.h>
  20 #include <stdio.h>
  21 #include <getopt.h>
  22 #include <sys/types.h>
  23 #include <assert.h>
  24
  25 #include "system.h"
  26 #include "error.h"
  27 #include "filenamecat.h"
  28 #include "quote.h"
  29 #include "xreadlink.h"
  30 #include "xstrtol.h"
  31 #include "c-ctype.h"
  32
  33 /* The official name of this program (e.g., no 'g' prefix).  */
  34 #define PROGRAM_NAME "stdbuf"
  35 #define LIB_NAME "libstdbuf.so" /* FIXME: don't hardcode  */
  36
  37 #define AUTHORS proper_name_utf8 ("Padraig Brady", "P\303\241draig Brady")
  38
  39 static char *program_path;
  40
  41 static struct
  42 {
  43   size_t size;
  44   int optc;
  45   char *optarg;
  46 } stdbuf[3];
  47
  48 static struct option const longopts[] =
  49 {
  50   {"input", required_argument, NULL, 'i'},
  51   {"output", required_argument, NULL, 'o'},
  52   {"error", required_argument, NULL, 'e'},
  53   {GETOPT_HELP_OPTION_DECL},
  54   {GETOPT_VERSION_OPTION_DECL},
  55   {NULL, 0, NULL, 0}
  56 };
  57
  58 /* Set size to the value of STR, interpreted as a decimal integer,
  59    optionally multiplied by various values.
  60    Return -1 on error, 0 on success.
  61
  62    This supports dd BLOCK size suffixes.
  63    Note we don't support dd's b=512, c=1, w=2 or 21x512MiB formats.  */
  64 static int
  65 parse_size (char const *str, size_t *size)
  66 {
  67   uintmax_t tmp_size;
  68   enum strtol_error e = xstrtoumax (str, NULL, 10, &tmp_size, "EGkKMPTYZ0");
  69   if (e == LONGINT_OK && tmp_size > SIZE_MAX)
  70     e = LONGINT_OVERFLOW;
  71
  72   if (e == LONGINT_OK)
  73     {
  74       errno = 0;
  75       *size = tmp_size;
  76       return 0;
  77     }
  78
  79   errno = (e == LONGINT_OVERFLOW ? EOVERFLOW : 0);
  80   return -1;
  81 }
  82
  83 void
  84 usage (int status)
  85 {
  86   if (status != EXIT_SUCCESS)
  87     emit_try_help ();
  88   else
  89     {
  90       printf (_("Usage: %s OPTION... COMMAND\n"), program_name);
  91       fputs (_("\
  92 Run COMMAND, with modified buffering operations for its standard streams.\n\
  93 \n\
  94 "), stdout);
  95       fputs (_("\
  96 Mandatory arguments to long options are mandatory for short options too.\n\
  97 "), stdout);
  98       fputs (_("\
  99   -i, --input=MODE   adjust standard input stream buffering\n\
 100   -o, --output=MODE  adjust standard output stream buffering\n\
 101   -e, --error=MODE   adjust standard error stream buffering\n\
 102 "), stdout);
 103       fputs (HELP_OPTION_DESCRIPTION, stdout);
 104       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 105       fputs (_("\n\
 106 If MODE is 'L' the corresponding stream will be line buffered.\n\
 107 This option is invalid with standard input.\n"), stdout);
 108       fputs (_("\n\
 109 If MODE is '0' the corresponding stream will be unbuffered.\n\
 110 "), stdout);
 111       fputs (_("\n\
 112 Otherwise MODE is a number which may be followed by one of the following:\n\
 113 KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
 114 In this case the corresponding stream will be fully buffered with the buffer\n\
 115 size set to MODE bytes.\n\
 116 "), stdout);
 117       fputs (_("\n\
 118 NOTE: If COMMAND adjusts the buffering of its standard streams ('tee' does\n\
 119 for e.g.) then that will override corresponding settings changed by 'stdbuf'.\n\
 120 Also some filters (like 'dd' and 'cat' etc.) don't use streams for I/O,\n\
 121 and are thus unaffected by 'stdbuf' settings.\n\
 122 "), stdout);
 123       emit_ancillary_info ();
 124     }
 125   exit (status);
 126 }
 127
 128 /* argv[0] can be anything really, but generally it contains
 129    the path to the executable or just a name if it was executed
 130    using $PATH. In the latter case to get the path we can:
 131    search getenv("PATH"), readlink("/prof/self/exe"), getenv("_"),
 132    dladdr(), pstat_getpathname(), etc.  */
 133
 134 static void
 135 set_program_path (const char *arg)
 136 {
 137   if (strchr (arg, '/'))        /* Use absolute or relative paths directly.  */
 138     {
 139       program_path = dir_name (arg);
 140     }
 141   else
 142     {
 143       char *path = xreadlink ("/proc/self/exe");
 144       if (path)
 145         program_path = dir_name (path);
 146       else if ((path = getenv ("PATH")))
 147         {
 148           char *dir;
 149           path = xstrdup (path);
 150           for (dir = strtok (path, ":"); dir != NULL; dir = strtok (NULL, ":"))
 151             {
 152               char *candidate = file_name_concat (dir, arg, NULL);
 153               if (access (candidate, X_OK) == 0)
 154                 {
 155                   program_path = dir_name (candidate);
 156                   free (candidate);
 157                   break;
 158                 }
 159               free (candidate);
 160             }
 161         }
 162       free (path);
 163     }
 164 }
 165
 166 static int
 167 optc_to_fileno (int c)
 168 {
 169   int ret = -1;
 170
 171   switch (c)
 172     {
 173     case 'e':
 174       ret = STDERR_FILENO;
 175       break;
 176     case 'i':
 177       ret = STDIN_FILENO;
 178       break;
 179     case 'o':
 180       ret = STDOUT_FILENO;
 181       break;
 182     }
 183
 184   return ret;
 185 }
 186
 187 static void
 188 set_LD_PRELOAD (void)
 189 {
 190   int ret;
 191   char *old_libs = getenv ("LD_PRELOAD");
 192   char *LD_PRELOAD;
 193
 194   /* Note this would auto add the appropriate search path for "libstdbuf.so":
 195      gcc stdbuf.c -Wl,-rpath,'$ORIGIN' -Wl,-rpath,$PKGLIBEXECDIR
 196      However we want the lookup done for the exec'd command not stdbuf.
 197
 198      Since we don't link against libstdbuf.so add it to PKGLIBEXECDIR
 199      rather than to LIBDIR.  */
 200   char const *const search_path[] = {
 201     program_path,
 202     PKGLIBEXECDIR,
 203     NULL
 204   };
 205
 206   char const *const *path = search_path;
 207   char *libstdbuf;
 208
 209   while (true)
 210     {
 211       struct stat sb;
 212
 213       if (!**path)              /* system default  */
 214         {
 215           libstdbuf = xstrdup (LIB_NAME);
 216           break;
 217         }
 218       ret = asprintf (&libstdbuf, "%s/%s", *path, LIB_NAME);
 219       if (ret < 0)
 220         xalloc_die ();
 221       if (stat (libstdbuf, &sb) == 0)   /* file_exists  */
 222         break;
 223       free (libstdbuf);
 224
 225       ++path;
 226       if ( ! *path)
 227         error (EXIT_CANCELED, 0, _("failed to find %s"), quote (LIB_NAME));
 228     }
 229
 230   /* FIXME: Do we need to support libstdbuf.dll, c:, '\' separators etc?  */
 231
 232   if (old_libs)
 233     ret = asprintf (&LD_PRELOAD, "LD_PRELOAD=%s:%s", old_libs, libstdbuf);
 234   else
 235     ret = asprintf (&LD_PRELOAD, "LD_PRELOAD=%s", libstdbuf);
 236
 237   if (ret < 0)
 238     xalloc_die ();
 239
 240   free (libstdbuf);
 241
 242   ret = putenv (LD_PRELOAD);
 243
 244   if (ret != 0)
 245     {
 246       error (EXIT_CANCELED, errno,
 247              _("failed to update the environment with %s"),
 248              quote (LD_PRELOAD));
 249     }
 250 }
 251
 252 /* Populate environ with _STDBUF_I=$MODE _STDBUF_O=$MODE _STDBUF_E=$MODE  */
 253
 254 static void
 255 set_libstdbuf_options (void)
 256 {
 257   unsigned int i;
 258
 259   for (i = 0; i < ARRAY_CARDINALITY (stdbuf); i++)
 260     {
 261       if (stdbuf[i].optarg)
 262         {
 263           char *var;
 264           int ret;
 265
 266           if (*stdbuf[i].optarg == 'L')
 267             ret = asprintf (&var, "%s%c=L", "_STDBUF_",
 268                             toupper (stdbuf[i].optc));
 269           else
 270             ret = asprintf (&var, "%s%c=%" PRIuMAX, "_STDBUF_",
 271                             toupper (stdbuf[i].optc),
 272                             (uintmax_t) stdbuf[i].size);
 273           if (ret < 0)
 274             xalloc_die ();
 275
 276           if (putenv (var) != 0)
 277             {
 278               error (EXIT_CANCELED, errno,
 279                      _("failed to update the environment with %s"),
 280                      quote (var));
 281             }
 282         }
 283     }
 284 }
 285
 286 int
 287 main (int argc, char **argv)
 288 {
 289   int c;
 290
 291   initialize_main (&argc, &argv);
 292   set_program_name (argv[0]);
 293   setlocale (LC_ALL, "");
 294   bindtextdomain (PACKAGE, LOCALEDIR);
 295   textdomain (PACKAGE);
 296
 297   initialize_exit_failure (EXIT_CANCELED);
 298   atexit (close_stdout);
 299
 300   while ((c = getopt_long (argc, argv, "+i:o:e:", longopts, NULL)) != -1)
 301     {
 302       int opt_fileno;
 303
 304       switch (c)
 305         {
 306         /* Old McDonald had a farm ei...  */
 307         case 'e':
 308         case 'i':
 309         case 'o':
 310           opt_fileno = optc_to_fileno (c);
 311           assert (0 <= opt_fileno && opt_fileno < ARRAY_CARDINALITY (stdbuf));
 312           stdbuf[opt_fileno].optc = c;
 313           while (c_isspace (*optarg))
 314             optarg++;
 315           stdbuf[opt_fileno].optarg = optarg;
 316           if (c == 'i' && *optarg == 'L')
 317             {
 318               /* -oL will be by far the most common use of this utility,
 319                  but one could easily think -iL might have the same affect,
 320                  so disallow it as it could be confusing.  */
 321               error (0, 0, _("line buffering stdin is meaningless"));
 322               usage (EXIT_CANCELED);
 323             }
 324
 325           if (!STREQ (optarg, "L")
 326               && parse_size (optarg, &stdbuf[opt_fileno].size) == -1)
 327             error (EXIT_CANCELED, errno, _("invalid mode %s"), quote (optarg));
 328
 329           break;
 330
 331         case_GETOPT_HELP_CHAR;
 332
 333         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 334
 335         default:
 336           usage (EXIT_CANCELED);
 337         }
 338     }
 339
 340   argv += optind;
 341   argc -= optind;
 342
 343   /* must specify at least 1 command.  */
 344   if (argc < 1)
 345     {
 346       error (0, 0, _("missing operand"));
 347       usage (EXIT_CANCELED);
 348     }
 349
 350   /* FIXME: Should we mandate at least one option?  */
 351
 352   set_libstdbuf_options ();
 353
 354   /* Try to preload libstdbuf first from the same path as
 355      stdbuf is running from.  */
 356   set_program_path (program_name);
 357   if (!program_path)
 358     program_path = xstrdup (PKGLIBDIR);  /* Need to init to non NULL.  */
 359   set_LD_PRELOAD ();
 360   free (program_path);
 361
 362   execvp (*argv, argv);
 363
 364   {
 365     int exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 366     error (0, errno, _("failed to run command %s"), quote (argv[0]));
 367     exit (exit_status);
 368   }
 369 }