src/stdbuf.c

   1 /* stdbuf -- setup the standard streams for a command
   2    Copyright (C) 2009-2013 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 "), stdout);
  94
  95       emit_mandatory_arg_note ();
  96
  97       fputs (_("\
  98   -i, --input=MODE   adjust standard input stream buffering\n\
  99   -o, --output=MODE  adjust standard output stream buffering\n\
 100   -e, --error=MODE   adjust standard error stream buffering\n\
 101 "), stdout);
 102       fputs (HELP_OPTION_DESCRIPTION, stdout);
 103       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 104       fputs (_("\n\
 105 If MODE is 'L' the corresponding stream will be line buffered.\n\
 106 This option is invalid with standard input.\n"), stdout);
 107       fputs (_("\n\
 108 If MODE is '0' the corresponding stream will be unbuffered.\n\
 109 "), stdout);
 110       fputs (_("\n\
 111 Otherwise MODE is a number which may be followed by one of the following:\n\
 112 KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
 113 In this case the corresponding stream will be fully buffered with the buffer\n\
 114 size set to MODE bytes.\n\
 115 "), stdout);
 116       fputs (_("\n\
 117 NOTE: If COMMAND adjusts the buffering of its standard streams ('tee' does\n\
 118 for e.g.) then that will override corresponding settings changed by 'stdbuf'.\n\
 119 Also some filters (like 'dd' and 'cat' etc.) don't use streams for I/O,\n\
 120 and are thus unaffected by 'stdbuf' settings.\n\
 121 "), stdout);
 122       emit_ancillary_info ();
 123     }
 124   exit (status);
 125 }
 126
 127 /* argv[0] can be anything really, but generally it contains
 128    the path to the executable or just a name if it was executed
 129    using $PATH. In the latter case to get the path we can:
 130    search getenv("PATH"), readlink("/prof/self/exe"), getenv("_"),
 131    dladdr(), pstat_getpathname(), etc.  */
 132
 133 static void
 134 set_program_path (const char *arg)
 135 {
 136   if (strchr (arg, '/'))        /* Use absolute or relative paths directly.  */
 137     {
 138       program_path = dir_name (arg);
 139     }
 140   else
 141     {
 142       char *path = xreadlink ("/proc/self/exe");
 143       if (path)
 144         program_path = dir_name (path);
 145       else if ((path = getenv ("PATH")))
 146         {
 147           char *dir;
 148           path = xstrdup (path);
 149           for (dir = strtok (path, ":"); dir != NULL; dir = strtok (NULL, ":"))
 150             {
 151               char *candidate = file_name_concat (dir, arg, NULL);
 152               if (access (candidate, X_OK) == 0)
 153                 {
 154                   program_path = dir_name (candidate);
 155                   free (candidate);
 156                   break;
 157                 }
 158               free (candidate);
 159             }
 160         }
 161       free (path);
 162     }
 163 }
 164
 165 static int
 166 optc_to_fileno (int c)
 167 {
 168   int ret = -1;
 169
 170   switch (c)
 171     {
 172     case 'e':
 173       ret = STDERR_FILENO;
 174       break;
 175     case 'i':
 176       ret = STDIN_FILENO;
 177       break;
 178     case 'o':
 179       ret = STDOUT_FILENO;
 180       break;
 181     }
 182
 183   return ret;
 184 }
 185
 186 static void
 187 set_LD_PRELOAD (void)
 188 {
 189   int ret;
 190   char *old_libs = getenv ("LD_PRELOAD");
 191   char *LD_PRELOAD;
 192
 193   /* Note this would auto add the appropriate search path for "libstdbuf.so":
 194      gcc stdbuf.c -Wl,-rpath,'$ORIGIN' -Wl,-rpath,$PKGLIBEXECDIR
 195      However we want the lookup done for the exec'd command not stdbuf.
 196
 197      Since we don't link against libstdbuf.so add it to PKGLIBEXECDIR
 198      rather than to LIBDIR.  */
 199   char const *const search_path[] = {
 200     program_path,
 201     PKGLIBEXECDIR,
 202     NULL
 203   };
 204
 205   char const *const *path = search_path;
 206   char *libstdbuf;
 207
 208   while (true)
 209     {
 210       struct stat sb;
 211
 212       if (!**path)              /* system default  */
 213         {
 214           libstdbuf = xstrdup (LIB_NAME);
 215           break;
 216         }
 217       ret = asprintf (&libstdbuf, "%s/%s", *path, LIB_NAME);
 218       if (ret < 0)
 219         xalloc_die ();
 220       if (stat (libstdbuf, &sb) == 0)   /* file_exists  */
 221         break;
 222       free (libstdbuf);
 223
 224       ++path;
 225       if ( ! *path)
 226         error (EXIT_CANCELED, 0, _("failed to find %s"), quote (LIB_NAME));
 227     }
 228
 229   /* FIXME: Do we need to support libstdbuf.dll, c:, '\' separators etc?  */
 230
 231   if (old_libs)
 232     ret = asprintf (&LD_PRELOAD, "LD_PRELOAD=%s:%s", old_libs, libstdbuf);
 233   else
 234     ret = asprintf (&LD_PRELOAD, "LD_PRELOAD=%s", libstdbuf);
 235
 236   if (ret < 0)
 237     xalloc_die ();
 238
 239   free (libstdbuf);
 240
 241   ret = putenv (LD_PRELOAD);
 242
 243   if (ret != 0)
 244     {
 245       error (EXIT_CANCELED, errno,
 246              _("failed to update the environment with %s"),
 247              quote (LD_PRELOAD));
 248     }
 249 }
 250
 251 /* Populate environ with _STDBUF_I=$MODE _STDBUF_O=$MODE _STDBUF_E=$MODE  */
 252
 253 static void
 254 set_libstdbuf_options (void)
 255 {
 256   unsigned int i;
 257
 258   for (i = 0; i < ARRAY_CARDINALITY (stdbuf); i++)
 259     {
 260       if (stdbuf[i].optarg)
 261         {
 262           char *var;
 263           int ret;
 264
 265           if (*stdbuf[i].optarg == 'L')
 266             ret = asprintf (&var, "%s%c=L", "_STDBUF_",
 267                             toupper (stdbuf[i].optc));
 268           else
 269             ret = asprintf (&var, "%s%c=%" PRIuMAX, "_STDBUF_",
 270                             toupper (stdbuf[i].optc),
 271                             (uintmax_t) stdbuf[i].size);
 272           if (ret < 0)
 273             xalloc_die ();
 274
 275           if (putenv (var) != 0)
 276             {
 277               error (EXIT_CANCELED, errno,
 278                      _("failed to update the environment with %s"),
 279                      quote (var));
 280             }
 281         }
 282     }
 283 }
 284
 285 int
 286 main (int argc, char **argv)
 287 {
 288   int c;
 289
 290   initialize_main (&argc, &argv);
 291   set_program_name (argv[0]);
 292   setlocale (LC_ALL, "");
 293   bindtextdomain (PACKAGE, LOCALEDIR);
 294   textdomain (PACKAGE);
 295
 296   initialize_exit_failure (EXIT_CANCELED);
 297   atexit (close_stdout);
 298
 299   while ((c = getopt_long (argc, argv, "+i:o:e:", longopts, NULL)) != -1)
 300     {
 301       int opt_fileno;
 302
 303       switch (c)
 304         {
 305         /* Old McDonald had a farm ei...  */
 306         case 'e':
 307         case 'i':
 308         case 'o':
 309           opt_fileno = optc_to_fileno (c);
 310           assert (0 <= opt_fileno && opt_fileno < ARRAY_CARDINALITY (stdbuf));
 311           stdbuf[opt_fileno].optc = c;
 312           while (c_isspace (*optarg))
 313             optarg++;
 314           stdbuf[opt_fileno].optarg = optarg;
 315           if (c == 'i' && *optarg == 'L')
 316             {
 317               /* -oL will be by far the most common use of this utility,
 318                  but one could easily think -iL might have the same affect,
 319                  so disallow it as it could be confusing.  */
 320               error (0, 0, _("line buffering stdin is meaningless"));
 321               usage (EXIT_CANCELED);
 322             }
 323
 324           if (!STREQ (optarg, "L")
 325               && parse_size (optarg, &stdbuf[opt_fileno].size) == -1)
 326             error (EXIT_CANCELED, errno, _("invalid mode %s"), quote (optarg));
 327
 328           break;
 329
 330         case_GETOPT_HELP_CHAR;
 331
 332         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 333
 334         default:
 335           usage (EXIT_CANCELED);
 336         }
 337     }
 338
 339   argv += optind;
 340   argc -= optind;
 341
 342   /* must specify at least 1 command.  */
 343   if (argc < 1)
 344     {
 345       error (0, 0, _("missing operand"));
 346       usage (EXIT_CANCELED);
 347     }
 348
 349   /* FIXME: Should we mandate at least one option?  */
 350
 351   set_libstdbuf_options ();
 352
 353   /* Try to preload libstdbuf first from the same path as
 354      stdbuf is running from.  */
 355   set_program_path (program_name);
 356   if (!program_path)
 357     program_path = xstrdup (PKGLIBDIR);  /* Need to init to non NULL.  */
 358   set_LD_PRELOAD ();
 359   free (program_path);
 360
 361   execvp (*argv, argv);
 362
 363   {
 364     int exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 365     error (0, errno, _("failed to run command %s"), quote (argv[0]));
 366     exit (exit_status);
 367   }
 368 }