Exercice sur les processus

Bonjour,voici mon exercice.

Écrire un programme runas name program arg1 arg2 ... argN qui exécute
le programme program arg1 arg2 ... argN avec name comme valeur de argv[0] au lieu de program.

J'avais pensé à utiliser la fonction qui exécute un processus:

Code:

---

1 2 3 4

#include <unistd .h>   int execl ( const char *path , const char *arg0 , . . . , NULL ) ;

---

Je ne suis pas sur de comment faire ?.Si je pouvais avoir votre avis.Merci!

En gros je prends comme exemple un programme "affiche.c" qui affiche à l'aide d'un printf: "Bonjour".

J'écris ensuite le programme runas avec la fonction execl dedans.

Jcomprends pas trop en fait.Est-ce qu'il faut que "affiche.c" prenne des arguments en paramètre obligatoirement ?

En fait,jcomprends pas l'énoncé en fait je crois.:(

J'ai l'impressions que tu dois creer un programme qui prendra en argument

le nom (argv[0])
et les argument du programme appelé.


Mais c'est vrai que c'est un peu foulli

Oué jcomprends pas !

C'est un exercice sur les processus donc je pense que je dois utiliser la fonction execl !

Voici mon programme initial qui affiche le nom et prenom.Ce programme marche correctement.

Code:

---

1 2 3 4 5 6 7

#include <stdio.h> #include <stdlib.h>   int main(int argc,char *argv[]) { printf("Bonjour je m'appelle %s %s\n",argv[1],argv[2]); }

---

Voici le programme runas.

Code:

---

1 2 3 4 5 6 7 8 9

#include <stdio.h> #include <stdlib.h> #include <unistd.h>     int main(int argc,char *argv[]) { execl(argv[0],argv[1],argv[2],NULL ); }

---

En faisant ./runas affiche guillaume peano, voici l'erreur que j'obtiens:

Bonjour je m'appelle (null) ORBIT_SOCKETDIR=/tmp/orbit-pubuntu

Je ne comprends pas !

J'ai modifié le programme runas, y avait une erreur:

Code:

---

1 2 3 4

int main(int argc,char *argv[]) { execl(argv[1],argv[2],argv[3]); }

---

Ca ne marche toujours pas !

ex: je fais : ./runas affiche jean jacques

Ca m'affiche "Bonjour je m'appelle jacques".

C'est bizarre !

Bonjour ! :D

Ca date peut-être mais le sujet semble toujours d'actualité étant donné que j'ai dû me confronter à cet exercice très récemment, dont la consigne n'est pas assez explicite à mon avis (on pourrait l'interpréter de plusieurs manières).

Enfin bon, voici une solution (commentée, sans accent), du fichier (programme) "runas.c" :



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

int main(int argc, char *argv[])
{
if (argc < 3) // Minimum 3 arguments : ./runas, name et program.
{
printf("usage : ./runas name program ([arg1] [arg2] ... [argN])\n"); // Message d'erreur si moins de 3 arguments.
exit(1); // On quitte le programme aussitot, avec un code d'erreur (entier different de 0).
}

// Affiche les differents elements du tableau des arguments, pour qu'on puisse voir ou chaque element est stocke.
//printf("argv[0] : %s\n", argv[0]);
//printf("argv[1] : %s\n", argv[1]);
//printf("argv[2] : %s\n", argv[2]);
//printf("argv[3] : %s\n", argv[3]);

char *command = argv[2]; // On garde de cote le nom de la commande a executer. A la base : argv = [./runas name program ...]
argv[2] = argv[1]; // On peut ensuite mettre "name" a la place de "program". On a maintenant : argv = [./runas name name ...]

// On constate que le changement de position a bien ete effectue
//printf("command : %s\n", command);
//printf("argv[2] : %s\n", argv[2]);

// "execvp", derive de exec ("man 3 exec" dans un terminal pour + d'info),
// 1er argument : nom de la commande a executer,
// 2eme argument : liste du nom "name" passe en arguments, et des arguments supplementaires [arg1] [arg2] ...
if (execvp(command, &argv[2]) == -1) // La fonction est executee dans l'instruction "if", elle retourne 0 en cas de succes, -1 sinon.
{
perror("execvp"); // Affiche un message d'erreur prevu pour "execvp" en cas d'erreur (si "execvp" vaut -1).
exit(1); // On quitte egalement le programme avec un code d'erreur (different de 0).
}

// Si le programme n'a pas rencontre d'erreur, il devrait executer cette derniere ligne, le programme renvoie l'entier 0, synonyme de bon deroulement du programme
// (aucun echec).
return 0;
}




Alors pour lancer une commande (un processus) on utilise "exec" ou un de ses dérivés, ici "execvp", qui prend en 1er paramètre le nom du programme ou de la commande POSIX souhaitée (ex : "mkdir") et en 2ème argument la liste des paramètres associés à cette commande (ex : "folder1 folder2").

Voilà pour l'exécution d'un programme ou commande, mais en ce qui concerne "name" de l'énoncé, je n'avais pas très bien compris son utilité, puis, j'ai finalement remarqué que le premier élément du tableau donné en 2ème paramètre de "execvp" est en fait affiché en cas d'échec de la commande ou pour toute erreur.

Donc, pour que ce soit "name" qui soit affiché en cas d'erreur, et non "program", il faut mettre "name" à la place de "program" dans le tableau des arguments "argv", qui à la base est similaire à ça :
argv[0] = runas
argv[1] = [name] (enfin le nom que vous voulez)
argv[2] = program (le nom de la commande POSIX ("ls", "mkdir", ...) ou d'un exécutable (compilé).
argv[3] (et +) : arguments supplémentaires (non obligatoires pour certaines commandes (non obligatoire pour ls, obligatoire pour mkdir, qui a besoin d'au moins un nom pour créer un dossier).

On conserve le nom du programme*/commande (en position "argv[2]") dans une variable, qu'on nomme ici "command" (*plus exactement "exécutable", le programme désignant normalement le code, qui une fois compilé donne un exécutable),
car on va remplacer la valeur de argv[2] par "name", dont on va mettre l'adresse en 2ème paramètre de "execvp", ce qui fait que "execvp" aura un tableau comme celui-ci : ["name", "arg1", "arg2", ...], "arg1" et "arg2" étant les paramètres supplémentaires, dans le tableau "argv" aux positions "argv[3]", "argv[4]" et plus (si ces paramètres sont renseignés).

Bon bref, on va maintenant voir ce que ça donne (on peut décommenter les lignes qui contiennent "printf" pour voir si chaque élément est bien à sa place dans le tableau ("argv") des arguments entrés en paramètres.
(En ouvrant un terminal dans le dossier contenant "runas.c" on exécute la commande "make runas" pour compiler le programme runas.c et en obtenir un exécutable ("runas")).

Si on veut tester la commande ls : "./runas ls ls" -> affiche les fichiers et dossiers du répertoire courant, le 2ème "ls" est la commande qui est exécutée tandis que le 1er est le nom qui sera affiché en cas d'erreur.
Donc on peut très bien exécuter la commande : "./runas choucroute ls" -> ce qui donne exactement le même résultat, sauf qu'en cas d'erreur, c'est "choucroute" qui sera responsable.

Si on veut tester la commande mkdir : "./runas choucroute mkdir a" -> le dossier "a" est créé.
En exécutant de nouveau la commande : "./runas choucroute mkdir a" -> on a : "choucroute: cannot create directory ‘a’: File exists" (si le système d'exploitation GNU/Linux est en Anglais du moins), car le dossier "a", créé précédemment empêche la création d'un nouveau dossier "a".

Mais... On peut également reporter la faute sur "ls" comme ceci :
"./runas ls mkdir a" -> "ls: cannot create directory ‘a’: File exists"
Voilà, "ls" n'a même pas réussi à créer un dossier, pitoyable... (alors que c'est en réalité "mkdir" qui s'en charge).

PS : On peut également rajouter plus d'un argument supplémentaire, exemple : "./runas You mkdir a b c" -> "You: cannot create directory ‘a’: File exists" Voilà, maintenant vous savez que vous ne pouvez pas créer de dossier, si même l'ordinateur vous le dit x),
en revanche les dossiers "b" et "c" ont bien été créés, eux (et ce n'est pas grâce à vous xD) (le dossier "a" existant déjà).

Epilogue :
Il est possible que l'argument "name" n'ait rien à voir avec un quelconque report de faute dans le cas où un programme faillirait à sa tâche et en dénoncerait un autre à sa place, dans ce cas le sujet serait à revoir entièrement,
et quelqu'un d'autre devra se charger d'écrire un post aussi court et concis que le mien.
Bon je sais qu'on aurait pu détailler un peu plus, mais j'ai voulu faire un truc simple et rapide, donc voilà.

Bonne nuit :D !