A veces es necesario llamar a una aplicación de terceros en una aplicación, lo cual es un requisito común. En este momento, puede usar el comando exec o el comando del sistema en Linux para lograr el objetivo. Pero, ¿cuál de los dos elegir? ¿Cual es la diferencia? Lo siguiente es un resumen.

Introducción a exec y sistema.

En Linux, el comando `exec` se usa para ejecutar un nuevo programa en el proceso actual. Reemplaza el contenido del proceso actual y lo reemplaza con un nuevo programa. El comando `exec` acepta dos argumentos, el primer argumento es la ruta al programa a ejecutar, y el segundo argumento es una matriz de cadenas para los argumentos de la línea de comandos pasados al nuevo programa.

El comando `system` también se usa para ejecutar un nuevo programa en el proceso actual, pero lo hace invocando el shell. El comando `system` acepta un argumento de cadena que contiene el comando a ejecutar. Crea un nuevo proceso de shell y ejecuta el comando especificado en ese proceso.

La principal diferencia entre `exec` y `system` es cómo se implementan y para qué se utilizan. `exec` ejecuta un nuevo programa directamente en el proceso actual, mientras que `system` ejecuta comandos llamando al shell. Por lo tanto, `exec` es más eficiente porque evita la sobrecarga de crear un nuevo proceso y shell. Además, `exec` generalmente se usa para ejecutar otros programas ejecutables en el proceso actual, mientras que `system` es más adecuado para ejecutar scripts y comandos de shell. exec es un término general para una serie de interfaces funcionales, que en realidad se dividen en varias versiones de interfaz funcional.

Funciones de la familia ejecutiva:

       int execl(const char *path, const char *arg, ...);
       int execlp(const char *file, const char *arg, ...);
       int execle(const char *path, const char *arg,..., char * const envp[]);
       int execv(const char *path, char *const argv[]);
       int execvp(const char *file, char *const argv[]);
       int execvpe(const char *file, char *const argv[],char *const envp[]);

como escoger

En Linux, exec y system son dos comandos diferentes que se utilizan para ejecutar programas externos.

exec es una llamada al sistema que se puede usar para ejecutar un nuevo programa y reemplazar el contenido del proceso actual. Debe proporcionar una ruta a un archivo ejecutable y argumentos de línea de comando, y luego reemplazará el proceso actual con el programa especificado. El comando execvp es un comando de bajo nivel que permite un control más preciso sobre el proceso de ejecución, pero no crea nuevos procesos.

system es una función de biblioteca que se puede utilizar para ejecutar un comando. Toma un argumento de cadena que es el comando a ejecutar, luego crea un nuevo proceso para ejecutar el comando. El comando del sistema es un comando de alto nivel, que es más simple y fácil de usar, pero su capacidad de control es más débil.

La elección de usar exec o sistema depende de sus necesidades. Use exec si necesita un control más detallado. Por ejemplo, si necesita reemplazar el contenido del proceso actual o necesita realizar algunas operaciones específicas en el proceso secundario, entonces exec puede ser más adecuado. Por otro lado, si simplemente ejecuta un comando y desea obtener el resultado, entonces el sistema puede ser más conveniente.

void set_gpio64_low(void)
{	
	system("echo 64 > /sys/class/gpio/export");
	system("echo out > /sys/class/gpio/gpio64/direction");
	system("echo 0 > /sys/class/gpio/gpio64/value");
}

Uso básico del comando `exec`

#include <unistd.h>

int execvp(const char *file, char *const argv[]);

Para ejecutar un script de shell, pase la ruta al intérprete de shell como primer argumento, la ruta al archivo de script como segundo argumento y pase los otros argumentos como una matriz de cadenas.

Aquí hay un ejemplo que muestra cómo ejecutar un script de shell usando el comando `execvp`:

#include <unistd.h>
#include <stdio.h>

int main() {
    char *const argv[] = {"./script.sh", NULL};
    execvp("/bin/sh", argv);
    printf("execvp failed\n");
    return 0;
}

En el ejemplo anterior, `./script.sh` es la ruta al script de shell que se ejecutará. `/bin/sh` es la ruta al intérprete de shell. `NULL` indica el final de la matriz de parámetros.

Tenga en cuenta que después de ejecutar con éxito el comando `execvp`, el proceso actual se reemplazará con un nuevo programa, por lo que no se ejecutará el código posterior. Si el comando `execvp` falla, devolverá -1 y el mensaje de error se puede imprimir usando la función `perror`.

Asegúrese de que el archivo de script tenga permiso de ejecución antes de ejecutar el comando `execvp`. Se pueden agregar permisos de ejecución a los archivos de secuencias de comandos mediante el comando `chmod`.

Después de ejecutar con éxito el comando `execvp`, el proceso actual se reemplazará con un nuevo programa y los códigos subsiguientes no se ejecutarán. Si desea continuar ejecutando el código después de ejecutar el comando `execvp`, puede usar la función `fork` para crear un proceso secundario, llamar al comando `execvp` en el proceso secundario y el proceso principal puede continuar ejecutándose posteriormente. código.

Aquí hay un código de muestra:

#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程中执行新的程序
        char *args[] = {"ls", "-l", NULL};
        execvp("ls", args);
    } else if (pid > 0) {
        // 父进程中继续执行后续代码
        printf("This is the parent process.\n");
        // 可以添加其他代码
    } else {
        // fork失败
        printf("Fork failed.\n");
        return 1;
    }

    return 0;
}

En el código anterior, el comando `execvp` se llama en el proceso secundario para ejecutar el comando `ls -l`, mientras que el proceso principal continúa ejecutando el código subsiguiente.

Si desea llamar a otras aplicaciones cuando se cumplen las condiciones en su aplicación, considere usar una combinación de bifurcación y execvp. Use fork para crear un proceso secundario y use execvp para ejecutar otras aplicaciones en el proceso secundario, lo que puede evitar reemplazar el proceso actual y puede continuar ejecutando el código posterior en el proceso principal.

La diferencia entre system y execl

el sistema iniciará un nuevo proceso secundario para llamar al comando que se ejecutará. Y exec simplemente reemplaza los segmentos de cuerpo, datos, montón y pila del proceso actual con otro programa nuevo.

int system(const char * cmdstring){
    pid_t pid;
    int status;
    if(cmdstring == NULL){
        return (1);
    }
    if((pid = fork())<0){
        status = -1;
    }else if(pid == 0){
        execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);//底层就是execl
        exit(127); //子进程正常执行则不会执行此语句
    }else{
     while(waitpid(pid, &status, 0) < 0){
          if(errno != EINTER){
              status = -1;
              break;
          }
     }
    }
    return status;
}

Manejar adecuadamente `execvp` los escenarios de error de llamada de función y los mensajes de salida correspondientes

Tenga en cuenta que exec la familia de funciones solo regresará si ocurre un error, así que implemente rutinas de verificación de errores y maneje las rutas de código apropiadas según sea necesario.
Que execvp regresa en caso de falla -1, y también establece errno la variable. Tenga en cuenta, sin embargo, errno que debe establecerse explícitamente en 0 antes de la llamada de función, y el valor solo se verifica después de que regresa una llamada determinada. execvp La función puede aceptar un nombre de archivo sin una barra inclinada, lo que significa que el archivo se PATH busca en el directorio especificado por la variable de entorno.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
int main(void) {
    const char *args[] = { "vim", "/home/ben/tmp3.txt", NULL };
    execvp("vim", args);
    exit(EXIT_SUCCESS);
}

Supongamos que el usuario necesita crear un nuevo proceso y ejecutar un código de programa dado, entonces en este caso podemos usar la combinación de fork llamada de función y execvpEn este caso, podemos aprovechar fork las llamadas a funciones execvp combinadas con . fork Duplica el proceso de llamada y crea un nuevo proceso llamado -child. En el siguiente ejemplo, implementamos un contenedor de función personalizado para crear un nuevo proceso y cargar/ejecutar el código de programa dado. Tenga en cuenta que una vez que se crea el proceso secundario, ejecuta un código diferente, mientras que el proceso principal espera hasta que finaliza el proceso secundario.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/wait.h>

pid_t spawnChild(const char* program, char** arg_list)
{
    pid_t ch_pid = fork();
    if (ch_pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if (ch_pid > 0) {
        printf("spawn child with pid - %d\n", ch_pid);
        return ch_pid;
    } else {
        execvp(program, arg_list);
        perror("execve");
        exit(EXIT_FAILURE);
    }
}

int main(void) {

    const char *args[] = { "vim", "/home/ben/tmp3.txt", NULL };
    pid_t child;
    int wstatus;
    child = spawnChild("vim", args);
    if (waitpid(child, &wstatus, WUNTRACED | WCONTINUED) == -1) {
        perror("waitpid");
        exit(EXIT_FAILURE);
    }
    exit(EXIT_SUCCESS);
}