/* modechange.c -- file mode manipulation
- Copyright (C) 1989, 1990 Free Software Foundation, Inc.
+
+ Copyright (C) 1989, 1990, 1997, 1998, 1999, 2001, 2003, 2004, 2005
+ Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* Written by David MacKenzie <djm@ai.mit.edu> */
-/* The ASCII mode string is compiled into a linked list of `struct
+/* The ASCII mode string is compiled into an array of `struct
modechange', which can then be applied to each file to be changed.
We do this instead of re-parsing the ASCII string for each file
because the compiled form requires less computation to use; when
changing the mode of many files, this probably results in a
- performance gain. */
+ performance gain. */
-#ifdef HAVE_CONFIG_H
-#include <config.h>
+#if HAVE_CONFIG_H
+# include <config.h>
#endif
-#include <sys/types.h>
-#include <sys/stat.h>
#include "modechange.h"
-
-#ifdef STDC_HEADERS
+#include <sys/stat.h>
+#include "stat-macros.h"
+#include "xalloc.h"
#include <stdlib.h>
-#else
-char *malloc ();
-#endif
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifdef STAT_MACROS_BROKEN
-#undef S_ISDIR
-#endif /* STAT_MACROS_BROKEN. */
-#if !defined(S_ISDIR) && defined(S_IFDIR)
-#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
-#endif
-
-/* Return newly allocated memory to hold one element of type TYPE. */
-#define talloc(type) ((type *) malloc (sizeof (type)))
+/* The traditional octal values corresponding to each mode bit. */
+#define SUID 04000
+#define SGID 02000
+#define SVTX 01000
+#define RUSR 00400
+#define WUSR 00200
+#define XUSR 00100
+#define RGRP 00040
+#define WGRP 00020
+#define XGRP 00010
+#define ROTH 00004
+#define WOTH 00002
+#define XOTH 00001
+#define ALLM 07777 /* all octal mode bits */
+
+/* Special operations flags. */
+enum
+ {
+ /* For the sentinel at the end of the mode changes array. */
+ MODE_DONE,
+
+ /* The typical case. */
+ MODE_ORDINARY_CHANGE,
+
+ /* In addition to the typical case, affect the execute bits if at
+ least one execute bit is set already, or if the file is a
+ directory. */
+ MODE_X_IF_ANY_X,
+
+ /* Instead of the typical case, copy some existing permissions for
+ u, g, or o onto the other two. Which of u, g, or o is copied
+ is determined by which bits are set in the `value' field. */
+ MODE_COPY_EXISTING
+ };
+
+/* Description of a mode change. */
+struct mode_change
+{
+ char op; /* One of "=+-". */
+ char flag; /* Special operations flag. */
+ mode_t affected; /* Set for u, g, o, or a. */
+ mode_t value; /* Bits to add/remove. */
+};
-#define isodigit(c) ((c) >= '0' && (c) <= '7')
+/* Return a mode_change array with the specified `=ddd'-style
+ mode change operation, where NEW_MODE is `ddd'. */
-static int oatoi ();
+static struct mode_change *
+make_node_op_equals (mode_t new_mode)
+{
+ struct mode_change *p = xmalloc (2 * sizeof *p);
+ p->op = '=';
+ p->flag = MODE_ORDINARY_CHANGE;
+ p->affected = CHMOD_MODE_BITS;
+ p->value = new_mode;
+ p[1].flag = MODE_DONE;
+ return p;
+}
-/* Return a linked list of file mode change operations created from
+/* Return a pointer to an array of file mode change operations created from
MODE_STRING, an ASCII string that contains either an octal number
specifying an absolute mode, or symbolic mode change operations with
the form:
[ugoa...][[+-=][rwxXstugo...]...][,...]
- MASKED_OPS is a bitmask indicating which symbolic mode operators (=+-)
- should not affect bits set in the umask when no users are given.
- Operators not selected in MASKED_OPS ignore the umask.
- Return MODE_INVALID if `mode_string' does not contain a valid
- representation of file mode change operations;
- return MODE_MEMORY_EXHAUSTED if there is insufficient memory. */
+ Return NULL if `mode_string' does not contain a valid
+ representation of file mode change operations. */
struct mode_change *
-mode_compile (mode_string, masked_ops)
- const char *mode_string;
- unsigned masked_ops;
+mode_compile (char const *mode_string)
{
- struct mode_change *head; /* First element of the linked list. */
- struct mode_change *change; /* An element of the linked list. */
- int i; /* General purpose temporary. */
- int umask_value; /* The umask value (surprise). */
- unsigned short affected_bits; /* Which bits in the mode are operated on. */
- unsigned short affected_masked; /* `affected_bits' modified by umask. */
- unsigned ops_to_mask; /* Operators to actually use umask on. */
-
- i = oatoi (mode_string);
- if (i >= 0)
- {
- if (i > 07777)
- return MODE_INVALID;
- head = talloc (struct mode_change);
- if (head == NULL)
- return MODE_MEMORY_EXHAUSTED;
- head->next = NULL;
- head->op = '=';
- head->flags = 0;
- head->value = i;
- head->affected = 07777; /* Affect all permissions. */
- return head;
- }
+ /* The array of mode-change directives to be returned. */
+ struct mode_change *mc;
+ size_t used = 0;
- umask_value = umask (0);
- umask (umask_value); /* Restore the old value. */
+ if ('0' <= *mode_string && *mode_string < '8')
+ {
+ mode_t mode;
+ unsigned int octal_value = 0;
- head = NULL;
-#ifdef lint
- change = NULL;
-#endif
- --mode_string;
+ do
+ {
+ octal_value = 8 * octal_value + *mode_string++ - '0';
+ if (ALLM < octal_value)
+ return NULL;
+ }
+ while ('0' <= *mode_string && *mode_string < '8');
+
+ /* Help the compiler optimize the usual case where mode_t uses
+ the traditional octal representation. */
+ mode = ((S_ISUID == SUID && S_ISGID == SGID && S_ISVTX == SVTX
+ && S_IRUSR == RUSR && S_IWUSR == WUSR && S_IXUSR == XUSR
+ && S_IRGRP == RGRP && S_IWGRP == WGRP && S_IXGRP == XGRP
+ && S_IROTH == ROTH && S_IWOTH == WOTH && S_IXOTH == XOTH)
+ ? octal_value
+ : (mode_t) ((octal_value & SUID ? S_ISUID : 0)
+ | (octal_value & SGID ? S_ISGID : 0)
+ | (octal_value & SVTX ? S_ISVTX : 0)
+ | (octal_value & RUSR ? S_IRUSR : 0)
+ | (octal_value & WUSR ? S_IWUSR : 0)
+ | (octal_value & XUSR ? S_IXUSR : 0)
+ | (octal_value & RGRP ? S_IRGRP : 0)
+ | (octal_value & WGRP ? S_IWGRP : 0)
+ | (octal_value & XGRP ? S_IXGRP : 0)
+ | (octal_value & ROTH ? S_IROTH : 0)
+ | (octal_value & WOTH ? S_IWOTH : 0)
+ | (octal_value & XOTH ? S_IXOTH : 0)));
+
+ return make_node_op_equals (mode);
+ }
- /* One loop iteration for each "ugoa...=+-rwxXstugo...[=+-rwxXstugo...]". */
- do
+ /* Allocate enough space to hold the result. */
+ {
+ size_t needed = 1;
+ char const *p;
+ for (p = mode_string; *p; p++)
+ needed += (*p == '=' || *p == '+' || *p == '-');
+ mc = xnmalloc (needed, sizeof *mc);
+ }
+
+ /* One loop iteration for each `[ugoa]*([-+=]([rwxXst]*|[ugo]))+'. */
+ for (;; mode_string++)
{
- affected_bits = 0;
- ops_to_mask = 0;
- /* Turn on all the bits in `affected_bits' for each group given. */
- for (++mode_string;; ++mode_string)
+ /* Which bits in the mode are operated on. */
+ mode_t affected = 0;
+
+ /* Turn on all the bits in `affected' for each group given. */
+ for (;; mode_string++)
switch (*mode_string)
{
+ default:
+ goto invalid;
case 'u':
- affected_bits |= 04700;
+ affected |= S_ISUID | S_IRWXU;
break;
case 'g':
- affected_bits |= 02070;
+ affected |= S_ISGID | S_IRWXG;
break;
case 'o':
- affected_bits |= 01007;
+ affected |= S_ISVTX | S_IRWXO;
break;
case 'a':
- affected_bits |= 07777;
+ affected |= CHMOD_MODE_BITS;
break;
- default:
+ case '=': case '+': case '-':
goto no_more_affected;
}
+ no_more_affected:;
- no_more_affected:
- /* If none specified, affect all bits, except perhaps those
- set in the umask. */
- if (affected_bits == 0)
+ do
{
- affected_bits = 07777;
- ops_to_mask = masked_ops;
- }
+ char op = *mode_string++;
+ mode_t value;
+ char flag = MODE_COPY_EXISTING;
+ struct mode_change *change;
- while (*mode_string == '=' || *mode_string == '+' || *mode_string == '-')
- {
- /* Add the element to the tail of the list, so the operations
- are performed in the correct order. */
- if (head == NULL)
- {
- head = talloc (struct mode_change);
- if (head == NULL)
- return MODE_MEMORY_EXHAUSTED;
- change = head;
- }
- else
+ switch (*mode_string++)
{
- change->next = talloc (struct mode_change);
- if (change->next == NULL)
- {
- mode_free (change);
- return MODE_MEMORY_EXHAUSTED;
- }
- change = change->next;
+ case 'u':
+ /* Set the affected bits to the value of the `u' bits
+ on the same file. */
+ value = S_IRWXU;
+ break;
+ case 'g':
+ /* Set the affected bits to the value of the `g' bits
+ on the same file. */
+ value = S_IRWXG;
+ break;
+ case 'o':
+ /* Set the affected bits to the value of the `o' bits
+ on the same file. */
+ value = S_IRWXO;
+ break;
+
+ default:
+ value = 0;
+ flag = MODE_ORDINARY_CHANGE;
+
+ for (mode_string--;; mode_string++)
+ switch (*mode_string)
+ {
+ case 'r':
+ value |= S_IRUSR | S_IRGRP | S_IROTH;
+ break;
+ case 'w':
+ value |= S_IWUSR | S_IWGRP | S_IWOTH;
+ break;
+ case 'x':
+ value |= S_IXUSR | S_IXGRP | S_IXOTH;
+ break;
+ case 'X':
+ flag = MODE_X_IF_ANY_X;
+ break;
+ case 's':
+ /* Set the setuid/gid bits if `u' or `g' is selected. */
+ value |= S_ISUID | S_ISGID;
+ break;
+ case 't':
+ /* Set the "save text image" bit if `o' is selected. */
+ value |= S_ISVTX;
+ break;
+ default:
+ goto no_more_values;
+ }
+ no_more_values:;
}
- change->next = NULL;
- change->op = *mode_string; /* One of "=+-". */
- affected_masked = affected_bits;
- if (ops_to_mask & (*mode_string == '=' ? MODE_MASK_EQUALS
- : *mode_string == '+' ? MODE_MASK_PLUS
- : MODE_MASK_MINUS))
- affected_masked &= ~umask_value;
- change->affected = affected_masked;
- change->value = 0;
- change->flags = 0;
-
- /* Set `value' according to the bits set in `affected_masked'. */
- for (++mode_string;; ++mode_string)
- switch (*mode_string)
- {
- case 'r':
- change->value |= 00444 & affected_masked;
- break;
- case 'w':
- change->value |= 00222 & affected_masked;
- break;
- case 'X':
- change->flags |= MODE_X_IF_ANY_X;
- /* Fall through. */
- case 'x':
- change->value |= 00111 & affected_masked;
- break;
- case 's':
- /* Set the setuid/gid bits if `u' or `g' is selected. */
- change->value |= 06000 & affected_masked;
- break;
- case 't':
- /* Set the "save text image" bit if `o' is selected. */
- change->value |= 01000 & affected_masked;
- break;
- case 'u':
- /* Set the affected bits to the value of the `u' bits
- on the same file. */
- if (change->value)
- goto invalid;
- change->value = 00700;
- change->flags |= MODE_COPY_EXISTING;
- break;
- case 'g':
- /* Set the affected bits to the value of the `g' bits
- on the same file. */
- if (change->value)
- goto invalid;
- change->value = 00070;
- change->flags |= MODE_COPY_EXISTING;
- break;
- case 'o':
- /* Set the affected bits to the value of the `o' bits
- on the same file. */
- if (change->value)
- goto invalid;
- change->value = 00007;
- change->flags |= MODE_COPY_EXISTING;
- break;
- default:
- goto no_more_values;
- }
- no_more_values:;
+ change = &mc[used++];
+ change->op = op;
+ change->flag = flag;
+ change->affected = affected;
+ change->value = value;
}
- } while (*mode_string == ',');
+ while (*mode_string == '=' || *mode_string == '+'
+ || *mode_string == '-');
+
+ if (*mode_string != ',')
+ break;
+ }
+
if (*mode_string == 0)
- return head;
+ {
+ mc[used].flag = MODE_DONE;
+ return mc;
+ }
+
invalid:
- mode_free (head);
- return MODE_INVALID;
+ free (mc);
+ return NULL;
+}
+
+/* Return a file mode change operation that sets permissions to match those
+ of REF_FILE. Return NULL (setting errno) if REF_FILE can't be accessed. */
+
+struct mode_change *
+mode_create_from_ref (const char *ref_file)
+{
+ struct stat ref_stats;
+
+ if (stat (ref_file, &ref_stats) != 0)
+ return NULL;
+ return make_node_op_equals (ref_stats.st_mode);
}
/* Return file mode OLDMODE, adjusted as indicated by the list of change
- operations CHANGES. If OLDMODE is a directory, the type `X'
+ operations CHANGES, which are interpreted assuming the umask is
+ UMASK_VALUE. If OLDMODE is a directory, the type `X'
change affects it even if no execute bits were set in OLDMODE.
- The returned value has the S_IFMT bits cleared. */
+ The returned value has the S_IFMT bits cleared. */
-unsigned short
-mode_adjust (oldmode, changes)
- unsigned oldmode;
- const struct mode_change *changes;
+mode_t
+mode_adjust (mode_t oldmode, struct mode_change const *changes,
+ mode_t umask_value)
{
- unsigned short newmode; /* The adjusted mode and one operand. */
- unsigned short value; /* The other operand. */
-
- newmode = oldmode & 07777;
+ /* The adjusted mode. */
+ mode_t newmode = oldmode & CHMOD_MODE_BITS;
- for (; changes; changes = changes->next)
+ for (; changes->flag != MODE_DONE; changes++)
{
- if (changes->flags & MODE_COPY_EXISTING)
- {
- /* Isolate in `value' the bits in `newmode' to copy, given in
- the mask `changes->value'. */
- value = newmode & changes->value;
-
- if (changes->value & 00700)
- /* Copy `u' permissions onto `g' and `o'. */
- value |= (value >> 3) | (value >> 6);
- else if (changes->value & 00070)
- /* Copy `g' permissions onto `u' and `o'. */
- value |= (value << 3) | (value >> 3);
- else
- /* Copy `o' permissions onto `u' and `g'. */
- value |= (value << 3) | (value << 6);
-
- /* In order to change only `u', `g', or `o' permissions,
- or some combination thereof, clear unselected bits.
- This can not be done in mode_compile because the value
- to which the `changes->affected' mask is applied depends
- on the old mode of each file. */
- value &= changes->affected;
- }
- else
+ mode_t affected = changes->affected;
+ mode_t value = changes->value;
+
+ switch (changes->flag)
{
- value = changes->value;
- /* If `X', do not affect the execute bits if the file is not a
- directory and no execute bits are already set. */
- if ((changes->flags & MODE_X_IF_ANY_X)
- && !S_ISDIR (oldmode)
- && (newmode & 00111) == 0)
- value &= ~00111; /* Clear the execute bits. */
+ case MODE_ORDINARY_CHANGE:
+ break;
+
+ case MODE_COPY_EXISTING:
+ /* Isolate in `value' the bits in `newmode' to copy. */
+ value &= newmode;
+
+ /* Copy the isolated bits to the other two parts. */
+ value |= ((value & (S_IRUSR | S_IRGRP | S_IROTH)
+ ? S_IRUSR | S_IRGRP | S_IROTH : 0)
+ | (value & (S_IWUSR | S_IWGRP | S_IWOTH)
+ ? S_IWUSR | S_IWGRP | S_IWOTH : 0)
+ | (value & (S_IXUSR | S_IXGRP | S_IXOTH)
+ ? S_IXUSR | S_IXGRP | S_IXOTH : 0));
+ break;
+
+ case MODE_X_IF_ANY_X:
+ /* Affect the execute bits if execute bits are already set
+ or if the file is a directory. */
+ if ((newmode & (S_IXUSR | S_IXGRP | S_IXOTH)) || S_ISDIR (oldmode))
+ value |= S_IXUSR | S_IXGRP | S_IXOTH;
+ break;
}
+ /* If WHO was specified, limit the change to the affected bits.
+ Otherwise, apply the umask. */
+ value &= (affected ? affected : ~umask_value);
+
switch (changes->op)
{
case '=':
- /* Preserve the previous values in `newmode' of bits that are
- not affected by this change operation. */
- newmode = (newmode & ~changes->affected) | value;
- break;
+ /* If WHO was specified, preserve the previous values of
+ bits that are not affected by this change operation.
+ Otherwise, clear all the bits. */
+ newmode = (affected ? newmode & ~affected : 0);
+ /* Fall through. */
case '+':
newmode |= value;
break;
+
case '-':
newmode &= ~value;
break;
}
}
- return newmode;
-}
-
-/* Free the memory used by the list of file mode change operations
- CHANGES. */
-
-void
-mode_free (changes)
- register struct mode_change *changes;
-{
- register struct mode_change *next;
- while (changes)
- {
- next = changes->next;
- free (changes);
- changes = next;
- }
-}
-
-/* Return a positive integer containing the value of the ASCII
- octal number S. If S is not an octal number, return -1. */
-
-static int
-oatoi (s)
- char *s;
-{
- register int i;
-
- if (*s == 0)
- return -1;
- for (i = 0; isodigit (*s); ++s)
- i = i * 8 + *s - '0';
- if (*s)
- return -1;
- return i;
+ return newmode;
}