Question: I have been following a system programming course recently and I came through the system calls **exec()** and **execve()**. So far I cannot find any difference between these two, Even the Wikipedia does not give a clear explanation, so is there a difference between **exec()** and **execve()**. 

And someone please could give brief descriptions about exec family system calls such as **execl()**, **execv()**, **execle()**, **execvp()**.

Answer: 
There is no `exec` system call -- this is usually used to refer to all the `execXX` calls as a group. They all do essentially the same thing: loading a new program into the current process, and provide it with arguments and environment variables. The differences are in how the program is found, how the arguments are specified, and where the environment comes from.

* The calls with `v` in the name take an array parameter to specify the `argv[]` array of the new program. The end of the arguments is indicated by an array element containing `NULL`.
* The calls with `l` in the name take the arguments of the new program as a variable-length argument list to the function itself. The end of the arguments is indicated by a `(char *)NULL` argument. You should always include the type cast, because `NULL` is allowed to be an integer constant, and default argument conversions when calling a variadic function won't convert that to a pointer.
* The calls with `e` in the name take an extra argument (or arguments in the `l` case) to provide the environment of the new program; otherwise, the program inherits the current process's environment. This is provided in the same way as the `argv` array: an array for `execve()`, separate arguments for `execle()`.
* The calls with `p` in the name search the `PATH` environment variable to find the program if it doesn't have a directory in it (i.e. it doesn't contain a `/` character). Otherwise, the program name is always treated as a path to the executable.
* FreeBSD 5.2 added another variant: `execvP` (with uppercase `P`). This is like `execvp()`, but instead of getting the search path from the `PATH` environment variable, it's an explicit parameter to the function:

```
int execvP(const char *file, const char *search_path, char *const argv[]);

```
The arguments are different for these functions.

* The function execl, execlp, and execle require each of the command line arguments to the new program to be specified as separate arguments.
* The execv, execvp and execve, we have to build an array of pointers to the arguments, and the address of this array is the argument to these three functions.
* The execve, execle functions allow us to pass the pointer to an array of pointers to the environment strings. The other four functions use the `environ` variable in the calling process to copy the existing environment to the program.
* The letter `p` means that the functions takes a file name argument and uses the PATH environment variable to find the executable file.
* The letter `l` means that the function takes a list of arguments and is mutually exclusive with the letter `v`, which means that it takes an argv[] vector.
* The letter `e` means that the function takes an `envp[]` array instead of using the current environment.
* The new program inherits the following additional features from the calling process.

```none
    Process ID and the Parent Process ID
    Real user ID and Real Group ID
    Supplementary group IDs
    Process group ID
    Session ID
    Controlling terminal
    Time left until alarm clock
    Current working directory
    Root directory
    File mode creation mask
    File locks
    Process signal mask
    Pending signals
    Resource limits
    Values for tms_utime, tms_stime, tms_cutime, and tms_cstime.

```

* The real user ID and the real group ID remain the same across the exec but the effective IDs can change, depending on the status of the set-user-id and the set-group-id bits for the program file executed.