303 lines
6.8 KiB
Modula-2
303 lines
6.8 KiB
Modula-2
This file is umask.def, from which is created umask.c.
|
|
It implements the builtin "umask" in Bash.
|
|
|
|
Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Bash, the Bourne Again SHell.
|
|
|
|
Bash is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
version.
|
|
|
|
Bash is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with Bash; see the file COPYING. If not, write to the Free Software
|
|
Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA.
|
|
|
|
$PRODUCES umask.c
|
|
|
|
$BUILTIN umask
|
|
$FUNCTION umask_builtin
|
|
$SHORT_DOC umask [-p] [-S] [mode]
|
|
The user file-creation mask is set to MODE. If MODE is omitted, or if
|
|
`-S' is supplied, the current value of the mask is printed. The `-S'
|
|
option makes the output symbolic; otherwise an octal number is output.
|
|
If `-p' is supplied, and MODE is omitted, the output is in a form
|
|
that may be used as input. If MODE begins with a digit, it is
|
|
interpreted as an octal number, otherwise it is a symbolic mode string
|
|
like that accepted by chmod(1).
|
|
$END
|
|
|
|
#include <config.h>
|
|
|
|
#include "../bashtypes.h"
|
|
#include "filecntl.h"
|
|
#ifndef _MINIX
|
|
# include <sys/file.h>
|
|
#endif
|
|
|
|
#if defined (HAVE_UNISTD_H)
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "../shell.h"
|
|
#include "posixstat.h"
|
|
#include "common.h"
|
|
#include "bashgetopt.h"
|
|
|
|
/* **************************************************************** */
|
|
/* */
|
|
/* UMASK Builtin and Helpers */
|
|
/* */
|
|
/* **************************************************************** */
|
|
|
|
static void print_symbolic_umask ();
|
|
static int symbolic_umask ();
|
|
|
|
/* Set or display the mask used by the system when creating files. Flag
|
|
of -S means display the umask in a symbolic mode. */
|
|
int
|
|
umask_builtin (list)
|
|
WORD_LIST *list;
|
|
{
|
|
int print_symbolically, opt, umask_value, pflag;
|
|
mode_t umask_arg;
|
|
|
|
print_symbolically = pflag = 0;
|
|
reset_internal_getopt ();
|
|
while ((opt = internal_getopt (list, "Sp")) != -1)
|
|
{
|
|
switch (opt)
|
|
{
|
|
case 'S':
|
|
print_symbolically++;
|
|
break;
|
|
case 'p':
|
|
pflag++;
|
|
break;
|
|
default:
|
|
builtin_usage ();
|
|
return (EX_USAGE);
|
|
}
|
|
}
|
|
|
|
list = loptend;
|
|
|
|
if (list)
|
|
{
|
|
if (digit (*list->word->word))
|
|
{
|
|
umask_value = read_octal (list->word->word);
|
|
|
|
/* Note that other shells just let you set the umask to zero
|
|
by specifying a number out of range. This is a problem
|
|
with those shells. We don't change the umask if the input
|
|
is lousy. */
|
|
if (umask_value == -1)
|
|
{
|
|
builtin_error ("`%s' is not an octal number from 000 to 777",
|
|
list->word->word);
|
|
return (EXECUTION_FAILURE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
umask_value = symbolic_umask (list);
|
|
if (umask_value == -1)
|
|
return (EXECUTION_FAILURE);
|
|
}
|
|
umask_arg = (mode_t)umask_value;
|
|
umask (umask_arg);
|
|
if (print_symbolically)
|
|
print_symbolic_umask (umask_arg);
|
|
}
|
|
else /* Display the UMASK for this user. */
|
|
{
|
|
umask_arg = umask (022);
|
|
umask (umask_arg);
|
|
|
|
if (pflag)
|
|
printf ("umask%s ", (print_symbolically ? " -S" : ""));
|
|
if (print_symbolically)
|
|
print_symbolic_umask (umask_arg);
|
|
else
|
|
printf ("%03o\n", umask_arg);
|
|
}
|
|
|
|
fflush (stdout);
|
|
return (EXECUTION_SUCCESS);
|
|
}
|
|
|
|
/* Print the umask in a symbolic form. In the output, a letter is
|
|
printed if the corresponding bit is clear in the umask. */
|
|
static void
|
|
print_symbolic_umask (um)
|
|
mode_t um;
|
|
{
|
|
char ubits[4], gbits[4], obits[4]; /* u=rwx,g=rwx,o=rwx */
|
|
int i;
|
|
|
|
i = 0;
|
|
if ((um & S_IRUSR) == 0)
|
|
ubits[i++] = 'r';
|
|
if ((um & S_IWUSR) == 0)
|
|
ubits[i++] = 'w';
|
|
if ((um & S_IXUSR) == 0)
|
|
ubits[i++] = 'x';
|
|
ubits[i] = '\0';
|
|
|
|
i = 0;
|
|
if ((um & S_IRGRP) == 0)
|
|
gbits[i++] = 'r';
|
|
if ((um & S_IWGRP) == 0)
|
|
gbits[i++] = 'w';
|
|
if ((um & S_IXGRP) == 0)
|
|
gbits[i++] = 'x';
|
|
gbits[i] = '\0';
|
|
|
|
i = 0;
|
|
if ((um & S_IROTH) == 0)
|
|
obits[i++] = 'r';
|
|
if ((um & S_IWOTH) == 0)
|
|
obits[i++] = 'w';
|
|
if ((um & S_IXOTH) == 0)
|
|
obits[i++] = 'x';
|
|
obits[i] = '\0';
|
|
|
|
printf ("u=%s,g=%s,o=%s\n", ubits, gbits, obits);
|
|
}
|
|
|
|
int
|
|
parse_symbolic_mode (mode, initial_bits)
|
|
char *mode;
|
|
int initial_bits;
|
|
{
|
|
int who, op, perm, mask, bits, c;
|
|
char *s;
|
|
|
|
for (s = mode, bits = initial_bits;;)
|
|
{
|
|
who = op = perm = mask = 0;
|
|
|
|
/* Parse the `who' portion of the symbolic mode clause. */
|
|
while (member (*s, "agou"))
|
|
{
|
|
switch (c = *s++)
|
|
{
|
|
case 'u':
|
|
who |= S_IRWXU;
|
|
continue;
|
|
case 'g':
|
|
who |= S_IRWXG;
|
|
continue;
|
|
case 'o':
|
|
who |= S_IRWXO;
|
|
continue;
|
|
case 'a':
|
|
who |= S_IRWXU | S_IRWXG | S_IRWXO;
|
|
continue;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* The operation is now sitting in *s. */
|
|
op = *s++;
|
|
switch (op)
|
|
{
|
|
case '+':
|
|
case '-':
|
|
case '=':
|
|
break;
|
|
default:
|
|
builtin_error ("bad symbolic mode operator: %c", op);
|
|
return (-1);
|
|
}
|
|
|
|
/* Parse out the `perm' section of the symbolic mode clause. */
|
|
while (member (*s, "rwx"))
|
|
{
|
|
c = *s++;
|
|
|
|
switch (c)
|
|
{
|
|
case 'r':
|
|
perm |= S_IRUGO;
|
|
break;
|
|
case 'w':
|
|
perm |= S_IWUGO;
|
|
break;
|
|
case 'x':
|
|
perm |= S_IXUGO;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Now perform the operation or return an error for a
|
|
bad permission string. */
|
|
if (!*s || *s == ',')
|
|
{
|
|
if (who)
|
|
perm &= who;
|
|
|
|
switch (op)
|
|
{
|
|
case '+':
|
|
bits |= perm;
|
|
break;
|
|
case '-':
|
|
bits &= ~perm;
|
|
break;
|
|
case '=':
|
|
bits &= ~who;
|
|
bits |= perm;
|
|
break;
|
|
|
|
/* No other values are possible. */
|
|
}
|
|
|
|
if (*s == '\0')
|
|
break;
|
|
else
|
|
s++; /* skip past ',' */
|
|
}
|
|
else
|
|
{
|
|
builtin_error ("bad character in symbolic mode: %c", *s);
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
return (bits);
|
|
}
|
|
|
|
/* Set the umask from a symbolic mode string similar to that accepted
|
|
by chmod. If the -S argument is given, then print the umask in a
|
|
symbolic form. */
|
|
static int
|
|
symbolic_umask (list)
|
|
WORD_LIST *list;
|
|
{
|
|
int um, bits;
|
|
|
|
/* Get the initial umask. Don't change it yet. */
|
|
um = umask (022);
|
|
umask (um);
|
|
|
|
/* All work is done with the complement of the umask -- it's
|
|
more intuitive and easier to deal with. It is complemented
|
|
again before being returned. */
|
|
bits = parse_symbolic_mode (list->word->word, ~um);
|
|
if (bits == -1)
|
|
return (-1);
|
|
|
|
um = ~bits & 0777;
|
|
return (um);
|
|
}
|