C execve() parameters [spawn a shell example]

Question

I have to fill the parameters for:

int execve(const char *filename, char *const argv[], char *const envp[]);

If I execute this program:

#include <unistd.h>
int main() {
        char *args[2];
        args[0] = "/bin/sh";
        args[1] = NULL;
        execve(args[0], args, NULL);
}

the shell is spawned correctly as expected.

My problem is that the shell is spawned correctly also if I pass a NULL as second parameter like that:

#include <unistd.h>

int main() {
        char *args[2];
        args[0] = "/bin/sh";
        args[1] = NULL;
        execve(args[0], NULL, NULL);
}

So what's the purpose to use the args vector (with the "/bin/sh" + NULL) as second parameter instead of a NULL?

In this case, you're not passing any arguments, so there is no difference. You could choose to pass some argument within `args`. — Anirudh Ramanathan, May 10 '15 at 09:29
And so, why in all the example I see, people use to pass the /bin/sh + NULL as arg? It's simpler to understand with the arg parameter directly set to NULL. — rh0x, May 10 '15 at 09:37
It's probably because it's an example to understand that if I pass some parameters, there must be a NULL as string terminator? — rh0x, May 10 '15 at 09:44
Write yourself a C program which prints out the arguments, you should see a difference if you call it with your two sample programs. — dav1d, May 10 '15 at 09:44

score 5 · Accepted Answer · answered May 10 '15 at 09:48

In this line: execve(args[0], NULL, NULL); you are simply using the first element of args array. You could also use something like char* command="/bin/sh". You have to pass something, because that's how execve() was defined. In your case you pass NULL because you don't need to pass anything.

The point of the second argument of execve() is to pass arguments to the command you are spawning. Suppose that instead of shell you simply want to execute ls, you could then pass f.e. these arguments:

#include <unistd.h>
int main() {
        char *args[2];
        args[0] = "/bin/ls";
        args[1] = "-lh";
        execve(args[0], args, NULL);
}

Also, quoting man execve:

argv is an array of argument strings passed to the new program. By convention, the first of these strings should contain the filename associated with the file being executed. envp is an array of strings, conventionally of the form key=value, which are passed as environment to the new program.

You need `NULL` in the last element of `args`. – scrutari Nov 24 '22 at 11:45 — scrutari, Nov 24 '22 at 11:45

score 5 · Answer 2 · answered Sep 22 '17 at 16:49

If you pass a null pointer as the second, or the third, argument of execve, your program is incorrect according to POSIX; both of these arguments are required to be non-null. (This is not all that clearly stated in the specification of execve, but it's in there.) I am currently typing this on an operating system that treats passing null pointers,

execve("executable", 0, 0);

as equivalent to passing empty arrays, e.g.

execve("executable", (char *[]){0}, (char *[]){0});

but it would not surprise me to learn that other operating systems would fire a segmentation fault or return -1 with errno set to EFAULT or EINVAL.

Passing empty arrays for these arguments is allowed, but the newly executed program will receive zero arguments in argc/argv if the second argument is an empty array, and/or zero environment variables in envp/environ if the third argument is an empty array. Many programs will malfunction under these conditions. For instance, it is very common to see things like

int main(int argc, char **argv)
{
   if (argc != 4) {
     fprintf(stderr, "usage: %s one two three\n", argv[0]);
     return 2;
   }
   // ...
}

where the program implicitly assumes that argv[0] will always be non-null.

So, you should always provide non-empty arrays for both arguments. The usual convention is that if you don't have anything else to do, you use

execve(program, (char *[]){program, 0}, environ);

which supplies the program's own name as argv[0] and no further arguments, and the same set of environment variables you got from your own parent.

C execve() parameters [spawn a shell example]

2 Answers2

Linked

Related