"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "littleutils/orig/tempname.c" between
littleutils-1.2.4.tar.lz and littleutils-1.2.5.tar.lz

About: littleutils are a collection of small and simple utilities (rename files, search for duplicate files, ...).

tempname.c  (littleutils-1.2.4.tar.lz):tempname.c  (littleutils-1.2.5.tar.lz)
/* Copyright (C) 1991-2020 Free Software Foundation, Inc. /* Copyright (C) 1991-2021 Free Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful, The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */ <https://www.gnu.org/licenses/>. */
#if !_LIBC #if !_LIBC
# include <config.h> # include <libc-config.h>
# include "tempname.h" # include "tempname.h"
#endif #endif
#include <sys/types.h> #include <sys/types.h>
#include <assert.h> #include <assert.h>
#include <stdbool.h>
#include <errno.h> #include <errno.h>
#ifndef __set_errno
# define __set_errno(Val) errno = (Val)
#endif
#include <stdio.h> #include <stdio.h>
#ifndef P_tmpdir #ifndef P_tmpdir
# define P_tmpdir "/tmp" # define P_tmpdir "/tmp"
#endif #endif
#ifndef TMP_MAX #ifndef TMP_MAX
# define TMP_MAX 238328 # define TMP_MAX 238328
#endif #endif
#ifndef __GT_FILE #ifndef __GT_FILE
# define __GT_FILE 0 # define __GT_FILE 0
# define __GT_DIR 1 # define __GT_DIR 1
# define __GT_NOCREATE 2 # define __GT_NOCREATE 2
#endif #endif
#if !_LIBC && (GT_FILE != __GT_FILE || GT_DIR != __GT_DIR \ #if !_LIBC && (GT_FILE != __GT_FILE || GT_DIR != __GT_DIR \
|| GT_NOCREATE != __GT_NOCREATE) || GT_NOCREATE != __GT_NOCREATE)
# error report this to bug-gnulib@gnu.org # error report this to bug-gnulib@gnu.org
#endif #endif
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <fcntl.h> #include <fcntl.h>
#include <time.h> #include <stdalign.h>
#include <stdint.h> #include <stdint.h>
#include <unistd.h> #include <sys/random.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <time.h>
#if _LIBC #if _LIBC
# define struct_stat64 struct stat64 # define struct_stat64 struct __stat64_t64
# define __secure_getenv __libc_secure_getenv # define __secure_getenv __libc_secure_getenv
#else #else
# define struct_stat64 struct stat # define struct_stat64 struct stat
# define __gen_tempname gen_tempname # define __gen_tempname gen_tempname
# define __getpid getpid
# define __mkdir mkdir # define __mkdir mkdir
# define __open open # define __open open
# define __lxstat64(version, file, buf) lstat (file, buf) # define __lstat64_time64(file, buf) lstat (file, buf)
# define __secure_getenv secure_getenv # define __stat64(file, buf) stat (file, buf)
# define __getrandom getrandom
# define __clock_gettime64 clock_gettime
# define __timespec64 timespec
#endif #endif
#ifdef _LIBC /* Use getrandom if it works, falling back on a 64-bit linear
# include <random-bits.h> congruential generator that starts with Var's value
# define RANDOM_BITS(Var) ((Var) = random_bits ()) mixed in with a clock's low-order bits if available. */
# else typedef uint_fast64_t random_value;
# define RANDOM_BITS(Var) \ #define RANDOM_VALUE_MAX UINT_FAST64_MAX
{ \ #define BASE_62_DIGITS 10 /* 62**10 < UINT_FAST64_MAX */
struct timespec ts; \ #define BASE_62_POWER (62LL * 62 * 62 * 62 * 62 * 62 * 62 * 62 * 62 * 62)
clock_gettime (CLOCK_REALTIME, &ts); \
(Var) = ((uint64_t) tv.tv_nsec << 16) ^ tv.tv_sec; \
}
#endif
/* Use the widest available unsigned type if uint64_t is not static random_value
available. The algorithm below extracts a number less than 62**6 random_bits (random_value var, bool use_getrandom)
(approximately 2**35.725) from uint64_t, so ancient hosts where {
uintmax_t is only 32 bits lose about 3.725 bits of randomness, random_value r;
which is better than not having mkstemp at all. */ /* Without GRND_NONBLOCK it can be blocked for minutes on some systems. */
#if !defined UINT64_MAX && !defined uint64_t if (use_getrandom && __getrandom (&r, sizeof r, GRND_NONBLOCK) == sizeof r)
# define uint64_t uintmax_t return r;
#if _LIBC || (defined CLOCK_MONOTONIC && HAVE_CLOCK_GETTIME)
/* Add entropy if getrandom did not work. */
struct __timespec64 tv;
__clock_gettime64 (CLOCK_MONOTONIC, &tv);
var ^= tv.tv_nsec;
#endif #endif
return 2862933555777941757 * var + 3037000493;
}
#if _LIBC #if _LIBC
/* Return nonzero if DIR is an existent directory. */ /* Return nonzero if DIR is an existent directory. */
static int static int
direxists (const char *dir) direxists (const char *dir)
{ {
struct_stat64 buf; struct_stat64 buf;
return __xstat64 (_STAT_VER, dir, &buf) == 0 && S_ISDIR (buf.st_mode); return __stat64_time64 (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
} }
/* Path search algorithm, for tmpnam, tmpfile, etc. If DIR is /* Path search algorithm, for tmpnam, tmpfile, etc. If DIR is
non-null and exists, uses it; otherwise uses the first of $TMPDIR, non-null and exists, uses it; otherwise uses the first of $TMPDIR,
P_tmpdir, /tmp that exists. Copies into TMPL a template suitable P_tmpdir, /tmp that exists. Copies into TMPL a template suitable
for use with mk[s]temp. Will fail (-1) if DIR is non-null and for use with mk[s]temp. Will fail (-1) if DIR is non-null and
doesn't exist, none of the searched dirs exists, or there's not doesn't exist, none of the searched dirs exists, or there's not
enough space in TMPL. */ enough space in TMPL. */
int int
__path_search (char *tmpl, size_t tmpl_len, const char *dir, const char *pfx, __path_search (char *tmpl, size_t tmpl_len, const char *dir, const char *pfx,
int try_tmpdir) int try_tmpdir)
{ {
const char *d; const char *d;
size_t dlen, plen; size_t dlen, plen;
if (!pfx || !pfx[0]) if (!pfx || !pfx[0])
{ {
pfx = "file"; pfx = "file";
plen = 4; plen = 4;
} }
else else
{ {
plen = strlen (pfx); plen = strlen (pfx);
if (plen > 5) if (plen > 5)
plen = 5; plen = 5;
} }
if (try_tmpdir) if (try_tmpdir)
{ {
d = __secure_getenv ("TMPDIR"); d = __secure_getenv ("TMPDIR");
if (d != NULL && direxists (d)) if (d != NULL && direxists (d))
dir = d; dir = d;
else if (dir != NULL && direxists (dir)) else if (dir != NULL && direxists (dir))
/* nothing */ ; /* nothing */ ;
else else
dir = NULL; dir = NULL;
} }
if (dir == NULL) if (dir == NULL)
{ {
if (direxists (P_tmpdir)) if (direxists (P_tmpdir))
dir = P_tmpdir; dir = P_tmpdir;
else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp")) else if (strcmp (P_tmpdir, "/tmp") != 0 && direxists ("/tmp"))
dir = "/tmp"; dir = "/tmp";
else else
{ {
__set_errno (ENOENT); __set_errno (ENOENT);
return -1; return -1;
} }
} }
dlen = strlen (dir); dlen = strlen (dir);
while (dlen > 1 && dir[dlen - 1] == '/') while (dlen > 1 && dir[dlen - 1] == '/')
dlen--; /* remove trailing slashes */ dlen--; /* remove trailing slashes */
/* check we have room for "${dir}/${pfx}XXXXXX\0" */ /* check we have room for "${dir}/${pfx}XXXXXX\0" */
if (tmpl_len < dlen + 1 + plen + 6 + 1) if (tmpl_len < dlen + 1 + plen + 6 + 1)
{ {
__set_errno (EINVAL); __set_errno (EINVAL);
return -1; return -1;
} }
sprintf (tmpl, "%.*s/%.*sXXXXXX", (int) dlen, dir, (int) plen, pfx); sprintf (tmpl, "%.*s/%.*sXXXXXX", (int) dlen, dir, (int) plen, pfx);
return 0; return 0;
} }
#endif /* _LIBC */ #endif /* _LIBC */
#if _LIBC
static int try_tempname_len (char *, int, void *, int (*) (char *, void *),
size_t);
#endif
static int
try_file (char *tmpl, void *flags)
{
int *openflags = flags;
return __open (tmpl,
(*openflags & ~O_ACCMODE)
| O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
}
static int
try_dir (char *tmpl, void *flags _GL_UNUSED)
{
return __mkdir (tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
}
static int
try_nocreate (char *tmpl, void *flags _GL_UNUSED)
{
struct_stat64 st;
if (__lstat64_time64 (tmpl, &st) == 0 || errno == EOVERFLOW)
__set_errno (EEXIST);
return errno == ENOENT ? 0 : -1;
}
/* These are the characters used in temporary file names. */ /* These are the characters used in temporary file names. */
static const char letters[] = static const char letters[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
/* Generate a temporary file name based on TMPL. TMPL must match the /* Generate a temporary file name based on TMPL. TMPL must match the
rules for mk[s]temp (i.e. end in "XXXXXX", possibly with a suffix). rules for mk[s]temp (i.e., end in at least X_SUFFIX_LEN "X"s,
possibly with a suffix).
The name constructed does not exist at the time of the call to The name constructed does not exist at the time of the call to
__gen_tempname. TMPL is overwritten with the result. this function. TMPL is overwritten with the result.
KIND may be one of: KIND may be one of:
__GT_NOCREATE: simply verify that the name does not exist __GT_NOCREATE: simply verify that the name does not exist
at the time of the call. at the time of the call.
__GT_FILE: create the file using open(O_CREAT|O_EXCL) __GT_FILE: create the file using open(O_CREAT|O_EXCL)
and return a read-write fd. The file is mode 0600. and return a read-write fd. The file is mode 0600.
__GT_DIR: create a directory, which will be mode 0700. __GT_DIR: create a directory, which will be mode 0700.
We use a clever algorithm to get hard-to-predict names. */ We use a clever algorithm to get hard-to-predict names. */
#ifdef _LIBC
static
#endif
int int
__gen_tempname (char *tmpl, int suffixlen, int flags, int kind) gen_tempname_len (char *tmpl, int suffixlen, int flags, int kind,
size_t x_suffix_len)
{
static int (*const tryfunc[]) (char *, void *) =
{
[__GT_FILE] = try_file,
[__GT_DIR] = try_dir,
[__GT_NOCREATE] = try_nocreate
};
return try_tempname_len (tmpl, suffixlen, &flags, tryfunc[kind],
x_suffix_len);
}
#ifdef _LIBC
static
#endif
int
try_tempname_len (char *tmpl, int suffixlen, void *args,
int (*tryfunc) (char *, void *), size_t x_suffix_len)
{ {
int len; size_t len;
char *XXXXXX; char *XXXXXX;
unsigned int count; unsigned int count;
int fd = -1; int fd = -1;
int save_errno = errno; int save_errno = errno;
struct_stat64 st;
/* A lower bound on the number of temporary files to attempt to /* A lower bound on the number of temporary files to attempt to
generate. The maximum total number of temporary file names that generate. The maximum total number of temporary file names that
can exist for a given template is 62**6. It should never be can exist for a given template is 62**6. It should never be
necessary to try all of these combinations. Instead if a reasonable necessary to try all of these combinations. Instead if a reasonable
number of names is tried (we define reasonable as 62**3) fail to number of names is tried (we define reasonable as 62**3) fail to
give the system administrator the chance to remove the problems. */ give the system administrator the chance to remove the problems.
This value requires that X_SUFFIX_LEN be at least 3. */
#define ATTEMPTS_MIN (62 * 62 * 62) #define ATTEMPTS_MIN (62 * 62 * 62)
/* The number of times to attempt to generate a temporary file. To /* The number of times to attempt to generate a temporary file. To
conform to POSIX, this must be no smaller than TMP_MAX. */ conform to POSIX, this must be no smaller than TMP_MAX. */
#if ATTEMPTS_MIN < TMP_MAX #if ATTEMPTS_MIN < TMP_MAX
unsigned int attempts = TMP_MAX; unsigned int attempts = TMP_MAX;
#else #else
unsigned int attempts = ATTEMPTS_MIN; unsigned int attempts = ATTEMPTS_MIN;
#endif #endif
/* A random variable. The initial value is used only the for fallback path
on 'random_bits' on 'getrandom' failure. Its initial value tries to use
some entropy from the ASLR and ignore possible bits from the stack
alignment. */
random_value v = ((uintptr_t) &v) / alignof (max_align_t);
/* How many random base-62 digits can currently be extracted from V. */
int vdigits = 0;
/* Whether to consume entropy when acquiring random bits. On the
first try it's worth the entropy cost with __GT_NOCREATE, which
is inherently insecure and can use the entropy to make it a bit
less secure. On the (rare) second and later attempts it might
help against DoS attacks. */
bool use_getrandom = tryfunc == try_nocreate;
/* Least unfair value for V. If V is less than this, V can generate
BASE_62_DIGITS digits fairly. Otherwise it might be biased. */
random_value const unfair_min
= RANDOM_VALUE_MAX - RANDOM_VALUE_MAX % BASE_62_POWER;
len = strlen (tmpl); len = strlen (tmpl);
if (len < 6 + suffixlen || memcmp (&tmpl[len - 6 - suffixlen], "XXXXXX", 6)) if (len < x_suffix_len + suffixlen
|| strspn (&tmpl[len - x_suffix_len - suffixlen], "X") < x_suffix_len)
{ {
__set_errno (EINVAL); __set_errno (EINVAL);
return -1; return -1;
} }
/* This is where the Xs start. */ /* This is where the Xs start. */
XXXXXX = &tmpl[len - 6 - suffixlen]; XXXXXX = &tmpl[len - x_suffix_len - suffixlen];
uint64_t pid = (uint64_t) __getpid () << 32;
for (count = 0; count < attempts; ++count) for (count = 0; count < attempts; ++count)
{ {
uint64_t v; for (size_t i = 0; i < x_suffix_len; i++)
/* Get some more or less random data. */ {
RANDOM_BITS (v); if (vdigits == 0)
v ^= pid; {
do
/* Fill in the random bits. */ {
XXXXXX[0] = letters[v % 62]; v = random_bits (v, use_getrandom);
v /= 62; use_getrandom = true;
XXXXXX[1] = letters[v % 62]; }
v /= 62; while (unfair_min <= v);
XXXXXX[2] = letters[v % 62];
v /= 62; vdigits = BASE_62_DIGITS;
XXXXXX[3] = letters[v % 62]; }
v /= 62;
XXXXXX[4] = letters[v % 62]; XXXXXX[i] = letters[v % 62];
v /= 62; v /= 62;
XXXXXX[5] = letters[v % 62]; vdigits--;
}
switch (kind)
{
case __GT_FILE:
fd = __open (tmpl,
(flags & ~O_ACCMODE)
| O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
break;
case __GT_DIR:
fd = __mkdir (tmpl, S_IRUSR | S_IWUSR | S_IXUSR);
break;
case __GT_NOCREATE:
/* This case is backward from the other three. __gen_tempname
succeeds if __xstat fails because the name does not exist.
Note the continue to bypass the common logic at the bottom
of the loop. */
if (__lxstat64 (_STAT_VER, tmpl, &st) < 0)
{
if (errno == ENOENT)
{
__set_errno (save_errno);
return 0;
}
else
/* Give up now. */
return -1;
}
continue;
default:
assert (! "invalid KIND in __gen_tempname");
abort ();
}
fd = tryfunc (tmpl, args);
if (fd >= 0) if (fd >= 0)
{ {
__set_errno (save_errno); __set_errno (save_errno);
return fd; return fd;
} }
else if (errno != EEXIST) else if (errno != EEXIST)
return -1; return -1;
} }
/* We got out of the loop because we ran out of combinations to try. */ /* We got out of the loop because we ran out of combinations to try. */
__set_errno (EEXIST); __set_errno (EEXIST);
return -1; return -1;
} }
int
__gen_tempname (char *tmpl, int suffixlen, int flags, int kind)
{
return gen_tempname_len (tmpl, suffixlen, flags, kind, 6);
}
#if !_LIBC
int
try_tempname (char *tmpl, int suffixlen, void *args,
int (*tryfunc) (char *, void *))
{
return try_tempname_len (tmpl, suffixlen, args, tryfunc, 6);
}
#endif
 End of changes. 43 change blocks. 
119 lines changed or deleted 162 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)