Appel système exec dans c

La famille Exec a de nombreuses fonctions en C. Ces fonctions C sont essentiellement utilisées pour exécuter une commande système dans un processus distinct que le programme principal et l'imprimer la sortie.

Dans cet article, je vais parler de la famille exécutive des fonctions et vous montrer comment utiliser chacune de ces fonctions de la famille Exec en C. Alors, commençons.

C Fonctions du système dans la famille Exec:

Les familles de fonctions exec sont définies dans l'en-tête unistd.H. Vous devez donc utiliser cet en-tête sur le programme C où vous souhaitez utiliser ces fonctions.

Les fonctions EXEC disponibles ainsi que leurs paramètres de fonction sont données ci-dessous:

• int execl (const char * path, const char * arg,…, null);
• int execlp (fichier const char *, const char * arg,…, null);
• int execv (const char * path, char * const argv []);
• int execvp (fichier const char *, char * const argv []);
• int execle (const char * path, const char * arg,…, null, char * const envp []);
• int execve (const char * file, char * const argv [], char * const envp []);

Voyons ce que font chacune de ces fonctions et comment les utiliser.

Fonction du système execl ():

Dans EXECL (), la fonction Système prend le chemin du fichier binaire exécutable (I.e. / bac / ls) comme premier et deuxième argument. Ensuite, les arguments (je.e. -LH, /maison) que vous voulez passer à l'exécutable suivi de NUL. Ensuite, la fonction du système EXECL () exécute la commande et imprime la sortie. Si une erreur se produit, alors eecl () renvoie -1. Sinon, ça ne renvoie rien.

Syntaxe:

int execl (const char * path, const char * arg,…, null);

Un exemple de la fonction Système EXECL () est donné ci-dessous:

#inclure
int main (void)
char * binaryPath = "/ bin / ls";
char * arg1 = "-lh";
char * arg2 = "/ home";
exechent (binarypath, binarypath, arg1, arg2, null);
retour 0;

J'ai couru le ls -lh / maison Commande à l'aide de la fonction du système execl (). Comme vous pouvez le voir, le résultat correct est affiché.

Fonction du système execlp ():

eecl () n'utilise pas le CHEMIN variable d'environnement. Ainsi, le chemin complet du fichier exécutable est requis pour l'exécuter avec execl (). execlp () utilise la variable d'environnement de chemin. Donc, si un fichier ou une commande exécutable est disponible dans le chemin, alors la commande ou le nom de fichier est suffisant pour l'exécuter, le chemin complet n'est pas nécessaire.

Syntaxe:

int execlp (fichier const char *, const char * arg,…, null);

Nous pouvons réécrire l'exemple EXECL () à l'aide de la fonction système execlp () comme suit:

#inclure
int main (void)
char * ProgramName = "ls";
char * arg1 = "-lh";
char * arg2 = "/ home";
execlp (ProgramName, ProgramName, Arg1, Arg2, NULL);
retour 0;

Je n'ai réussi que le nom de commande LS, Pas le chemin complet / bac / ls. Comme vous pouvez le voir, j'ai obtenu la même sortie qu'avant.

Fonction du système execv ():

Dans la fonction execl (), les paramètres du fichier exécutable sont transmis à la fonction comme différents arguments. Avec execv (), vous pouvez transmettre tous les paramètres dans un tableau terminé nul argv. Le premier élément du tableau doit être le chemin d'accès du fichier exécutable. Sinon, la fonction Execv () fonctionne tout comme EXECL ().

Syntaxe:

int execv (const char * path, char * const argv []);

Nous pouvons réécrire l'exemple EXECL () comme suit:

#inclure
int main (void)
char * binaryPath = "/ bin / ls";
char * args [] = binaryPath, "-lh", "/ home", null;
execv (binaryPath, args);
retour 0;

Comme vous pouvez le voir, j'obtiens la sortie correcte.

Fonction du système execvp ():

Fonctionne la même manière que la fonction Système Execv (). Mais, la variable d'environnement de chemin est utilisée. Ainsi, le chemin complet du fichier exécutable n'est pas requis comme dans execlp ().

Syntaxe:

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

Nous pouvons réécrire l'exemple execv () comme suit:

#inclure
int main (void)
char * ProgramName = "ls";
char * args [] = ProgramName, "-lh", "/ home", null;
execvp (ProgramName, Args);
retour 0;

Comme vous pouvez le voir, la sortie correcte s'affiche.

Fonction du système execle ():

Fonctionne comme execl () mais vous pouvez fournir vos propres variables d'environnement avec lui. Les variables d'environnement sont passées comme un tableau envp. Le dernier élément du envp le tableau doit être nul. Tous les autres éléments contiennent les paires de valeurs de clé sous forme de chaîne.

Syntaxe:

int execle (const char * path, const char * arg,…, null, char * const envp []);

Un exemple de la fonction Système Execle () est donné ci-dessous:

#inclure
int main (void)
char * binarypath = "/ bin / bash";
char * arg1 = "-c";
char * arg2 = "echo" visiter $ hostname: $ port de votre navigateur."";
char * const env [] = "hostname = www.linuxhint.com "," port = 8080 ", null;
Execle (BinaryPath, BinaryPath, Arg1, Arg2, Null, Env);
retour 0;

J'ai passé deux variables d'environnement Nom d'hôte et PORT à la fonction execle (). Comme vous pouvez le voir, je peux y accéder depuis l'exécutable / bac / bash.

Fonction du système execve ():

Tout comme execle (), vous pouvez fournir vos propres variables d'environnement avec EXECVE (). Vous pouvez également passer des arguments en tant que tableaux que vous l'avez fait dans execv ().

Syntaxe:

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

L'exemple execle () peut être réécrit comme suit:

#inclure
int main (void)
char * binarypath = "/ bin / bash";
char * const args [] = binarypath, "-c", "echo" visiter $ hostname: $ port
de votre navigateur."", NUL;
char * const env [] = "hostname = www.linuxhint.com "," port = 8080 ", null;
execve (binarypath, args, env);
retour 0;

Comme vous pouvez le voir, nous obtenons la même sortie que dans l'exemple Execle ().

C'est donc ainsi que vous utilisez la famille des fonctions d'exec en C pour la programmation système dans Linux. Merci d'avoir lu cet article.