Dans cet article, je vais parler de la famille de fonctions exec et vous montrer comment utiliser chacune de ces fonctions de la famille exec en C. Alors, commençons.
Fonctions du système C 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 d'exécution disponibles ainsi que leurs paramètres de fonction sont indiqués ci-dessous :
- int execl(const char *chemin, const char *arg, …, NULL);
- int execlp(const char *file, const char *arg, …, NULL );
- int execv(const char *chemin, char *const argv[]);
- int execvp(const char *fichier, char *const argv[]);
- int execle(const char *chemin, const char *arg, …, NULL, char * const envp[] );
- int execve(const char *fichier, char *const argv[], char *const envp[]);
Voyons ce que fait chacune de ces fonctions et comment les utiliser.
Fonction système execl() :
Dans execl(), la fonction système prend le chemin du fichier binaire exécutable (c'est-à-dire / bin / ls ) comme premier et deuxième arguments. Ensuite, les arguments (c'est-à-dire -lh , /domicile ) que vous souhaitez passer à l'exécutable suivi de NUL . Ensuite, la fonction système execl() exécute la commande et imprime la sortie. Si une erreur se produit, alors execl() renvoie -1. Sinon, il ne renvoie rien.
Syntaxe:
entierexecl(const carboniser *chemin, const carboniser *en colère,...,NUL);Un exemple de la fonction système execl() est donné ci-dessous :
#comprendre
entierprincipale(annuler) {
carboniser *chemin binaire= '/ bin / ls';
carboniser *argument1= '-lh';
carboniser *arg2= '/domicile';
execl(chemin binaire,chemin binaire,argument1,arg2,NUL);
revenir 0;
}
j'ai couru le ls -lh / maison commande utilisant la fonction système execl(). Comme vous pouvez le voir, le résultat correct est affiché.
Fonction système execlp() :
execl() 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 PATH. Ainsi, si un fichier exécutable ou une commande est disponible dans le PATH, alors la commande ou le nom de fichier est suffisant pour l'exécuter, le chemin complet n'est pas nécessaire.
Syntaxe:
entierà l'exception(const carboniser *déposer, const carboniser *en colère,...,NUL);Nous pouvons réécrire l'exemple execl() en utilisant la fonction système execlp() comme suit :
#comprendreentierprincipale(annuler) {
carboniser *nom du programme= 'ls';
carboniser *argument1= '-lh';
carboniser *arg2= '/domicile';
à l'exception(nom du programme,nom du programme,argument1,arg2,NUL);
revenir 0;
}
je n'ai passé que le nom de la commande ls , pas le chemin complet / bin / ls . Comme vous pouvez le voir, j'ai le même résultat qu'avant.
Fonction système execv() :
Dans la fonction execl(), les paramètres du fichier exécutable sont passés à la fonction en tant qu'arguments différents. Avec execv(), vous pouvez passer tous les paramètres dans un tableau terminé par NULL argv . Le premier élément du tableau doit être le chemin du fichier exécutable. Sinon, la fonction execv() fonctionne exactement comme la fonction execl().
Syntaxe:
entierexecv(const carboniser *chemin, carboniser *constargv[]);Nous pouvons réécrire l'exemple execl() comme suit :
#comprendreentierprincipale(annuler) {
carboniser *chemin binaire= '/ bin / ls';
carboniser *arguments[] = {chemin binaire, '-lh', '/domicile',NUL};
execv(chemin binaire,arguments);
revenir 0;
}
Comme vous pouvez le voir, j'obtiens le bon résultat.
Fonction système execvp() :
Fonctionne de la même manière que la fonction système execv(). Mais, la variable d'environnement PATH est utilisée. Ainsi, le chemin complet du fichier exécutable n'est pas requis comme dans execlp().
Syntaxe:
entierexecvp(const carboniser *déposer, carboniser *constargv[]);Nous pouvons réécrire l'exemple execv() comme suit :
#comprendreentierprincipale(annuler) {
carboniser *nom du programme= 'ls';
carboniser *arguments[] = {nom du programme, '-lh', '/domicile',NUL};
execvp(nom du programme,arguments);
revenir 0;
}
Comme vous pouvez le voir, la sortie correcte est affichée.
Fonction système execle() :
Fonctionne exactement comme execl(), mais vous pouvez également fournir vos propres variables d'environnement. Les variables d'environnement sont passées sous forme de tableau envp . Le dernier élément de la envp tableau doit être NULL. Tous les autres éléments contiennent les paires clé-valeur sous forme de chaîne.
Syntaxe:
entierexécuter(const carboniser *chemin, const carboniser *en colère,...,NUL, carboniser * constenvp[] );Un exemple de la fonction système execle() est donné ci-dessous :
#comprendreentierprincipale(annuler) {
carboniser *chemin binaire= '/bin/bash';
carboniser *argument1= '-c';
carboniser *arg2= 'chassèrent 'Visitez $HOSTNAME:$PORT depuis votre navigateur.'';
carboniser *constenv[] = {'HOSTNAME=www.linuxhint.com', 'PORT=8080',NUL};
exécuter(chemin binaire,chemin binaire,argument1,arg2,NUL,env);
revenir 0;
}
J'ai passé deux variables d'environnement NOM D'HTE et PORT à la fonction execle(). Comme vous pouvez le voir, je peux y accéder depuis l'exécutable /bin/bash .
Fonction système execve() :
Tout comme execle(), vous pouvez fournir vos propres variables d'environnement avec execve(). Vous pouvez également passer des arguments sous forme de tableaux comme vous l'avez fait dans execv().
Syntaxe:
entierexecve(const carboniser *déposer, carboniser *constargv[], carboniser *constenvp[]);L'exemple execle() peut être réécrit comme suit :
#comprendreentierprincipale(annuler) {
carboniser *chemin binaire= '/bin/bash';
carboniser *constarguments[] = {chemin binaire, '-c', 'chassèrent 'Visitez $HOSTNAME:$PORT
depuis votre navigateur.'',NUL};
carboniser *constenv[] = {'HOSTNAME=www.linuxhint.com', 'PORT=8080',NUL};
execve(chemin binaire,arguments,env);
revenir 0;
}
Comme vous pouvez le voir, nous obtenons le même résultat que dans l'exemple execle().
C'est ainsi que vous utilisez la famille de fonctions exec en C pour la programmation système sous Linux. Merci d'avoir lu cet article.