src/dircolors.c

   1 /* dircolors - output commands to set the LS_COLOR environment variable
   2    Copyright (C) 1996-2019 Free Software Foundation, Inc.
   3    Copyright (C) 1994, 1995, 1997, 1998, 1999, 2000 H. Peter Anvin
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation, either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19
  20 #include <sys/types.h>
  21 #include <fnmatch.h>
  22 #include <getopt.h>
  23
  24 #include "system.h"
  25 #include "dircolors.h"
  26 #include "c-strcase.h"
  27 #include "die.h"
  28 #include "error.h"
  29 #include "obstack.h"
  30 #include "quote.h"
  31 #include "stdio--.h"
  32 #include "xstrndup.h"
  33
  34 /* The official name of this program (e.g., no 'g' prefix).  */
  35 #define PROGRAM_NAME "dircolors"
  36
  37 #define AUTHORS proper_name ("H. Peter Anvin")
  38
  39 #define obstack_chunk_alloc malloc
  40 #define obstack_chunk_free free
  41
  42 enum Shell_syntax
  43 {
  44   SHELL_SYNTAX_BOURNE,
  45   SHELL_SYNTAX_C,
  46   SHELL_SYNTAX_UNKNOWN
  47 };
  48
  49 #define APPEND_CHAR(C) obstack_1grow (&lsc_obstack, C)
  50 #define APPEND_TWO_CHAR_STRING(S)                                       \
  51   do                                                                    \
  52     {                                                                   \
  53       APPEND_CHAR (S[0]);                                               \
  54       APPEND_CHAR (S[1]);                                               \
  55     }                                                                   \
  56   while (0)
  57
  58 /* Accumulate in this obstack the value for the LS_COLORS environment
  59    variable.  */
  60 static struct obstack lsc_obstack;
  61
  62 static const char *const slack_codes[] =
  63 {
  64   "NORMAL", "NORM", "FILE", "RESET", "DIR", "LNK", "LINK",
  65   "SYMLINK", "ORPHAN", "MISSING", "FIFO", "PIPE", "SOCK", "BLK", "BLOCK",
  66   "CHR", "CHAR", "DOOR", "EXEC", "LEFT", "LEFTCODE", "RIGHT", "RIGHTCODE",
  67   "END", "ENDCODE", "SUID", "SETUID", "SGID", "SETGID", "STICKY",
  68   "OTHER_WRITABLE", "OWR", "STICKY_OTHER_WRITABLE", "OWT", "CAPABILITY",
  69   "MULTIHARDLINK", "CLRTOEOL", NULL
  70 };
  71
  72 static const char *const ls_codes[] =
  73 {
  74   "no", "no", "fi", "rs", "di", "ln", "ln", "ln", "or", "mi", "pi", "pi",
  75   "so", "bd", "bd", "cd", "cd", "do", "ex", "lc", "lc", "rc", "rc", "ec", "ec",
  76   "su", "su", "sg", "sg", "st", "ow", "ow", "tw", "tw", "ca", "mh", "cl", NULL
  77 };
  78 verify (ARRAY_CARDINALITY (slack_codes) == ARRAY_CARDINALITY (ls_codes));
  79
  80 static struct option const long_options[] =
  81   {
  82     {"bourne-shell", no_argument, NULL, 'b'},
  83     {"sh", no_argument, NULL, 'b'},
  84     {"csh", no_argument, NULL, 'c'},
  85     {"c-shell", no_argument, NULL, 'c'},
  86     {"print-database", no_argument, NULL, 'p'},
  87     {GETOPT_HELP_OPTION_DECL},
  88     {GETOPT_VERSION_OPTION_DECL},
  89     {NULL, 0, NULL, 0}
  90   };
  91
  92 void
  93 usage (int status)
  94 {
  95   if (status != EXIT_SUCCESS)
  96     emit_try_help ();
  97   else
  98     {
  99       printf (_("Usage: %s [OPTION]... [FILE]\n"), program_name);
 100       fputs (_("\
 101 Output commands to set the LS_COLORS environment variable.\n\
 102 \n\
 103 Determine format of output:\n\
 104   -b, --sh, --bourne-shell    output Bourne shell code to set LS_COLORS\n\
 105   -c, --csh, --c-shell        output C shell code to set LS_COLORS\n\
 106   -p, --print-database        output defaults\n\
 107 "), stdout);
 108       fputs (HELP_OPTION_DESCRIPTION, stdout);
 109       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 110       fputs (_("\
 111 \n\
 112 If FILE is specified, read it to determine which colors to use for which\n\
 113 file types and extensions.  Otherwise, a precompiled database is used.\n\
 114 For details on the format of these files, run 'dircolors --print-database'.\n\
 115 "), stdout);
 116       emit_ancillary_info (PROGRAM_NAME);
 117     }
 118
 119   exit (status);
 120 }
 121
 122 /* If the SHELL environment variable is set to 'csh' or 'tcsh,'
 123    assume C shell.  Else Bourne shell.  */
 124
 125 static enum Shell_syntax
 126 guess_shell_syntax (void)
 127 {
 128   char *shell;
 129
 130   shell = getenv ("SHELL");
 131   if (shell == NULL || *shell == '\0')
 132     return SHELL_SYNTAX_UNKNOWN;
 133
 134   shell = last_component (shell);
 135
 136   if (STREQ (shell, "csh") || STREQ (shell, "tcsh"))
 137     return SHELL_SYNTAX_C;
 138
 139   return SHELL_SYNTAX_BOURNE;
 140 }
 141
 142 static void
 143 parse_line (char const *line, char **keyword, char **arg)
 144 {
 145   char const *p;
 146   char const *keyword_start;
 147   char const *arg_start;
 148
 149   *keyword = NULL;
 150   *arg = NULL;
 151
 152   for (p = line; isspace (to_uchar (*p)); ++p)
 153     continue;
 154
 155   /* Ignore blank lines and shell-style comments.  */
 156   if (*p == '\0' || *p == '#')
 157     return;
 158
 159   keyword_start = p;
 160
 161   while (!isspace (to_uchar (*p)) && *p != '\0')
 162     {
 163       ++p;
 164     }
 165
 166   *keyword = xstrndup (keyword_start, p - keyword_start);
 167   if (*p  == '\0')
 168     return;
 169
 170   do
 171     {
 172       ++p;
 173     }
 174   while (isspace (to_uchar (*p)));
 175
 176   if (*p == '\0' || *p == '#')
 177     return;
 178
 179   arg_start = p;
 180
 181   while (*p != '\0' && *p != '#')
 182     ++p;
 183
 184   for (--p; isspace (to_uchar (*p)); --p)
 185     continue;
 186   ++p;
 187
 188   *arg = xstrndup (arg_start, p - arg_start);
 189 }
 190
 191 /* FIXME: Write a string to standard out, while watching for "dangerous"
 192    sequences like unescaped : and = characters.  */
 193
 194 static void
 195 append_quoted (const char *str)
 196 {
 197   bool need_backslash = true;
 198
 199   while (*str != '\0')
 200     {
 201       switch (*str)
 202         {
 203         case '\'':
 204           APPEND_CHAR ('\'');
 205           APPEND_CHAR ('\\');
 206           APPEND_CHAR ('\'');
 207           need_backslash = true;
 208           break;
 209
 210         case '\\':
 211         case '^':
 212           need_backslash = !need_backslash;
 213           break;
 214
 215         case ':':
 216         case '=':
 217           if (need_backslash)
 218             APPEND_CHAR ('\\');
 219           FALLTHROUGH;
 220
 221         default:
 222           need_backslash = true;
 223           break;
 224         }
 225
 226       APPEND_CHAR (*str);
 227       ++str;
 228     }
 229 }
 230
 231 /* Read the file open on FP (with name FILENAME).  First, look for a
 232    'TERM name' directive where name matches the current terminal type.
 233    Once found, translate and accumulate the associated directives onto
 234    the global obstack LSC_OBSTACK.  Give a diagnostic
 235    upon failure (unrecognized keyword is the only way to fail here).
 236    Return true if successful.  */
 237
 238 static bool
 239 dc_parse_stream (FILE *fp, const char *filename)
 240 {
 241   size_t line_number = 0;
 242   char const *next_G_line = G_line;
 243   char *input_line = NULL;
 244   size_t input_line_size = 0;
 245   char const *line;
 246   char const *term;
 247   bool ok = true;
 248
 249   /* State for the parser.  */
 250   enum { ST_TERMNO, ST_TERMYES, ST_TERMSURE, ST_GLOBAL } state = ST_GLOBAL;
 251
 252   /* Get terminal type */
 253   term = getenv ("TERM");
 254   if (term == NULL || *term == '\0')
 255     term = "none";
 256
 257   while (1)
 258     {
 259       char *keywd, *arg;
 260       bool unrecognized;
 261
 262       ++line_number;
 263
 264       if (fp)
 265         {
 266           if (getline (&input_line, &input_line_size, fp) <= 0)
 267             {
 268               free (input_line);
 269               break;
 270             }
 271           line = input_line;
 272         }
 273       else
 274         {
 275           if (next_G_line == G_line + sizeof G_line)
 276             break;
 277           line = next_G_line;
 278           next_G_line += strlen (next_G_line) + 1;
 279         }
 280
 281       parse_line (line, &keywd, &arg);
 282
 283       if (keywd == NULL)
 284         continue;
 285
 286       if (arg == NULL)
 287         {
 288           error (0, 0, _("%s:%lu: invalid line;  missing second token"),
 289                  quotef (filename), (unsigned long int) line_number);
 290           ok = false;
 291           free (keywd);
 292           continue;
 293         }
 294
 295       unrecognized = false;
 296       if (c_strcasecmp (keywd, "TERM") == 0)
 297         {
 298           if (fnmatch (arg, term, 0) == 0)
 299             state = ST_TERMSURE;
 300           else if (state != ST_TERMSURE)
 301             state = ST_TERMNO;
 302         }
 303       else
 304         {
 305           if (state == ST_TERMSURE)
 306             state = ST_TERMYES; /* Another TERM can cancel */
 307
 308           if (state != ST_TERMNO)
 309             {
 310               if (keywd[0] == '.')
 311                 {
 312                   APPEND_CHAR ('*');
 313                   append_quoted (keywd);
 314                   APPEND_CHAR ('=');
 315                   append_quoted (arg);
 316                   APPEND_CHAR (':');
 317                 }
 318               else if (keywd[0] == '*')
 319                 {
 320                   append_quoted (keywd);
 321                   APPEND_CHAR ('=');
 322                   append_quoted (arg);
 323                   APPEND_CHAR (':');
 324                 }
 325               else if (c_strcasecmp (keywd, "OPTIONS") == 0
 326                        || c_strcasecmp (keywd, "COLOR") == 0
 327                        || c_strcasecmp (keywd, "EIGHTBIT") == 0)
 328                 {
 329                   /* Ignore.  */
 330                 }
 331               else
 332                 {
 333                   int i;
 334
 335                   for (i = 0; slack_codes[i] != NULL; ++i)
 336                     if (c_strcasecmp (keywd, slack_codes[i]) == 0)
 337                       break;
 338
 339                   if (slack_codes[i] != NULL)
 340                     {
 341                       APPEND_TWO_CHAR_STRING (ls_codes[i]);
 342                       APPEND_CHAR ('=');
 343                       append_quoted (arg);
 344                       APPEND_CHAR (':');
 345                     }
 346                   else
 347                     {
 348                       unrecognized = true;
 349                     }
 350                 }
 351             }
 352           else
 353             {
 354               unrecognized = true;
 355             }
 356         }
 357
 358       if (unrecognized && (state == ST_TERMSURE || state == ST_TERMYES))
 359         {
 360           error (0, 0, _("%s:%lu: unrecognized keyword %s"),
 361                  (filename ? quotef (filename) : _("<internal>")),
 362                  (unsigned long int) line_number, keywd);
 363           ok = false;
 364         }
 365
 366       free (keywd);
 367       free (arg);
 368     }
 369
 370   return ok;
 371 }
 372
 373 static bool
 374 dc_parse_file (const char *filename)
 375 {
 376   bool ok;
 377
 378   if (! STREQ (filename, "-") && freopen (filename, "r", stdin) == NULL)
 379     {
 380       error (0, errno, "%s", quotef (filename));
 381       return false;
 382     }
 383
 384   ok = dc_parse_stream (stdin, filename);
 385
 386   if (fclose (stdin) != 0)
 387     {
 388       error (0, errno, "%s", quotef (filename));
 389       return false;
 390     }
 391
 392   return ok;
 393 }
 394
 395 int
 396 main (int argc, char **argv)
 397 {
 398   bool ok = true;
 399   int optc;
 400   enum Shell_syntax syntax = SHELL_SYNTAX_UNKNOWN;
 401   bool print_database = false;
 402
 403   initialize_main (&argc, &argv);
 404   set_program_name (argv[0]);
 405   setlocale (LC_ALL, "");
 406   bindtextdomain (PACKAGE, LOCALEDIR);
 407   textdomain (PACKAGE);
 408
 409   atexit (close_stdout);
 410
 411   while ((optc = getopt_long (argc, argv, "bcp", long_options, NULL)) != -1)
 412     switch (optc)
 413       {
 414       case 'b': /* Bourne shell syntax.  */
 415         syntax = SHELL_SYNTAX_BOURNE;
 416         break;
 417
 418       case 'c': /* C shell syntax.  */
 419         syntax = SHELL_SYNTAX_C;
 420         break;
 421
 422       case 'p':
 423         print_database = true;
 424         break;
 425
 426       case_GETOPT_HELP_CHAR;
 427
 428       case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 429
 430       default:
 431         usage (EXIT_FAILURE);
 432       }
 433
 434   argc -= optind;
 435   argv += optind;
 436
 437   /* It doesn't make sense to use --print with either of
 438      --bourne or --c-shell.  */
 439   if (print_database && syntax != SHELL_SYNTAX_UNKNOWN)
 440     {
 441       error (0, 0,
 442              _("the options to output dircolors' internal database and\n"
 443                "to select a shell syntax are mutually exclusive"));
 444       usage (EXIT_FAILURE);
 445     }
 446
 447   if ((!print_database) < argc)
 448     {
 449       error (0, 0, _("extra operand %s"), quote (argv[!print_database]));
 450       if (print_database)
 451         fprintf (stderr, "%s\n",
 452                  _("file operands cannot be combined with "
 453                    "--print-database (-p)"));
 454       usage (EXIT_FAILURE);
 455     }
 456
 457   if (print_database)
 458     {
 459       char const *p = G_line;
 460       while (p - G_line < sizeof G_line)
 461         {
 462           puts (p);
 463           p += strlen (p) + 1;
 464         }
 465     }
 466   else
 467     {
 468       /* If shell syntax was not explicitly specified, try to guess it. */
 469       if (syntax == SHELL_SYNTAX_UNKNOWN)
 470         {
 471           syntax = guess_shell_syntax ();
 472           if (syntax == SHELL_SYNTAX_UNKNOWN)
 473             {
 474               die (EXIT_FAILURE, 0,
 475          _("no SHELL environment variable, and no shell type option given"));
 476             }
 477         }
 478
 479       obstack_init (&lsc_obstack);
 480       if (argc == 0)
 481         ok = dc_parse_stream (NULL, NULL);
 482       else
 483         ok = dc_parse_file (argv[0]);
 484
 485       if (ok)
 486         {
 487           size_t len = obstack_object_size (&lsc_obstack);
 488           char *s = obstack_finish (&lsc_obstack);
 489           const char *prefix;
 490           const char *suffix;
 491
 492           if (syntax == SHELL_SYNTAX_BOURNE)
 493             {
 494               prefix = "LS_COLORS='";
 495               suffix = "';\nexport LS_COLORS\n";
 496             }
 497           else
 498             {
 499               prefix = "setenv LS_COLORS '";
 500               suffix = "'\n";
 501             }
 502           fputs (prefix, stdout);
 503           fwrite (s, 1, len, stdout);
 504           fputs (suffix, stdout);
 505         }
 506     }
 507
 508   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 509 }