Cómo llamar comandos de shell en lenguaje c en Linux
System() no requiere que usted genere el proceso usted mismo. Ha sido encapsulado, por lo que puedes agregar tus propios comandos directamente.
Exec necesita su propio proceso de bifurcación y luego ejecuta su propio comando.
Popen() también puede ejecutar tus comandos y es más económico que el sistema.
Método 1, utilizar system(). Codificaré
int system (const char * comando);
Creé un nuevo archivo test.sh en /home/book/shell de la siguiente manera:
& ltspan style = " font-size:18px;"& gt& ltspan style = " font-size:18px;"& gt#!bin/bash
echo $HOME
Echo "¡Es una prueba!"</span>. </span>.
El archivo test.c es el siguiente:
& ltspan style = " font-size:18px;"& gt& ltspan style = " font-size:18px;"& gt # incluir & ltstdlib.h & gt
int main()
{
system(" bash/home/book/shell/test . sh ") ; /* chmod +x test.sh y bash */
Devuelve 0;
} & lt/span>. </span>.
Por ejemplo, ejecute el siguiente comando para compilar:
& ltspan style = "font-size:18px;"& gtgcc test
& lt/span> .
Comando de prueba:
& ltspan style = "font-size:18px;"& gt. /prueba</span>.
Los resultados son los siguientes:
& ltspan style = "font-size:18px;"& gt/root
¡está probado! </span>.
Método 2: popen() llamará a fork() para generar un proceso hijo y luego llamará a /bin/sh -c desde el proceso hijo para completar las instrucciones del comando de parámetros. Los tipos de parámetros se pueden leer con "r". La "w" significa escritura. Siga este tipo de valor. Popen() establecerá una tubería hacia el dispositivo de salida estándar o el dispositivo de entrada estándar del proceso hijo y luego devolverá un puntero de archivo.
El proceso puede usar este puntero de archivo para leer desde el dispositivo de salida del proceso hijo o escribirlo en el dispositivo de entrada estándar del proceso hijo. Además, también se pueden aplicar todas las funciones que aplican operaciones de puntero de archivo (FILE*), excepto fclose().
Valor de retorno: si tiene éxito, devuelve el puntero del archivo; de lo contrario, devuelve NULL y la causa del error se almacena en errno. Nota: Al escribir programas con permisos SUID/SGID, intente evitar el uso de popen(). Popen() hereda variables de entorno. Las variables de entorno pueden causar problemas de seguridad del sistema.
FILE * popen(const char *command, const char *type);
int pclose(FILE * stream
Otros no necesitan serlo); cambió.
Cambiemos el archivo test.c directamente:
# include & ltstdio.h & gt
int main()
{
Cargar buffer[80];
FILE * FP = popen(" bash/home/book/shell/test . sh ", " r "); (búfer), FP);
printf("%s", búfer);
pclose(FP);
p>
}
Método 3: grupo de funciones ejecutivas (no lo entiendo bien, copié el de otras personas). Sin verificación. Método habitual 1)
Cabe señalar que exec no es una función. De hecho, es solo un conjunto de funciones, incluidas las siguientes seis funciones:
# include & ltunistd.h & gt
int execl(const char *path, const char * arg. ..);
int execlp(const char *archivo, const char *arg,...);
int execle(const char *ruta, const char *arg , .., char * const envp[]);
int execv(const char *ruta, char * const argv[]); , char * const argv[]);
int execve(const char *path, char *const argv[], char * const envp[];
Se puede ver que estos seis Los nombres de las funciones son diferentes y los parámetros que aceptan también son diferentes.
De hecho, sus funciones son similares. Debido a que se utilizan para aceptar diferentes parámetros, deben distinguirse por nombres diferentes. Después de todo, no hay funciones en lenguaje C. Funciones sobrecargadas.
Pero, de hecho, sus nombres son regulares:
exec[l o v][p][e. ]
Los parámetros en la función ejecutiva se pueden dividir en tres partes: la parte del archivo en ejecución, la parte del parámetro de comando y la parte de la variable de entorno.
Por ejemplo, quiero ejecutar. el comando 1 ls -l /home/gateman
La parte del archivo en ejecución es "/usr/bin/ls"
La parte de entrada del comando es "ls", "-l", "/home/gateman". Cuando ve nulo, es ls. Al principio, cada espacio debe dividirse en dos partes y terminar con
parte de variable de entorno. es una matriz, el último elemento debe ser NULL, como char * env[]= { " path =/home/gateman","user=lei","status=testing",NULL};
Bien, hablemos de reglas de nomenclatura:
eQuizás, parámetros Debe haber una parte de variable de entorno. Los parámetros en la parte cero del entorno se convertirán en variables de entorno durante la ejecución de la función ejecutiva y rara vez se utilizan.
lQuizás, los parámetros del comando deben estar separados por ",", y el último comando debe ser nulo.
Quizás la parte del parámetro del comando nulo es el puntero principal. una matriz de punteros de cadena terminada en NULL. Por ejemplo, char * pstr es un puntero a una cadena y char * pstr[] es una matriz que apunta a cada cadena respectivamente.
Para obtener una introducción a los comandos de Linux, consulte "Así es como debe aprender Linux". Específicamente, la dirección de este capítulo es 3W(punto)Linux Probe/Chapter-02(punto)HTML.
pQuizás la parte del archivo en ejecución se pueda ejecutar sin una ruta y la función ejecutiva se encontrará en $PATH.
Tenga en cuenta que la función ejecutiva reemplazará el proceso que la ejecuta, es decir, una vez que la función ejecutiva se ejecute correctamente, no regresará y el proceso finalizará. Sin embargo, si la función ejecutiva falla, devolverá un mensaje de error y el proceso continuará ejecutando el código siguiente.
Por lo general, exec se colocará en la parte del subproceso de la función fork() para ejecutarse en lugar del subproceso. Una vez que el subproceso se ejecute correctamente, desaparecerá. Pero si el proceso hijo no se ejecuta, debe utilizar la función exit() para salir del proceso hijo.