lib/modechange.c

   1 /* modechange.c -- file mode manipulation
   2
   3    Copyright (C) 1989, 1990, 1997, 1998, 1999, 2001, 2003, 2004, 2005,
   4    2006 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 /* Written by David MacKenzie <djm@ai.mit.edu> */
  21
  22 /* The ASCII mode string is compiled into an array of `struct
  23    modechange', which can then be applied to each file to be changed.
  24    We do this instead of re-parsing the ASCII string for each file
  25    because the compiled form requires less computation to use; when
  26    changing the mode of many files, this probably results in a
  27    performance gain.  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include <config.h>
  31 #endif
  32
  33 #include "modechange.h"
  34 #include <sys/stat.h>
  35 #include "stat-macros.h"
  36 #include "xalloc.h"
  37 #include <stdlib.h>
  38
  39 /* The traditional octal values corresponding to each mode bit.  */
  40 #define SUID 04000
  41 #define SGID 02000
  42 #define SVTX 01000
  43 #define RUSR 00400
  44 #define WUSR 00200
  45 #define XUSR 00100
  46 #define RGRP 00040
  47 #define WGRP 00020
  48 #define XGRP 00010
  49 #define ROTH 00004
  50 #define WOTH 00002
  51 #define XOTH 00001
  52 #define ALLM 07777 /* all octal mode bits */
  53
  54 /* Convert OCTAL, which uses one of the traditional octal values, to
  55    an internal mode_t value.  */
  56 static mode_t
  57 octal_to_mode (unsigned int octal)
  58 {
  59   /* Help the compiler optimize the usual case where mode_t uses
  60      the traditional octal representation.  */
  61   return ((S_ISUID == SUID && S_ISGID == SGID && S_ISVTX == SVTX
  62            && S_IRUSR == RUSR && S_IWUSR == WUSR && S_IXUSR == XUSR
  63            && S_IRGRP == RGRP && S_IWGRP == WGRP && S_IXGRP == XGRP
  64            && S_IROTH == ROTH && S_IWOTH == WOTH && S_IXOTH == XOTH)
  65           ? octal
  66           : (mode_t) ((octal & SUID ? S_ISUID : 0)
  67                       | (octal & SGID ? S_ISGID : 0)
  68                       | (octal & SVTX ? S_ISVTX : 0)
  69                       | (octal & RUSR ? S_IRUSR : 0)
  70                       | (octal & WUSR ? S_IWUSR : 0)
  71                       | (octal & XUSR ? S_IXUSR : 0)
  72                       | (octal & RGRP ? S_IRGRP : 0)
  73                       | (octal & WGRP ? S_IWGRP : 0)
  74                       | (octal & XGRP ? S_IXGRP : 0)
  75                       | (octal & ROTH ? S_IROTH : 0)
  76                       | (octal & WOTH ? S_IWOTH : 0)
  77                       | (octal & XOTH ? S_IXOTH : 0)));
  78 }
  79
  80 /* Special operations flags.  */
  81 enum
  82   {
  83     /* For the sentinel at the end of the mode changes array.  */
  84     MODE_DONE,
  85
  86     /* The typical case.  */
  87     MODE_ORDINARY_CHANGE,
  88
  89     /* In addition to the typical case, affect the execute bits if at
  90        least one execute bit is set already, or if the file is a
  91        directory.  */
  92     MODE_X_IF_ANY_X,
  93
  94     /* Instead of the typical case, copy some existing permissions for
  95        u, g, or o onto the other two.  Which of u, g, or o is copied
  96        is determined by which bits are set in the `value' field.  */
  97     MODE_COPY_EXISTING
  98   };
  99
 100 /* Description of a mode change.  */
 101 struct mode_change
 102 {
 103   char op;                      /* One of "=+-".  */
 104   char flag;                    /* Special operations flag.  */
 105   mode_t affected;              /* Set for u, g, o, or a.  */
 106   mode_t value;                 /* Bits to add/remove.  */
 107   mode_t mentioned;             /* Bits explicitly mentioned.  */
 108 };
 109
 110 /* Return a mode_change array with the specified `=ddd'-style
 111    mode change operation, where NEW_MODE is `ddd' and MENTIONED
 112    contains the bits explicitly mentioned in the mode are MENTIONED.  */
 113
 114 static struct mode_change *
 115 make_node_op_equals (mode_t new_mode, mode_t mentioned)
 116 {
 117   struct mode_change *p = xmalloc (2 * sizeof *p);
 118   p->op = '=';
 119   p->flag = MODE_ORDINARY_CHANGE;
 120   p->affected = CHMOD_MODE_BITS;
 121   p->value = new_mode;
 122   p->mentioned = mentioned;
 123   p[1].flag = MODE_DONE;
 124   return p;
 125 }
 126
 127 /* Return a pointer to an array of file mode change operations created from
 128    MODE_STRING, an ASCII string that contains either an octal number
 129    specifying an absolute mode, or symbolic mode change operations with
 130    the form:
 131    [ugoa...][[+-=][rwxXstugo...]...][,...]
 132
 133    Return NULL if `mode_string' does not contain a valid
 134    representation of file mode change operations.  */
 135
 136 struct mode_change *
 137 mode_compile (char const *mode_string)
 138 {
 139   /* The array of mode-change directives to be returned.  */
 140   struct mode_change *mc;
 141   size_t used = 0;
 142
 143   if ('0' <= *mode_string && *mode_string < '8')
 144     {
 145       unsigned int octal_mode = 0;
 146       unsigned int octal_mentioned = 0;
 147
 148       do
 149         {
 150           octal_mode = 8 * octal_mode + *mode_string++ - '0';
 151           octal_mentioned = 8 * octal_mentioned + 7;
 152           if (ALLM < octal_mode)
 153             return NULL;
 154         }
 155       while ('0' <= *mode_string && *mode_string < '8');
 156
 157       if (*mode_string)
 158         return NULL;
 159
 160       return make_node_op_equals (octal_to_mode (octal_mode),
 161                                   octal_to_mode (octal_mentioned & ALLM));
 162     }
 163
 164   /* Allocate enough space to hold the result.  */
 165   {
 166     size_t needed = 1;
 167     char const *p;
 168     for (p = mode_string; *p; p++)
 169       needed += (*p == '=' || *p == '+' || *p == '-');
 170     mc = xnmalloc (needed, sizeof *mc);
 171   }
 172
 173   /* One loop iteration for each `[ugoa]*([-+=]([rwxXst]*|[ugo]))+'.  */
 174   for (;; mode_string++)
 175     {
 176       /* Which bits in the mode are operated on.  */
 177       mode_t affected = 0;
 178
 179       /* Turn on all the bits in `affected' for each group given.  */
 180       for (;; mode_string++)
 181         switch (*mode_string)
 182           {
 183           default:
 184             goto invalid;
 185           case 'u':
 186             affected |= S_ISUID | S_IRWXU;
 187             break;
 188           case 'g':
 189             affected |= S_ISGID | S_IRWXG;
 190             break;
 191           case 'o':
 192             affected |= S_ISVTX | S_IRWXO;
 193             break;
 194           case 'a':
 195             affected |= CHMOD_MODE_BITS;
 196             break;
 197           case '=': case '+': case '-':
 198             goto no_more_affected;
 199           }
 200     no_more_affected:;
 201
 202       do
 203         {
 204           char op = *mode_string++;
 205           mode_t value;
 206           char flag = MODE_COPY_EXISTING;
 207           struct mode_change *change;
 208
 209           switch (*mode_string++)
 210             {
 211             case 'u':
 212               /* Set the affected bits to the value of the `u' bits
 213                  on the same file.  */
 214               value = S_IRWXU;
 215               break;
 216             case 'g':
 217               /* Set the affected bits to the value of the `g' bits
 218                  on the same file.  */
 219               value = S_IRWXG;
 220               break;
 221             case 'o':
 222               /* Set the affected bits to the value of the `o' bits
 223                  on the same file.  */
 224               value = S_IRWXO;
 225               break;
 226
 227             default:
 228               value = 0;
 229               flag = MODE_ORDINARY_CHANGE;
 230
 231               for (mode_string--;; mode_string++)
 232                 switch (*mode_string)
 233                   {
 234                   case 'r':
 235                     value |= S_IRUSR | S_IRGRP | S_IROTH;
 236                     break;
 237                   case 'w':
 238                     value |= S_IWUSR | S_IWGRP | S_IWOTH;
 239                     break;
 240                   case 'x':
 241                     value |= S_IXUSR | S_IXGRP | S_IXOTH;
 242                     break;
 243                   case 'X':
 244                     flag = MODE_X_IF_ANY_X;
 245                     break;
 246                   case 's':
 247                     /* Set the setuid/gid bits if `u' or `g' is selected.  */
 248                     value |= S_ISUID | S_ISGID;
 249                     break;
 250                   case 't':
 251                     /* Set the "save text image" bit if `o' is selected.  */
 252                     value |= S_ISVTX;
 253                     break;
 254                   default:
 255                     goto no_more_values;
 256                   }
 257             no_more_values:;
 258             }
 259
 260           change = &mc[used++];
 261           change->op = op;
 262           change->flag = flag;
 263           change->affected = affected;
 264           change->value = value;
 265           change->mentioned = (affected ? affected & value : value);
 266         }
 267       while (*mode_string == '=' || *mode_string == '+'
 268              || *mode_string == '-');
 269
 270       if (*mode_string != ',')
 271         break;
 272     }
 273
 274   if (*mode_string == 0)
 275     {
 276       mc[used].flag = MODE_DONE;
 277       return mc;
 278     }
 279
 280 invalid:
 281   free (mc);
 282   return NULL;
 283 }
 284
 285 /* Return a file mode change operation that sets permissions to match those
 286    of REF_FILE.  Return NULL (setting errno) if REF_FILE can't be accessed.  */
 287
 288 struct mode_change *
 289 mode_create_from_ref (const char *ref_file)
 290 {
 291   struct stat ref_stats;
 292
 293   if (stat (ref_file, &ref_stats) != 0)
 294     return NULL;
 295   return make_node_op_equals (ref_stats.st_mode, CHMOD_MODE_BITS);
 296 }
 297
 298 /* Return the file mode bits of OLDMODE (which is the mode of a
 299    directory if DIR), assuming the umask is UMASK_VALUE, adjusted as
 300    indicated by the list of change operations CHANGES.  If DIR, the
 301    type 'X' change affects the returned value even if no execute bits
 302    were set in OLDMODE.  If PMODE_BITS is not null, store into
 303    *PMODE_BITS a mask denoting file mode bits that are affected by
 304    CHANGES.
 305
 306    The returned value and *PMODE_BITS contain only file mode bits.
 307    For example, they have the S_IFMT bits cleared on a standard
 308    Unix-like host.  */
 309
 310 mode_t
 311 mode_adjust (mode_t oldmode, bool dir, mode_t umask_value,
 312              struct mode_change const *changes, mode_t *pmode_bits)
 313 {
 314   /* The adjusted mode.  */
 315   mode_t newmode = oldmode & CHMOD_MODE_BITS;
 316
 317   /* File mode bits that CHANGES cares about.  */
 318   mode_t mode_bits = 0;
 319
 320   for (; changes->flag != MODE_DONE; changes++)
 321     {
 322       mode_t affected = changes->affected;
 323       mode_t omit_change =
 324         (dir ? S_ISUID | S_ISGID : 0) & ~ changes->mentioned;
 325       mode_t value = changes->value;
 326
 327       switch (changes->flag)
 328         {
 329         case MODE_ORDINARY_CHANGE:
 330           break;
 331
 332         case MODE_COPY_EXISTING:
 333           /* Isolate in `value' the bits in `newmode' to copy.  */
 334           value &= newmode;
 335
 336           /* Copy the isolated bits to the other two parts.  */
 337           value |= ((value & (S_IRUSR | S_IRGRP | S_IROTH)
 338                      ? S_IRUSR | S_IRGRP | S_IROTH : 0)
 339                     | (value & (S_IWUSR | S_IWGRP | S_IWOTH)
 340                        ? S_IWUSR | S_IWGRP | S_IWOTH : 0)
 341                     | (value & (S_IXUSR | S_IXGRP | S_IXOTH)
 342                        ? S_IXUSR | S_IXGRP | S_IXOTH : 0));
 343           break;
 344
 345         case MODE_X_IF_ANY_X:
 346           /* Affect the execute bits if execute bits are already set
 347              or if the file is a directory.  */
 348           if ((newmode & (S_IXUSR | S_IXGRP | S_IXOTH)) | dir)
 349             value |= S_IXUSR | S_IXGRP | S_IXOTH;
 350           break;
 351         }
 352
 353       /* If WHO was specified, limit the change to the affected bits.
 354          Otherwise, apply the umask.  Either way, omit changes as
 355          requested.  */
 356       value &= (affected ? affected : ~umask_value) & ~ omit_change;
 357
 358       switch (changes->op)
 359         {
 360         case '=':
 361           /* If WHO was specified, preserve the previous values of
 362              bits that are not affected by this change operation.
 363              Otherwise, clear all the bits.  */
 364           {
 365             mode_t preserved = (affected ? ~affected : 0) | omit_change;
 366             mode_bits |= CHMOD_MODE_BITS & ~preserved;
 367             newmode = (newmode & preserved) | value;
 368             break;
 369           }
 370
 371         case '+':
 372           mode_bits |= value;
 373           newmode |= value;
 374           break;
 375
 376         case '-':
 377           mode_bits |= value;
 378           newmode &= ~value;
 379           break;
 380         }
 381     }
 382
 383   if (pmode_bits)
 384     *pmode_bits = mode_bits;
 385   return newmode;
 386 }