src/stdbuf.c

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