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    Return TRUE if any environment variables set.   */
 253
 254 static bool
 255 set_libstdbuf_options (void)
 256 {
 257   bool env_set = false;
 258   size_t i;
 259
 260   for (i = 0; i < ARRAY_CARDINALITY (stdbuf); i++)
 261     {
 262       if (stdbuf[i].optarg)
 263         {
 264           char *var;
 265           int ret;
 266
 267           if (*stdbuf[i].optarg == 'L')
 268             ret = asprintf (&var, "%s%c=L", "_STDBUF_",
 269                             toupper (stdbuf[i].optc));
 270           else
 271             ret = asprintf (&var, "%s%c=%" PRIuMAX, "_STDBUF_",
 272                             toupper (stdbuf[i].optc),
 273                             (uintmax_t) stdbuf[i].size);
 274           if (ret < 0)
 275             xalloc_die ();
 276
 277           if (putenv (var) != 0)
 278             {
 279               error (EXIT_CANCELED, errno,
 280                      _("failed to update the environment with %s"),
 281                      quote (var));
 282             }
 283
 284           env_set = true;
 285         }
 286     }
 287
 288   return env_set;
 289 }
 290
 291 int
 292 main (int argc, char **argv)
 293 {
 294   int c;
 295
 296   initialize_main (&argc, &argv);
 297   set_program_name (argv[0]);
 298   setlocale (LC_ALL, "");
 299   bindtextdomain (PACKAGE, LOCALEDIR);
 300   textdomain (PACKAGE);
 301
 302   initialize_exit_failure (EXIT_CANCELED);
 303   atexit (close_stdout);
 304
 305   while ((c = getopt_long (argc, argv, "+i:o:e:", longopts, NULL)) != -1)
 306     {
 307       int opt_fileno;
 308
 309       switch (c)
 310         {
 311         /* Old McDonald had a farm ei...  */
 312         case 'e':
 313         case 'i':
 314         case 'o':
 315           opt_fileno = optc_to_fileno (c);
 316           assert (0 <= opt_fileno && opt_fileno < ARRAY_CARDINALITY (stdbuf));
 317           stdbuf[opt_fileno].optc = c;
 318           while (c_isspace (*optarg))
 319             optarg++;
 320           stdbuf[opt_fileno].optarg = optarg;
 321           if (c == 'i' && *optarg == 'L')
 322             {
 323               /* -oL will be by far the most common use of this utility,
 324                  but one could easily think -iL might have the same affect,
 325                  so disallow it as it could be confusing.  */
 326               error (0, 0, _("line buffering stdin is meaningless"));
 327               usage (EXIT_CANCELED);
 328             }
 329
 330           if (!STREQ (optarg, "L")
 331               && parse_size (optarg, &stdbuf[opt_fileno].size) == -1)
 332             error (EXIT_CANCELED, errno, _("invalid mode %s"), quote (optarg));
 333
 334           break;
 335
 336         case_GETOPT_HELP_CHAR;
 337
 338         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 339
 340         default:
 341           usage (EXIT_CANCELED);
 342         }
 343     }
 344
 345   argv += optind;
 346   argc -= optind;
 347
 348   /* must specify at least 1 command.  */
 349   if (argc < 1)
 350     {
 351       error (0, 0, _("missing operand"));
 352       usage (EXIT_CANCELED);
 353     }
 354
 355   if (! set_libstdbuf_options ())
 356     {
 357       error (0, 0, _("you must specify a buffering mode option"));
 358       usage (EXIT_CANCELED);
 359     }
 360
 361   /* Try to preload libstdbuf first from the same path as
 362      stdbuf is running from.  */
 363   set_program_path (program_name);
 364   if (!program_path)
 365     program_path = xstrdup (PKGLIBDIR);  /* Need to init to non NULL.  */
 366   set_LD_PRELOAD ();
 367   free (program_path);
 368
 369   execvp (*argv, argv);
 370
 371   {
 372     int exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 373     error (0, errno, _("failed to run command %s"), quote (argv[0]));
 374     exit (exit_status);
 375   }
 376 }