rm_/lib/putenv.c
2020-09-02 16:47:03 +08:00

195 lines
4.9 KiB
C

/* Copyright (C) 1991, 1994, 1997-1998, 2000, 2003-2020 Free Software
Foundation, Inc.
NOTE: The canonical source of this file is maintained with the GNU C
Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
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 the
Free Software Foundation; either version 3 of the License, or any
later version.
This program 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 <https://www.gnu.org/licenses/>. */
#include <config.h>
/* Specification. */
#include <stdlib.h>
#include <stddef.h>
/* Include errno.h *after* sys/types.h to work around header problems
on AIX 3.2.5. */
#include <errno.h>
#ifndef __set_errno
# define __set_errno(ev) ((errno) = (ev))
#endif
#include <string.h>
#include <unistd.h>
#if defined _WIN32 && ! defined __CYGWIN__
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
#endif
#if _LIBC
# if HAVE_GNU_LD
# define environ __environ
# else
extern char **environ;
# endif
#endif
#if _LIBC
/* This lock protects against simultaneous modifications of 'environ'. */
# include <bits/libc-lock.h>
__libc_lock_define_initialized (static, envlock)
# define LOCK __libc_lock_lock (envlock)
# define UNLOCK __libc_lock_unlock (envlock)
#else
# define LOCK
# define UNLOCK
#endif
static int
_unsetenv (const char *name)
{
size_t len;
#if !HAVE_DECL__PUTENV
char **ep;
#endif
if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
{
__set_errno (EINVAL);
return -1;
}
len = strlen (name);
#if HAVE_DECL__PUTENV
{
int putenv_result, putenv_errno;
char *name_ = malloc (len + 2);
memcpy (name_, name, len);
name_[len] = '=';
name_[len + 1] = 0;
putenv_result = _putenv (name_);
putenv_errno = errno;
free (name_);
__set_errno (putenv_errno);
return putenv_result;
}
#else
LOCK;
ep = environ;
while (*ep != NULL)
if (!strncmp (*ep, name, len) && (*ep)[len] == '=')
{
/* Found it. Remove this pointer by moving later ones back. */
char **dp = ep;
do
dp[0] = dp[1];
while (*dp++);
/* Continue the loop in case NAME appears again. */
}
else
++ep;
UNLOCK;
return 0;
#endif
}
/* Put STRING, which is of the form "NAME=VALUE", in the environment.
If STRING contains no '=', then remove STRING from the environment. */
int
putenv (char *string)
{
const char *name_end = strchr (string, '=');
char **ep;
if (name_end == NULL)
{
/* Remove the variable from the environment. */
return _unsetenv (string);
}
#if HAVE_DECL__PUTENV
/* Rely on _putenv to allocate the new environment. If other
parts of the application use _putenv, the !HAVE_DECL__PUTENV code
would fight over who owns the environ vector, causing a crash. */
if (name_end[1])
return _putenv (string);
else
{
/* _putenv ("NAME=") unsets NAME, so invoke _putenv ("NAME= ")
to allocate the environ vector and then replace the new
entry with "NAME=". */
int putenv_result, putenv_errno;
char *name_x = malloc (name_end - string + sizeof "= ");
if (!name_x)
return -1;
memcpy (name_x, string, name_end - string + 1);
name_x[name_end - string + 1] = ' ';
name_x[name_end - string + 2] = 0;
putenv_result = _putenv (name_x);
putenv_errno = errno;
for (ep = environ; *ep; ep++)
if (strcmp (*ep, name_x) == 0)
{
*ep = string;
break;
}
# if defined _WIN32 && ! defined __CYGWIN__
if (putenv_result == 0)
{
/* _putenv propagated "NAME= " into the subprocess environment;
fix that by calling SetEnvironmentVariable directly. */
name_x[name_end - string] = 0;
putenv_result = SetEnvironmentVariable (name_x, "") ? 0 : -1;
putenv_errno = ENOMEM; /* ENOMEM is the only way to fail. */
}
# endif
free (name_x);
__set_errno (putenv_errno);
return putenv_result;
}
#else
for (ep = environ; *ep; ep++)
if (strncmp (*ep, string, name_end - string) == 0
&& (*ep)[name_end - string] == '=')
break;
if (*ep)
*ep = string;
else
{
static char **last_environ = NULL;
size_t size = ep - environ;
char **new_environ = malloc ((size + 2) * sizeof *new_environ);
if (! new_environ)
return -1;
new_environ[0] = string;
memcpy (new_environ + 1, environ, (size + 1) * sizeof *new_environ);
free (last_environ);
last_environ = new_environ;
environ = new_environ;
}
return 0;
#endif
}