mirror of
https://github.com/mirror/make.git
synced 2024-12-28 05:40:10 +08:00
1042 lines
24 KiB
C
1042 lines
24 KiB
C
/* Miscellaneous generic support functions for GNU Make.
|
||
Copyright (C) 1988-2013 Free Software Foundation, Inc.
|
||
This file is part of GNU Make.
|
||
|
||
GNU Make 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 3 of the License, or (at your option) any later
|
||
version.
|
||
|
||
GNU Make 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
|
||
this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "makeint.h"
|
||
#include "dep.h"
|
||
#include "debug.h"
|
||
|
||
/* GNU make no longer supports pre-ANSI89 environments. */
|
||
|
||
#include <stdarg.h>
|
||
|
||
#ifdef HAVE_FCNTL_H
|
||
# include <fcntl.h>
|
||
#else
|
||
# include <sys/file.h>
|
||
#endif
|
||
|
||
/* Compare strings *S1 and *S2.
|
||
Return negative if the first is less, positive if it is greater,
|
||
zero if they are equal. */
|
||
|
||
int
|
||
alpha_compare (const void *v1, const void *v2)
|
||
{
|
||
const char *s1 = *((char **)v1);
|
||
const char *s2 = *((char **)v2);
|
||
|
||
if (*s1 != *s2)
|
||
return *s1 - *s2;
|
||
return strcmp (s1, s2);
|
||
}
|
||
|
||
/* Discard each backslash-newline combination from LINE.
|
||
Backslash-backslash-newline combinations become backslash-newlines.
|
||
This is done by copying the text at LINE into itself. */
|
||
|
||
void
|
||
collapse_continuations (char *line)
|
||
{
|
||
char *in, *out, *p;
|
||
|
||
in = strchr (line, '\n');
|
||
if (in == 0)
|
||
return;
|
||
|
||
out = in;
|
||
while (out > line && out[-1] == '\\')
|
||
--out;
|
||
|
||
while (*in != '\0')
|
||
{
|
||
/* BS_WRITE gets the number of quoted backslashes at
|
||
the end just before IN, and BACKSLASH gets nonzero
|
||
if the next character is quoted. */
|
||
unsigned int backslash = 0;
|
||
unsigned int bs_write = 0;
|
||
for (p = in - 1; p >= line && *p == '\\'; --p)
|
||
{
|
||
if (backslash)
|
||
++bs_write;
|
||
backslash = !backslash;
|
||
|
||
/* It should be impossible to go back this far without exiting,
|
||
but if we do, we can't get the right answer. */
|
||
if (in == out - 1)
|
||
abort ();
|
||
}
|
||
|
||
/* Output the appropriate number of backslashes. */
|
||
while (bs_write-- > 0)
|
||
*out++ = '\\';
|
||
|
||
/* Skip the newline. */
|
||
++in;
|
||
|
||
if (backslash)
|
||
{
|
||
/* Backslash/newline handling:
|
||
In traditional GNU make all trailing whitespace, consecutive
|
||
backslash/newlines, and any leading whitespace on the next line
|
||
is reduced to a single space.
|
||
In POSIX, each backslash/newline and is replaced by a space. */
|
||
in = next_token (in);
|
||
if (! posix_pedantic)
|
||
while (out > line && isblank ((unsigned char)out[-1]))
|
||
--out;
|
||
*out++ = ' ';
|
||
}
|
||
else
|
||
/* If the newline isn't quoted, put it in the output. */
|
||
*out++ = '\n';
|
||
|
||
/* Now copy the following line to the output.
|
||
Stop when we find backslashes followed by a newline. */
|
||
while (*in != '\0')
|
||
if (*in == '\\')
|
||
{
|
||
p = in + 1;
|
||
while (*p == '\\')
|
||
++p;
|
||
if (*p == '\n')
|
||
{
|
||
in = p;
|
||
break;
|
||
}
|
||
while (in < p)
|
||
*out++ = *in++;
|
||
}
|
||
else
|
||
*out++ = *in++;
|
||
}
|
||
|
||
*out = '\0';
|
||
}
|
||
|
||
/* Print N spaces (used in debug for target-depth). */
|
||
|
||
void
|
||
print_spaces (unsigned int n)
|
||
{
|
||
while (n-- > 0)
|
||
putchar (' ');
|
||
}
|
||
|
||
|
||
/* Return a string whose contents concatenate the NUM strings provided
|
||
This string lives in static, re-used memory. */
|
||
|
||
const char *
|
||
concat (unsigned int num, ...)
|
||
{
|
||
static unsigned int rlen = 0;
|
||
static char *result = NULL;
|
||
unsigned int ri = 0;
|
||
va_list args;
|
||
|
||
va_start (args, num);
|
||
|
||
while (num-- > 0)
|
||
{
|
||
const char *s = va_arg (args, const char *);
|
||
unsigned int l = s ? strlen (s) : 0;
|
||
|
||
if (l == 0)
|
||
continue;
|
||
|
||
if (ri + l > rlen)
|
||
{
|
||
rlen = ((rlen ? rlen : 60) + l) * 2;
|
||
result = xrealloc (result, rlen);
|
||
}
|
||
|
||
memcpy (result + ri, s, l);
|
||
ri += l;
|
||
}
|
||
|
||
va_end (args);
|
||
|
||
/* Get some more memory if we don't have enough space for the
|
||
terminating '\0'. */
|
||
if (ri == rlen)
|
||
{
|
||
rlen = (rlen ? rlen : 60) * 2;
|
||
result = xrealloc (result, rlen);
|
||
}
|
||
|
||
result[ri] = '\0';
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
/* Return a formatted string buffer.
|
||
LENGTH must be the maximum length of all format arguments, stringified.
|
||
If we had a standard-compliant vsnprintf() this would be a lot simpler.
|
||
Maybe in the future we'll include gnulib's version. */
|
||
|
||
const char *
|
||
message_s (unsigned int length, int prefix, const char *fmt, ...)
|
||
{
|
||
static char *buffer = NULL;
|
||
static unsigned int bsize = 0;
|
||
char *bp;
|
||
va_list args;
|
||
|
||
/* Compute the maximum buffer size we'll need, and make sure we have it. */
|
||
length += strlen (fmt) + strlen (program) + 4 + INTEGER_LENGTH + 2;
|
||
if (length > bsize)
|
||
{
|
||
bsize = length * 2;
|
||
buffer = xrealloc (buffer, bsize);
|
||
}
|
||
|
||
bp = buffer;
|
||
if (prefix)
|
||
{
|
||
if (makelevel == 0)
|
||
sprintf (bp, "%s: ", program);
|
||
else
|
||
sprintf (bp, "%s[%u]: ", program, makelevel);
|
||
bp += strlen (buffer);
|
||
}
|
||
|
||
va_start (args, fmt);
|
||
vsprintf (bp, fmt, args);
|
||
va_end (args);
|
||
|
||
return buffer;
|
||
}
|
||
|
||
/* Return a formatted error message in a buffer.
|
||
LENGTH must be the maximum length of all format arguments, stringified. */
|
||
|
||
const char *
|
||
error_s (unsigned int length, const gmk_floc *flocp, const char *fmt, ...)
|
||
{
|
||
static char *buffer = NULL;
|
||
static unsigned int bsize = 0;
|
||
char *bp;
|
||
va_list args;
|
||
|
||
/* Compute the maximum buffer size we'll need, and make sure we have it. */
|
||
length += (strlen (fmt) + strlen (program) + 4 + INTEGER_LENGTH + 2
|
||
+ (flocp && flocp->filenm ? strlen (flocp->filenm) : 0));
|
||
if (length > bsize)
|
||
{
|
||
bsize = length * 2;
|
||
buffer = xrealloc (buffer, bsize);
|
||
}
|
||
|
||
bp = buffer;
|
||
if (flocp && flocp->filenm)
|
||
sprintf (bp, "%s:%lu: ", flocp->filenm, flocp->lineno);
|
||
else if (makelevel == 0)
|
||
sprintf (bp, "%s: ", program);
|
||
else
|
||
sprintf (bp, "%s[%u]: ", program, makelevel);
|
||
bp += strlen (bp);
|
||
|
||
va_start (args, fmt);
|
||
vsprintf (bp, fmt, args);
|
||
va_end (args);
|
||
|
||
return buffer;
|
||
}
|
||
|
||
/* Print a message on stdout. We could use message_s() to format it but then
|
||
we'd need a va_list version... */
|
||
|
||
void
|
||
message (int prefix, const char *fmt, ...)
|
||
{
|
||
va_list args;
|
||
|
||
log_working_directory (1, 0);
|
||
|
||
if (fmt != 0)
|
||
{
|
||
if (prefix)
|
||
{
|
||
if (makelevel == 0)
|
||
printf ("%s: ", program);
|
||
else
|
||
printf ("%s[%u]: ", program, makelevel);
|
||
}
|
||
va_start (args, fmt);
|
||
vfprintf (stdout, fmt, args);
|
||
va_end (args);
|
||
putchar ('\n');
|
||
}
|
||
|
||
fflush (stdout);
|
||
}
|
||
|
||
/* Print an error message. */
|
||
|
||
void
|
||
error (const gmk_floc *flocp, const char *fmt, ...)
|
||
{
|
||
va_list args;
|
||
|
||
log_working_directory (1, 0);
|
||
|
||
if (flocp && flocp->filenm)
|
||
fprintf (stderr, "%s:%lu: ", flocp->filenm, flocp->lineno);
|
||
else if (makelevel == 0)
|
||
fprintf (stderr, "%s: ", program);
|
||
else
|
||
fprintf (stderr, "%s[%u]: ", program, makelevel);
|
||
|
||
va_start (args, fmt);
|
||
vfprintf (stderr, fmt, args);
|
||
va_end (args);
|
||
|
||
putc ('\n', stderr);
|
||
fflush (stderr);
|
||
}
|
||
|
||
/* Print an error message and exit. */
|
||
|
||
void
|
||
fatal (const gmk_floc *flocp, const char *fmt, ...)
|
||
{
|
||
va_list args;
|
||
|
||
log_working_directory (1, 0);
|
||
|
||
if (flocp && flocp->filenm)
|
||
fprintf (stderr, "%s:%lu: *** ", flocp->filenm, flocp->lineno);
|
||
else if (makelevel == 0)
|
||
fprintf (stderr, "%s: *** ", program);
|
||
else
|
||
fprintf (stderr, "%s[%u]: *** ", program, makelevel);
|
||
|
||
va_start (args, fmt);
|
||
vfprintf (stderr, fmt, args);
|
||
va_end (args);
|
||
|
||
fputs (_(". Stop.\n"), stderr);
|
||
|
||
log_working_directory (0, 1);
|
||
|
||
die (2);
|
||
}
|
||
|
||
#ifndef HAVE_STRERROR
|
||
|
||
#undef strerror
|
||
|
||
char *
|
||
strerror (int errnum)
|
||
{
|
||
extern int errno, sys_nerr;
|
||
#ifndef __DECC
|
||
extern char *sys_errlist[];
|
||
#endif
|
||
static char buf[] = "Unknown error 12345678901234567890";
|
||
|
||
if (errno < sys_nerr)
|
||
return sys_errlist[errnum];
|
||
|
||
sprintf (buf, _("Unknown error %d"), errnum);
|
||
return buf;
|
||
}
|
||
#endif
|
||
|
||
/* Print an error message from errno. */
|
||
|
||
void
|
||
perror_with_name (const char *str, const char *name)
|
||
{
|
||
error (NILF, _("%s%s: %s"), str, name, strerror (errno));
|
||
}
|
||
|
||
/* Print an error message from errno and exit. */
|
||
|
||
void
|
||
pfatal_with_name (const char *name)
|
||
{
|
||
fatal (NILF, _("%s: %s"), name, strerror (errno));
|
||
|
||
/* NOTREACHED */
|
||
}
|
||
|
||
/* Like malloc but get fatal error if memory is exhausted. */
|
||
/* Don't bother if we're using dmalloc; it provides these for us. */
|
||
|
||
#ifndef HAVE_DMALLOC_H
|
||
|
||
#undef xmalloc
|
||
#undef xcalloc
|
||
#undef xrealloc
|
||
#undef xstrdup
|
||
|
||
void *
|
||
xmalloc (unsigned int size)
|
||
{
|
||
/* Make sure we don't allocate 0, for pre-ISO implementations. */
|
||
void *result = malloc (size ? size : 1);
|
||
if (result == 0)
|
||
fatal (NILF, _("virtual memory exhausted"));
|
||
return result;
|
||
}
|
||
|
||
|
||
void *
|
||
xcalloc (unsigned int size)
|
||
{
|
||
/* Make sure we don't allocate 0, for pre-ISO implementations. */
|
||
void *result = calloc (size ? size : 1, 1);
|
||
if (result == 0)
|
||
fatal (NILF, _("virtual memory exhausted"));
|
||
return result;
|
||
}
|
||
|
||
|
||
void *
|
||
xrealloc (void *ptr, unsigned int size)
|
||
{
|
||
void *result;
|
||
|
||
/* Some older implementations of realloc() don't conform to ISO. */
|
||
if (! size)
|
||
size = 1;
|
||
result = ptr ? realloc (ptr, size) : malloc (size);
|
||
if (result == 0)
|
||
fatal (NILF, _("virtual memory exhausted"));
|
||
return result;
|
||
}
|
||
|
||
|
||
char *
|
||
xstrdup (const char *ptr)
|
||
{
|
||
char *result;
|
||
|
||
#ifdef HAVE_STRDUP
|
||
result = strdup (ptr);
|
||
#else
|
||
result = malloc (strlen (ptr) + 1);
|
||
#endif
|
||
|
||
if (result == 0)
|
||
fatal (NILF, _("virtual memory exhausted"));
|
||
|
||
#ifdef HAVE_STRDUP
|
||
return result;
|
||
#else
|
||
return strcpy (result, ptr);
|
||
#endif
|
||
}
|
||
|
||
#endif /* HAVE_DMALLOC_H */
|
||
|
||
char *
|
||
xstrndup (const char *str, unsigned int length)
|
||
{
|
||
char *result;
|
||
|
||
#ifdef HAVE_STRNDUP
|
||
result = strndup (str, length);
|
||
if (result == 0)
|
||
fatal (NILF, _("virtual memory exhausted"));
|
||
#else
|
||
result = xmalloc (length + 1);
|
||
if (length > 0)
|
||
strncpy (result, str, length);
|
||
result[length] = '\0';
|
||
#endif
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
/* Limited INDEX:
|
||
Search through the string STRING, which ends at LIMIT, for the character C.
|
||
Returns a pointer to the first occurrence, or nil if none is found.
|
||
Like INDEX except that the string searched ends where specified
|
||
instead of at the first null. */
|
||
|
||
char *
|
||
lindex (const char *s, const char *limit, int c)
|
||
{
|
||
while (s < limit)
|
||
if (*s++ == c)
|
||
return (char *)(s - 1);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Return the address of the first whitespace or null in the string S. */
|
||
|
||
char *
|
||
end_of_token (const char *s)
|
||
{
|
||
while (! STOP_SET (*s, MAP_BLANK|MAP_NUL))
|
||
++s;
|
||
return (char *)s;
|
||
}
|
||
|
||
/* Return the address of the first nonwhitespace or null in the string S. */
|
||
|
||
char *
|
||
next_token (const char *s)
|
||
{
|
||
while (isblank ((unsigned char)*s))
|
||
++s;
|
||
return (char *)s;
|
||
}
|
||
|
||
/* Find the next token in PTR; return the address of it, and store the length
|
||
of the token into *LENGTHPTR if LENGTHPTR is not nil. Set *PTR to the end
|
||
of the token, so this function can be called repeatedly in a loop. */
|
||
|
||
char *
|
||
find_next_token (const char **ptr, unsigned int *lengthptr)
|
||
{
|
||
const char *p = next_token (*ptr);
|
||
|
||
if (*p == '\0')
|
||
return 0;
|
||
|
||
*ptr = end_of_token (p);
|
||
if (lengthptr != 0)
|
||
*lengthptr = *ptr - p;
|
||
|
||
return (char *)p;
|
||
}
|
||
|
||
|
||
/* Copy a chain of 'struct dep'. For 2nd expansion deps, dup the name. */
|
||
|
||
struct dep *
|
||
copy_dep_chain (const struct dep *d)
|
||
{
|
||
struct dep *firstnew = 0;
|
||
struct dep *lastnew = 0;
|
||
|
||
while (d != 0)
|
||
{
|
||
struct dep *c = xmalloc (sizeof (struct dep));
|
||
memcpy (c, d, sizeof (struct dep));
|
||
|
||
if (c->need_2nd_expansion)
|
||
c->name = xstrdup (c->name);
|
||
|
||
c->next = 0;
|
||
if (firstnew == 0)
|
||
firstnew = lastnew = c;
|
||
else
|
||
lastnew = lastnew->next = c;
|
||
|
||
d = d->next;
|
||
}
|
||
|
||
return firstnew;
|
||
}
|
||
|
||
/* Free a chain of 'struct dep'. */
|
||
|
||
void
|
||
free_dep_chain (struct dep *d)
|
||
{
|
||
while (d != 0)
|
||
{
|
||
struct dep *df = d;
|
||
d = d->next;
|
||
free_dep (df);
|
||
}
|
||
}
|
||
|
||
/* Free a chain of struct nameseq.
|
||
For struct dep chains use free_dep_chain. */
|
||
|
||
void
|
||
free_ns_chain (struct nameseq *ns)
|
||
{
|
||
while (ns != 0)
|
||
{
|
||
struct nameseq *t = ns;
|
||
ns = ns->next;
|
||
free (t);
|
||
}
|
||
}
|
||
|
||
|
||
#if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
|
||
|
||
/* If we don't have strcasecmp() (from POSIX), or anything that can substitute
|
||
for it, define our own version. */
|
||
|
||
int
|
||
strcasecmp (const char *s1, const char *s2)
|
||
{
|
||
while (1)
|
||
{
|
||
int c1 = (int) *(s1++);
|
||
int c2 = (int) *(s2++);
|
||
|
||
if (isalpha (c1))
|
||
c1 = tolower (c1);
|
||
if (isalpha (c2))
|
||
c2 = tolower (c2);
|
||
|
||
if (c1 != '\0' && c1 == c2)
|
||
continue;
|
||
|
||
return (c1 - c2);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if !HAVE_STRNCASECMP && !HAVE_STRNICMP && !HAVE_STRNCMPI
|
||
|
||
/* If we don't have strncasecmp() (from POSIX), or anything that can
|
||
substitute for it, define our own version. */
|
||
|
||
int
|
||
strncasecmp (const char *s1, const char *s2, int n)
|
||
{
|
||
while (n-- > 0)
|
||
{
|
||
int c1 = (int) *(s1++);
|
||
int c2 = (int) *(s2++);
|
||
|
||
if (isalpha (c1))
|
||
c1 = tolower (c1);
|
||
if (isalpha (c2))
|
||
c2 = tolower (c2);
|
||
|
||
if (c1 != '\0' && c1 == c2)
|
||
continue;
|
||
|
||
return (c1 - c2);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
#endif
|
||
|
||
#ifdef GETLOADAVG_PRIVILEGED
|
||
|
||
#ifdef POSIX
|
||
|
||
/* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
|
||
functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2,
|
||
for example) which claim to be POSIX.1 also have the BSD setreuid and
|
||
setregid functions, but they don't work as in BSD and only the POSIX.1
|
||
way works. */
|
||
|
||
#undef HAVE_SETREUID
|
||
#undef HAVE_SETREGID
|
||
|
||
#else /* Not POSIX. */
|
||
|
||
/* Some POSIX.1 systems have the seteuid and setegid functions. In a
|
||
POSIX-like system, they are the best thing to use. However, some
|
||
non-POSIX systems have them too but they do not work in the POSIX style
|
||
and we must use setreuid and setregid instead. */
|
||
|
||
#undef HAVE_SETEUID
|
||
#undef HAVE_SETEGID
|
||
|
||
#endif /* POSIX. */
|
||
|
||
#ifndef HAVE_UNISTD_H
|
||
extern int getuid (), getgid (), geteuid (), getegid ();
|
||
extern int setuid (), setgid ();
|
||
#ifdef HAVE_SETEUID
|
||
extern int seteuid ();
|
||
#else
|
||
#ifdef HAVE_SETREUID
|
||
extern int setreuid ();
|
||
#endif /* Have setreuid. */
|
||
#endif /* Have seteuid. */
|
||
#ifdef HAVE_SETEGID
|
||
extern int setegid ();
|
||
#else
|
||
#ifdef HAVE_SETREGID
|
||
extern int setregid ();
|
||
#endif /* Have setregid. */
|
||
#endif /* Have setegid. */
|
||
#endif /* No <unistd.h>. */
|
||
|
||
/* Keep track of the user and group IDs for user- and make- access. */
|
||
static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
|
||
#define access_inited (user_uid != -1)
|
||
static enum { make, user } current_access;
|
||
|
||
|
||
/* Under -d, write a message describing the current IDs. */
|
||
|
||
static void
|
||
log_access (const char *flavor)
|
||
{
|
||
if (! ISDB (DB_JOBS))
|
||
return;
|
||
|
||
/* All the other debugging messages go to stdout,
|
||
but we write this one to stderr because it might be
|
||
run in a child fork whose stdout is piped. */
|
||
|
||
fprintf (stderr, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
|
||
flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
|
||
(unsigned long) getegid (), (unsigned long) getgid ());
|
||
fflush (stderr);
|
||
}
|
||
|
||
|
||
static void
|
||
init_access (void)
|
||
{
|
||
#ifndef VMS
|
||
user_uid = getuid ();
|
||
user_gid = getgid ();
|
||
|
||
make_uid = geteuid ();
|
||
make_gid = getegid ();
|
||
|
||
/* Do these ever fail? */
|
||
if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
|
||
pfatal_with_name ("get{e}[gu]id");
|
||
|
||
log_access (_("Initialized access"));
|
||
|
||
current_access = make;
|
||
#endif
|
||
}
|
||
|
||
#endif /* GETLOADAVG_PRIVILEGED */
|
||
|
||
/* Give the process appropriate permissions for access to
|
||
user data (i.e., to stat files, or to spawn a child process). */
|
||
void
|
||
user_access (void)
|
||
{
|
||
#ifdef GETLOADAVG_PRIVILEGED
|
||
|
||
if (!access_inited)
|
||
init_access ();
|
||
|
||
if (current_access == user)
|
||
return;
|
||
|
||
/* We are in "make access" mode. This means that the effective user and
|
||
group IDs are those of make (if it was installed setuid or setgid).
|
||
We now want to set the effective user and group IDs to the real IDs,
|
||
which are the IDs of the process that exec'd make. */
|
||
|
||
#ifdef HAVE_SETEUID
|
||
|
||
/* Modern systems have the seteuid/setegid calls which set only the
|
||
effective IDs, which is ideal. */
|
||
|
||
if (seteuid (user_uid) < 0)
|
||
pfatal_with_name ("user_access: seteuid");
|
||
|
||
#else /* Not HAVE_SETEUID. */
|
||
|
||
#ifndef HAVE_SETREUID
|
||
|
||
/* System V has only the setuid/setgid calls to set user/group IDs.
|
||
There is an effective ID, which can be set by setuid/setgid.
|
||
It can be set (unless you are root) only to either what it already is
|
||
(returned by geteuid/getegid, now in make_uid/make_gid),
|
||
the real ID (return by getuid/getgid, now in user_uid/user_gid),
|
||
or the saved set ID (what the effective ID was before this set-ID
|
||
executable (make) was exec'd). */
|
||
|
||
if (setuid (user_uid) < 0)
|
||
pfatal_with_name ("user_access: setuid");
|
||
|
||
#else /* HAVE_SETREUID. */
|
||
|
||
/* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
|
||
They may be set to themselves or each other. So you have two alternatives
|
||
at any one time. If you use setuid/setgid, the effective will be set to
|
||
the real, leaving only one alternative. Using setreuid/setregid, however,
|
||
you can toggle between your two alternatives by swapping the values in a
|
||
single setreuid or setregid call. */
|
||
|
||
if (setreuid (make_uid, user_uid) < 0)
|
||
pfatal_with_name ("user_access: setreuid");
|
||
|
||
#endif /* Not HAVE_SETREUID. */
|
||
#endif /* HAVE_SETEUID. */
|
||
|
||
#ifdef HAVE_SETEGID
|
||
if (setegid (user_gid) < 0)
|
||
pfatal_with_name ("user_access: setegid");
|
||
#else
|
||
#ifndef HAVE_SETREGID
|
||
if (setgid (user_gid) < 0)
|
||
pfatal_with_name ("user_access: setgid");
|
||
#else
|
||
if (setregid (make_gid, user_gid) < 0)
|
||
pfatal_with_name ("user_access: setregid");
|
||
#endif
|
||
#endif
|
||
|
||
current_access = user;
|
||
|
||
log_access (_("User access"));
|
||
|
||
#endif /* GETLOADAVG_PRIVILEGED */
|
||
}
|
||
|
||
/* Give the process appropriate permissions for access to
|
||
make data (i.e., the load average). */
|
||
void
|
||
make_access (void)
|
||
{
|
||
#ifdef GETLOADAVG_PRIVILEGED
|
||
|
||
if (!access_inited)
|
||
init_access ();
|
||
|
||
if (current_access == make)
|
||
return;
|
||
|
||
/* See comments in user_access, above. */
|
||
|
||
#ifdef HAVE_SETEUID
|
||
if (seteuid (make_uid) < 0)
|
||
pfatal_with_name ("make_access: seteuid");
|
||
#else
|
||
#ifndef HAVE_SETREUID
|
||
if (setuid (make_uid) < 0)
|
||
pfatal_with_name ("make_access: setuid");
|
||
#else
|
||
if (setreuid (user_uid, make_uid) < 0)
|
||
pfatal_with_name ("make_access: setreuid");
|
||
#endif
|
||
#endif
|
||
|
||
#ifdef HAVE_SETEGID
|
||
if (setegid (make_gid) < 0)
|
||
pfatal_with_name ("make_access: setegid");
|
||
#else
|
||
#ifndef HAVE_SETREGID
|
||
if (setgid (make_gid) < 0)
|
||
pfatal_with_name ("make_access: setgid");
|
||
#else
|
||
if (setregid (user_gid, make_gid) < 0)
|
||
pfatal_with_name ("make_access: setregid");
|
||
#endif
|
||
#endif
|
||
|
||
current_access = make;
|
||
|
||
log_access (_("Make access"));
|
||
|
||
#endif /* GETLOADAVG_PRIVILEGED */
|
||
}
|
||
|
||
/* Give the process appropriate permissions for a child process.
|
||
This is like user_access, but you can't get back to make_access. */
|
||
void
|
||
child_access (void)
|
||
{
|
||
#ifdef GETLOADAVG_PRIVILEGED
|
||
|
||
if (!access_inited)
|
||
abort ();
|
||
|
||
/* Set both the real and effective UID and GID to the user's.
|
||
They cannot be changed back to make's. */
|
||
|
||
#ifndef HAVE_SETREUID
|
||
if (setuid (user_uid) < 0)
|
||
pfatal_with_name ("child_access: setuid");
|
||
#else
|
||
if (setreuid (user_uid, user_uid) < 0)
|
||
pfatal_with_name ("child_access: setreuid");
|
||
#endif
|
||
|
||
#ifndef HAVE_SETREGID
|
||
if (setgid (user_gid) < 0)
|
||
pfatal_with_name ("child_access: setgid");
|
||
#else
|
||
if (setregid (user_gid, user_gid) < 0)
|
||
pfatal_with_name ("child_access: setregid");
|
||
#endif
|
||
|
||
log_access (_("Child access"));
|
||
|
||
#endif /* GETLOADAVG_PRIVILEGED */
|
||
}
|
||
|
||
#ifdef NEED_GET_PATH_MAX
|
||
unsigned int
|
||
get_path_max (void)
|
||
{
|
||
static unsigned int value;
|
||
|
||
if (value == 0)
|
||
{
|
||
long int x = pathconf ("/", _PC_PATH_MAX);
|
||
if (x > 0)
|
||
value = x;
|
||
else
|
||
return MAXPATHLEN;
|
||
}
|
||
|
||
return value;
|
||
}
|
||
#endif
|
||
|
||
|
||
/* Set a file descriptor to be in O_APPEND mode.
|
||
If it fails, just ignore it. */
|
||
|
||
void
|
||
set_append_mode (int fd)
|
||
{
|
||
#if defined(F_GETFL) && defined(F_SETFL) && defined(O_APPEND)
|
||
int flags = fcntl (fd, F_GETFL, 0);
|
||
if (flags >= 0)
|
||
fcntl (fd, F_SETFL, flags | O_APPEND);
|
||
#endif
|
||
}
|
||
|
||
/* Provide support for temporary files. */
|
||
|
||
#ifndef HAVE_STDLIB_H
|
||
# ifdef HAVE_MKSTEMP
|
||
int mkstemp (char *template);
|
||
# else
|
||
char *mktemp (char *template);
|
||
# endif
|
||
#endif
|
||
|
||
/* This is only used by output-sync, and it may not be portable. */
|
||
#ifdef OUTPUT_SYNC
|
||
|
||
/* Returns a file descriptor to a temporary file. The file is automatically
|
||
closed/deleted on exit. Don't use a FILE* stream. */
|
||
int
|
||
open_tmpfd ()
|
||
{
|
||
int fd = -1;
|
||
FILE *tfile = tmpfile ();
|
||
|
||
if (! tfile)
|
||
pfatal_with_name ("tmpfile");
|
||
|
||
/* Create a duplicate so we can close the stream. */
|
||
fd = dup (fileno (tfile));
|
||
if (fd < 0)
|
||
pfatal_with_name ("dup");
|
||
|
||
fclose (tfile);
|
||
|
||
set_append_mode (fd);
|
||
|
||
return fd;
|
||
}
|
||
|
||
#endif
|
||
|
||
FILE *
|
||
open_tmpfile (char **name, const char *template)
|
||
{
|
||
#ifdef HAVE_FDOPEN
|
||
int fd;
|
||
#endif
|
||
|
||
#if defined HAVE_MKSTEMP || defined HAVE_MKTEMP
|
||
# define TEMPLATE_LEN strlen (template)
|
||
#else
|
||
# define TEMPLATE_LEN L_tmpnam
|
||
#endif
|
||
*name = xmalloc (TEMPLATE_LEN + 1);
|
||
strcpy (*name, template);
|
||
|
||
#if defined HAVE_MKSTEMP && defined HAVE_FDOPEN
|
||
/* It's safest to use mkstemp(), if we can. */
|
||
fd = mkstemp (*name);
|
||
if (fd == -1)
|
||
return 0;
|
||
return fdopen (fd, "w");
|
||
#else
|
||
# ifdef HAVE_MKTEMP
|
||
(void) mktemp (*name);
|
||
# else
|
||
(void) tmpnam (*name);
|
||
# endif
|
||
|
||
# ifdef HAVE_FDOPEN
|
||
/* Can't use mkstemp(), but guard against a race condition. */
|
||
fd = open (*name, O_CREAT|O_EXCL|O_WRONLY, 0600);
|
||
if (fd == -1)
|
||
return 0;
|
||
return fdopen (fd, "w");
|
||
# else
|
||
/* Not secure, but what can we do? */
|
||
return fopen (*name, "w");
|
||
# endif
|
||
#endif
|
||
}
|
||
|
||
|
||
|
||
/* This code is stolen from gnulib.
|
||
If/when we abandon the requirement to work with K&R compilers, we can
|
||
remove this (and perhaps other parts of GNU make!) and migrate to using
|
||
gnulib directly.
|
||
|
||
This is called only through atexit(), which means die() has already been
|
||
invoked. So, call exit() here directly. Apparently that works...?
|
||
*/
|
||
|
||
/* Close standard output, exiting with status 'exit_failure' on failure.
|
||
If a program writes *anything* to stdout, that program should close
|
||
stdout and make sure that it succeeds before exiting. Otherwise,
|
||
suppose that you go to the extreme of checking the return status
|
||
of every function that does an explicit write to stdout. The last
|
||
printf can succeed in writing to the internal stream buffer, and yet
|
||
the fclose(stdout) could still fail (due e.g., to a disk full error)
|
||
when it tries to write out that buffered data. Thus, you would be
|
||
left with an incomplete output file and the offending program would
|
||
exit successfully. Even calling fflush is not always sufficient,
|
||
since some file systems (NFS and CODA) buffer written/flushed data
|
||
until an actual close call.
|
||
|
||
Besides, it's wasteful to check the return value from every call
|
||
that writes to stdout -- just let the internal stream state record
|
||
the failure. That's what the ferror test is checking below.
|
||
|
||
It's important to detect such failures and exit nonzero because many
|
||
tools (most notably 'make' and other build-management systems) depend
|
||
on being able to detect failure in other tools via their exit status. */
|
||
|
||
void
|
||
close_stdout (void)
|
||
{
|
||
int prev_fail = ferror (stdout);
|
||
int fclose_fail = fclose (stdout);
|
||
|
||
if (prev_fail || fclose_fail)
|
||
{
|
||
if (fclose_fail)
|
||
error (NILF, _("write error: %s"), strerror (errno));
|
||
else
|
||
error (NILF, _("write error"));
|
||
exit (EXIT_FAILURE);
|
||
}
|
||
}
|