Linux system Programming-process substitution: Exec function family

Under the Windows platform, we can run the executable program by double-clicking, let this executable program become a process, and on the Linux platform, we can pass ./ Run, let an executable program become a process.

However, if we are running a program (process), how do we start an external program inside the process, and the kernel reads the external program into memory so that it executes as a process? Here we implement through the EXEC function family.

The EXEC function family, as the name implies, is a cluster of functions, in Linux, there is no exec () function, exec refers to a set of functions, a total of 6:

2. int execl (const Char *path, const char *arg, ...);
4. int EXECLP (const Char *file, const char *arg, ...);
6. int execle (const Char *path, const char *arg, ..., char * const envp[]);
8. int Execv (const Char *path, char *const argv[]);
10. int EXECVP (const Char *file, char *const argv[]);
11. int Execve (const Char *path, char *const argv[], char *const envp[]), where only Execve () is the true meaning of system tuning and others are packaged library functions on this basis.

    The EXEC function family provides six ways to start another program in the process . The function of the EXEC function family is to find the executable file based on the specified file name or directory name, and use it to replace the contents of the calling process, in other words , execute an executable file inside the calling process.

    When a process calls an EXEC function, the process is completely replaced by the new program, and the new program executes from its main function. Because calling exec does not create a new process, the process ID of the front and back (and of course the parent process number, the process group number, the current working directory ...). ) has not changed. exec simply replaces the body, data, heap, and stack (process substitution) of the current process with another new program.

    The 6 functions of the EXEC function family seem to be complex, but in fact they are very similar in function and usage, with only a small difference.

    L (list): The parameter address list, ending with a null pointer.

    V (vector): The address of an array of pointers that hold the address of each parameter.

    P (Path): Searches the executable file by the directory specified by the PATH environment variable.

    E (Environment): The address of an array of pointers containing the environment variable string addresses.

    The EXEC function family loads and runs the executable program Path/file and passes the parameter arg0 (arg1, Arg2, argv[], envp[]) to the program.

    The EXEC function family differs from the normal function in that the function of the EXEC function family does not return after successful execution, and thecode below the EXEC function family does not execute . Only if the call fails, they return 1, and then execute from the original program's point of invocation after the failure. execl () sample code:

    2. #include <unistd.h>
    4. int main (int argc, char *argv[])
    6. {
    8. printf ("before exec\n\n");
    10. / */bin/ls: External program, here is the LS executable of the/bin directory, must take the path (relative or absolute)
    12. LS: There is no point, if you need to send this external program, you must write the string, as the string content arbitrary
    14. -a,-l,-h: parameter to the external program LS Pass
    16. NULL: This must be written on behalf of the external program LS to end the argument
    18. */
    20. Execl ("/bin/ls", "ls", "-a", "-L", "-H", NULL);
    22. //If EXECL () execution succeeds, the following cannot be performed because the current process has been executed by LS replaced by the
    24. Perror ("execl");
    26. printf ("after exec\n\n");
    28. return 0;
    29. }

        The results of the operation are as follows:

        EXECV () Sample code:

        The usage of EXECV () and execl () is basically the same, instead of using a pointer array to pass the list to the parameter.

        2. int main (int argc, char *argv[])
        4. {
        6. The use of//EXECV () and execl () is basically the same, but instead of using a pointer array to pass a list of arguments
        8. //Execl ("/bin/ls", "ls", "-a", "-L", "-H", NULL);
        10. / * pointer array
        12. LS: There is no point, if you need to send this external program, you must write the string, as the string content arbitrary
        14. -a,-l,-h: parameter to the external program LS Pass
        16. NULL: This must be written on behalf of the external program LS to end the argument
        18. */
        20. char *arg[]={"ls", "-a", "-L", "-H", NULL};
        22. ///BIN/LS: External program, here is the LS executable of the/bin directory, must take the path (relative or absolute)
        24. //ARG: The pointer array address defined above
        26. Execv ("/bin/ls", Arg);
        28. Perror ("Execv");
        30. return 0;
        31. }EXECLP () or EXECL () sample code:

            The difference between EXECLP () and Execl () is that the executable program specified by EXECLP () may not have a pathname, and if it does not have a pathname, it will look for the executable in the directory specified by the environment variable path, and the executable program specified by EXECL () must take the path name.

            2. #include <stdio.h>
            4. #include <unistd.h>
            6. int main (int argc, char *argv[])
            8. {
            10. //The first parameter "ls", without path name, in the environment variable path search for this executable program
            12. //Other parameter usage same as EXECL ()
            14. EXECLP ("ls", "ls", "-a", "-L", "-H", NULL);
            16. /* 
            18. char *arg[]={"LS", "-a", "-L", "-H", NULL};
            20. EXECVP ("LS", ARG);
            22.     */  
            24. Perror ("EXECLP");
            26. return 0;
            27. }

                Execle () or EXECVE () sample code:

                Execle () and Execve () change the environment variables of the exec-initiated program (which only alters the environment variables of the process, does not affect the environment variables of the system ), and the other four function-initiated programs use the default system environment variables.

                Execle () Sample code:

                2. #include <stdio.h>
                4. #include <unistd.h>
                6. #include <stdlib.h>//getenv ()
                8. int main (int argc, char *argv[])
                10. { //getenv () Gets the value of the specified environment variable
                12. printf ("before exec:user=%s, home=%s\n", getenv ("USER"), getenv ("HOME"));
                14. //Pointer data
                16. Char *env[]={"User=mike", "Home=/tmp", NULL};
                18. /*/mike: External program, current path of the Mike program, compiled by GCC mike.c-o Mike
                20. Mike: There's no point here.
                22. NULL: End of argument to Mike Program
                24. ENV: Change the environment variables of the Mike program, correctly, let the Mike program keep only env environment variables
                26. */
                28. Execle ("./mike", "Mike", NULL, env);
                30. /* 
                32. Char *arg[]={"Mike", NULL};
                34. Execve ("./mike", ARG, env);
                36.     */  
                38. Perror ("execle");
                40. return 0;
                42. }
                External program, MIKE.C sample code:
                2. #include <stdio.h>
                4. #include <stdlib.h>
                6. #include <unistd.h>
                8. int main (int argc, char *argv[])
                10. {
                12. printf ("\nin The mike Fun, after exec: \ n");
                14. printf ("user=%s\n", getenv ("USER"));
                16. printf ("home=%s\n", getenv ("HOME"));
                18. return 0;
                20. }
                22. The results of the operation are as follows:

Linux system Programming-process substitution: Exec function family