Je peux lancer un processus depuis un programme C avec system(), vrai ?
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
Je peux lancer un processus depuis un programme C avec system(), vrai ?
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
Je peux lancer un processus depuis un programme C avec system(), vrai ?
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
Je peux lancer un processus depuis un programme C avec system(), vrai ?
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
Je peux lancer un processus depuis un programme C avec system(), vrai ?
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
Je peux lancer un processus depuis un programme C avec system(), vrai ?
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
Je peux lancer un processus depuis un programme C avec system(), vrai ?
ou via exec() et compagnie.
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
attention, les fonctions du C standard [f]printf(), etc, sont bufferisées,
donc il faudra voir un peu du côté de fflush() pour que les données
passent bien d'un processus à un autre.
Sinon, il faut voir du côté de pipe(), dup2(), fork() pour rediriger les
entrées et sorties standard.
Petit exemple :
{
int r;
int fd_child_to_parent[2];
int fd_parent_to_child[2];
r = pipe(fd_child_to_parent)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = pipe(fd_parent_to_child)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = fork();
if (r == -1) {
exit(EXIT_FAILURE);
}
if (r == 0) {
/* processus fils */
r = dup2(fd_child_to_parent[1], 1);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[1]);
close(fd_child_to_parent[0]);
r = dup2(fd_parent_to_child[0], 0);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_parent_to_child[0]);
close(fd_parent_to_child[1]);
execl("programme", "programme", "arg1", "arg2", NULL);
}
else {
char buf[256];
close(fd_parent_to_child[0]);
/* processus père */
r = write(fd_parent_to_child[1], "toto", 4);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[0]);
r = read(fd_child_to_parent[0], buf, sizeof(buf));
if (r < 0) {
exit(EXIT_FAILURE);
}
...
}
}
Je peux lancer un processus depuis un programme C avec system(), vrai ?
ou via exec() et compagnie.
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
attention, les fonctions du C standard [f]printf(), etc, sont bufferisées,
donc il faudra voir un peu du côté de fflush() pour que les données
passent bien d'un processus à un autre.
Sinon, il faut voir du côté de pipe(), dup2(), fork() pour rediriger les
entrées et sorties standard.
Petit exemple :
{
int r;
int fd_child_to_parent[2];
int fd_parent_to_child[2];
r = pipe(fd_child_to_parent)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = pipe(fd_parent_to_child)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = fork();
if (r == -1) {
exit(EXIT_FAILURE);
}
if (r == 0) {
/* processus fils */
r = dup2(fd_child_to_parent[1], 1);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[1]);
close(fd_child_to_parent[0]);
r = dup2(fd_parent_to_child[0], 0);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_parent_to_child[0]);
close(fd_parent_to_child[1]);
execl("programme", "programme", "arg1", "arg2", NULL);
}
else {
char buf[256];
close(fd_parent_to_child[0]);
/* processus père */
r = write(fd_parent_to_child[1], "toto", 4);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[0]);
r = read(fd_child_to_parent[0], buf, sizeof(buf));
if (r < 0) {
exit(EXIT_FAILURE);
}
...
}
}
Je peux lancer un processus depuis un programme C avec system(), vrai ?
ou via exec() et compagnie.
Ce que je voudrais faire c'est dialoguer avec lui à travers son entrée
et sa sortie standard, genre je lui fait un fputs, il envoie des
choses que je lis avec des fgetc (jusqu'à un EOF je suppose ?), etc.
attention, les fonctions du C standard [f]printf(), etc, sont bufferisées,
donc il faudra voir un peu du côté de fflush() pour que les données
passent bien d'un processus à un autre.
Sinon, il faut voir du côté de pipe(), dup2(), fork() pour rediriger les
entrées et sorties standard.
Petit exemple :
{
int r;
int fd_child_to_parent[2];
int fd_parent_to_child[2];
r = pipe(fd_child_to_parent)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = pipe(fd_parent_to_child)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = fork();
if (r == -1) {
exit(EXIT_FAILURE);
}
if (r == 0) {
/* processus fils */
r = dup2(fd_child_to_parent[1], 1);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[1]);
close(fd_child_to_parent[0]);
r = dup2(fd_parent_to_child[0], 0);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_parent_to_child[0]);
close(fd_parent_to_child[1]);
execl("programme", "programme", "arg1", "arg2", NULL);
}
else {
char buf[256];
close(fd_parent_to_child[0]);
/* processus père */
r = write(fd_parent_to_child[1], "toto", 4);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[0]);
r = read(fd_child_to_parent[0], buf, sizeof(buf));
if (r < 0) {
exit(EXIT_FAILURE);
}
...
}
}
Petit exemple :
{
int r;
int fd_child_to_parent[2];
int fd_parent_to_child[2];
r = pipe(fd_child_to_parent)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = pipe(fd_parent_to_child)
if (r != -1) {
exit(EXIT_FAILURE);
}
Je ne suis pas certain de comprendre. Si j'interprète le code au 1er
degré, le déroulement normal du programme c'est quand pipe renvoie une
erreur. Je pense donc qu'il y a maldonne. Est-ce que c'est pas plutôt
(r == -1) ou encore (r != 0) ? Mon manuel dit « On successful creation
of the pipe, zero is returned. Otherwise, a value of -1 is
returned... » (désolé pour la francophonie, mon manuel n'est pas
touboniste).
r = fork();
if (r == -1) {
exit(EXIT_FAILURE);
}
Là, je suis !if (r == 0) {
/* processus fils */
r = dup2(fd_child_to_parent[1], 1);
On essaie de réaffecter l'entrée du pipe à « l'objet nº 1 » si je suis bien.
Est-ce que ça veut dire que cet objet nº 1 est la sortie standard ?
Je trouve le manuel de dup2 plutôt sybillin.
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[1]);
close(fd_child_to_parent[0]);
On ferme ce pipe ? Ça veut dire que le fils n'en a plus besoin, mais
le père ne sera pas affecté par ces fermetures ; et quand le fils
écrira sur sa sortie standard, ça arrivera dans fd_child_to_parent[0]
chez le père.
J'ai bon ?
r = dup2(fd_parent_to_child[0], 0);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_parent_to_child[0]);
close(fd_parent_to_child[1]);
Si je comprends toujours bien, l'objet nº 0 est l'entrée standard, et
le fils va voir arriver sur son entrée standard tout ce que le père
envoie sur fd_parent_to_child[1] ?
execl("programme", "programme", "arg1", "arg2", NULL);
Et là on lance le programme. Il a l'entrée et la sortie standard du
processus qui l'a lancé, manquerait plus qu'il fasse le mariole. Tu me
dis si je me gourre.
}
else {
Maintenant on est chez papa.char buf[256];
close(fd_parent_to_child[0]);
Papa n'a pas besoin de la sortie du tuyau qui lui sert à parler à
bébé. Il la ferme mais ceci n'intervient pas sur le tuyau lui-même
(puisque du côté du processus fils ça reste ouvert, le pipe continue à
exister dans le système) mais seulement sur sa possibilité de
l'utiliser -- ce qu'il n'a justement pas à faire.
C'est ça ? C'est être propre qu'on ferme (ce que j'apprécie) ou il y a
une autre utilité ?
/* processus père */
r = write(fd_parent_to_child[1], "toto", 4);
Le père dit "toto" à son fils.if (r < 0) {
exit(EXIT_FAILURE);
À priori cette erreur ne survient que si le fils n'a pas réussi à
déplacer le bout du pipe avec dup2, oui ?
}
close(fd_child_to_parent[0]);
Je suppose que c'est fd_child_to_parent[1] qu'il faut fermer, non ?
Et ça aurait pu être fait avant d'écrire le moindre "toto"... non ?
r = read(fd_child_to_parent[0], buf, sizeof(buf));
if (r < 0) {
exit(EXIT_FAILURE);
}
...
}
}
Petit exemple :
{
int r;
int fd_child_to_parent[2];
int fd_parent_to_child[2];
r = pipe(fd_child_to_parent)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = pipe(fd_parent_to_child)
if (r != -1) {
exit(EXIT_FAILURE);
}
Je ne suis pas certain de comprendre. Si j'interprète le code au 1er
degré, le déroulement normal du programme c'est quand pipe renvoie une
erreur. Je pense donc qu'il y a maldonne. Est-ce que c'est pas plutôt
(r == -1) ou encore (r != 0) ? Mon manuel dit « On successful creation
of the pipe, zero is returned. Otherwise, a value of -1 is
returned... » (désolé pour la francophonie, mon manuel n'est pas
touboniste).
r = fork();
if (r == -1) {
exit(EXIT_FAILURE);
}
Là, je suis !
if (r == 0) {
/* processus fils */
r = dup2(fd_child_to_parent[1], 1);
On essaie de réaffecter l'entrée du pipe à « l'objet nº 1 » si je suis bien.
Est-ce que ça veut dire que cet objet nº 1 est la sortie standard ?
Je trouve le manuel de dup2 plutôt sybillin.
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[1]);
close(fd_child_to_parent[0]);
On ferme ce pipe ? Ça veut dire que le fils n'en a plus besoin, mais
le père ne sera pas affecté par ces fermetures ; et quand le fils
écrira sur sa sortie standard, ça arrivera dans fd_child_to_parent[0]
chez le père.
J'ai bon ?
r = dup2(fd_parent_to_child[0], 0);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_parent_to_child[0]);
close(fd_parent_to_child[1]);
Si je comprends toujours bien, l'objet nº 0 est l'entrée standard, et
le fils va voir arriver sur son entrée standard tout ce que le père
envoie sur fd_parent_to_child[1] ?
execl("programme", "programme", "arg1", "arg2", NULL);
Et là on lance le programme. Il a l'entrée et la sortie standard du
processus qui l'a lancé, manquerait plus qu'il fasse le mariole. Tu me
dis si je me gourre.
}
else {
Maintenant on est chez papa.
char buf[256];
close(fd_parent_to_child[0]);
Papa n'a pas besoin de la sortie du tuyau qui lui sert à parler à
bébé. Il la ferme mais ceci n'intervient pas sur le tuyau lui-même
(puisque du côté du processus fils ça reste ouvert, le pipe continue à
exister dans le système) mais seulement sur sa possibilité de
l'utiliser -- ce qu'il n'a justement pas à faire.
C'est ça ? C'est être propre qu'on ferme (ce que j'apprécie) ou il y a
une autre utilité ?
/* processus père */
r = write(fd_parent_to_child[1], "toto", 4);
Le père dit "toto" à son fils.
if (r < 0) {
exit(EXIT_FAILURE);
À priori cette erreur ne survient que si le fils n'a pas réussi à
déplacer le bout du pipe avec dup2, oui ?
}
close(fd_child_to_parent[0]);
Je suppose que c'est fd_child_to_parent[1] qu'il faut fermer, non ?
Et ça aurait pu être fait avant d'écrire le moindre "toto"... non ?
r = read(fd_child_to_parent[0], buf, sizeof(buf));
if (r < 0) {
exit(EXIT_FAILURE);
}
...
}
}
Petit exemple :
{
int r;
int fd_child_to_parent[2];
int fd_parent_to_child[2];
r = pipe(fd_child_to_parent)
if (r != -1) {
exit(EXIT_FAILURE);
}
r = pipe(fd_parent_to_child)
if (r != -1) {
exit(EXIT_FAILURE);
}
Je ne suis pas certain de comprendre. Si j'interprète le code au 1er
degré, le déroulement normal du programme c'est quand pipe renvoie une
erreur. Je pense donc qu'il y a maldonne. Est-ce que c'est pas plutôt
(r == -1) ou encore (r != 0) ? Mon manuel dit « On successful creation
of the pipe, zero is returned. Otherwise, a value of -1 is
returned... » (désolé pour la francophonie, mon manuel n'est pas
touboniste).
r = fork();
if (r == -1) {
exit(EXIT_FAILURE);
}
Là, je suis !if (r == 0) {
/* processus fils */
r = dup2(fd_child_to_parent[1], 1);
On essaie de réaffecter l'entrée du pipe à « l'objet nº 1 » si je suis bien.
Est-ce que ça veut dire que cet objet nº 1 est la sortie standard ?
Je trouve le manuel de dup2 plutôt sybillin.
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_child_to_parent[1]);
close(fd_child_to_parent[0]);
On ferme ce pipe ? Ça veut dire que le fils n'en a plus besoin, mais
le père ne sera pas affecté par ces fermetures ; et quand le fils
écrira sur sa sortie standard, ça arrivera dans fd_child_to_parent[0]
chez le père.
J'ai bon ?
r = dup2(fd_parent_to_child[0], 0);
if (r < 0) {
exit(EXIT_FAILURE);
}
close(fd_parent_to_child[0]);
close(fd_parent_to_child[1]);
Si je comprends toujours bien, l'objet nº 0 est l'entrée standard, et
le fils va voir arriver sur son entrée standard tout ce que le père
envoie sur fd_parent_to_child[1] ?
execl("programme", "programme", "arg1", "arg2", NULL);
Et là on lance le programme. Il a l'entrée et la sortie standard du
processus qui l'a lancé, manquerait plus qu'il fasse le mariole. Tu me
dis si je me gourre.
}
else {
Maintenant on est chez papa.char buf[256];
close(fd_parent_to_child[0]);
Papa n'a pas besoin de la sortie du tuyau qui lui sert à parler à
bébé. Il la ferme mais ceci n'intervient pas sur le tuyau lui-même
(puisque du côté du processus fils ça reste ouvert, le pipe continue à
exister dans le système) mais seulement sur sa possibilité de
l'utiliser -- ce qu'il n'a justement pas à faire.
C'est ça ? C'est être propre qu'on ferme (ce que j'apprécie) ou il y a
une autre utilité ?
/* processus père */
r = write(fd_parent_to_child[1], "toto", 4);
Le père dit "toto" à son fils.if (r < 0) {
exit(EXIT_FAILURE);
À priori cette erreur ne survient que si le fils n'a pas réussi à
déplacer le bout du pipe avec dup2, oui ?
}
close(fd_child_to_parent[0]);
Je suppose que c'est fd_child_to_parent[1] qu'il faut fermer, non ?
Et ça aurait pu être fait avant d'écrire le moindre "toto"... non ?
r = read(fd_child_to_parent[0], buf, sizeof(buf));
if (r < 0) {
exit(EXIT_FAILURE);
}
...
}
}
DINH Viêt Hoà a encore répondu.
DINH Viêt Hoà a encore répondu.
DINH Viêt Hoà a encore répondu.