Do envz_get and getenv reference the same pool of environment variables?

Question

Do getenv() and envz_get() both look up environment variables from the same source if the latter is passed the optional envp argument to int main (int argc, char *argv[], char *envp[])?

In other words, does the optional envp argument to int main (int argc, char *argv[], char *envp[]) refer to the same pool of environment variables that is referenced by getenv()?

did you try to print the pointer address of each `envp` and see where it is stored ? Maybe it's on the stack. — alinsoar, Feb 07 '19 at 07:36

score 1 · Accepted Answer · answered Feb 07 '19 at 07:29

In my experience, yes, they are identical. It doesn't seem like getenv() would be particularly useful if they weren't. This isn't something I'd tested in decades, but in response to your question, I just ran a test, and while getenv() is allowed by the standard to use a static memory area for its returns, its return values all pointed to the first character after the equal sign in the third argument to main. It's my vague recollection this happened the last time I did this test, too, though that was a different unix system.

That having been said, looking at the standard, or as close as I can reasonably come to that... From the last free proposed C17 draft:

The getenv function searches an environment list, provided by the host environment, for a string that matches the string pointed to by name . The set of environment names and the method for altering the environment list are implementation-defined. The getenv function need not avoid data races with other threads of execution that modify the environment list. 305)

The implementation shall behave as if no library function calls the getenv function. Returns The getenv function returns a pointer to a string associated with the matched list member. The string pointed to shall not be modified by the program, but may be overwritten by a subsequent call to the getenv function. If the specified name cannot be found, a null pointer is returned.

305) Many implementations provide non-standard functions that modify the environment list.

Which basically means, probably, but the C language doesn't exactly guarantee it.

Florian Weimer · Answer 2 · 2019-02-09T18:05:44.997

The strings used by the environment variables in the current process state are not necessarily in contiguous memory. Some environment variables may have been removed by the startup code, or changed or added by a call to putenv or setenv. These changes are not necessarily reflected in the array of strings that envz_get examines because they are performed by changing the pointers (not the strings) in the environment array.

Here's an example that demonstrates this:

#include <assert.h>
#include <envz.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int
main (int argc, char **argv, char **envp)
{ 
  assert (envp[0] != NULL);
  assert (envp[1] != NULL);
  char *first_name = strndup (envp[0], strcspn (envp[0], "="));
  char *second_name = strndup (envp[1], strcspn (envp[1], "="));

  printf ("removing: %s\n", second_name);
  unsetenv (second_name);

  printf ("getenv (%s): %s\n", first_name, getenv (first_name));
  size_t size = 0;
  for (size_t i = 0; envp[i] != NULL; ++i)
    size += strlen (envp[i]) + 1;
  printf ("envz_get (%s): %s\n",
          first_name, envz_get (envp[0], size, first_name));

  printf ("getenv (%s): %s\n",
          second_name, getenv (second_name));
  printf ("envz_get (%s): %s\n",
          second_name, envz_get (envp[0], size, second_name));
}

On my system, it prints this:

removing: LESSCLOSE
getenv (STY): 9173.pts-0.deneb
envz_get (STY): 9173.pts-0.deneb
getenv (LESSCLOSE): (null)
envz_get (LESSCLOSE): /usr/bin/lesspipe %s %s

score 0 · Answer 3 · answered Feb 08 '19 at 06:33

The following proves that envp references a pool that is at least a subset of the pool that getenv() draws from; and I'm inclined to think that they are, in practice, the same outright.

#include <iostream>
#include <vector>

int main( int argc, char* argv[], char* envp[] )
{
  std::vector<std::string> fromEnvP;

  while ( *envp ) fromEnvP.push_back( *envp++ );

  std::vector<std::string> fromEnv;

  for( std::vector<std::string>::iterator i = fromEnvP.begin();
       i != fromEnvP.end();
       ++i )
  {
    std::string::size_type pos = i->find( '=' );
    std::string varname( i->substr( 0, pos ) );
    fromEnv.push_back( varname + "=" + getenv( varname.c_str() ) );
  }

  std::cout << std::boolalpha << ( fromEnvP == fromEnv ) << std::endl;

  return 0;
}

.

> g++ main.cpp && ./a.exe
true

The program compares the contents of the `envp` array to what `getenv` returns. That is not the question; `envz_get` does something else. — Florian Weimer, Feb 09 '19 at 17:49

Do envz_get and getenv reference the same pool of environment variables?

3 Answers3