Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1461 connectés 

  FORUM HardWare.fr
  Programmation
  C

  C, linux et les pipes

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

C, linux et les pipes

n°2079082
effa
Posté le 30-05-2011 à 12:46:51  profilanswer
 

Bonjour, j'ai un TP à realiser pour lequel je m'arrache les cheveux....
L'objectif est creer 2 equipes composées d'un processus pere et de 5 sous processus. Chque sous processus doit ecrire dans un fichier son PID en binaire, et son PPID. les fichiers sont numérotés de 0000 a 9999. Le processus pere envoit aux sous processus le numero de fichier a conquérir. Le processus pere est soumis à une tempo de 20s.
En outre, si un processus de l'autre equipe ouvre un fichier deja conquis par l'autre equipe, il recupere le pid de l'adversaire et le tue via SIG_QUIT.
Enfin, un programme qui compte les points par equipe devra etre mis à disposition....
Voila mon debut de code (j'ai honte de le dire, mais j'y ai déjà passé une semaine entière....)
Je crois que seul le premier n° de fichier est recupéré par le sous processus ?
D'autre part, je n'ai pas la moindre idee de comment installer le programme qui compte les points par équipe...
HELP svp, mon exam arrive et je n'ai pas encore pu commencer les revisions tant que je n'ai pas fini ca....et ce n'est pas faute de ne pas bosser !
 

Code :
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <sys/wait.h>
  6. #include <sys/msg.h>
  7. #include <sys/sem.h>
  8. #include <signal.h>
  9. void pere1();
  10. void pere2();
  11. void fils1();
  12. void fils2();
  13. int randomSel();
  14. void verif();
  15. int rand_a_b();
  16. //creation des tubes en lecture et en ecriture - 1 pour chaque equipe
  17. int pip1[2], pip2[2];
  18. char buff[5];
  19. // variables pour la sélection aléatoire des fichiers :
  20. int nb_arrivee=0;
  21. int min = 0000;
  22. int max = 8001;
  23. int main()
  24. {
  25. // les processus (pg1 sous processus pa1.1 a 5 et processus pg2 avec sous processus pa2.1 a 5)
  26. pid_t pg1,pg2, pa11, pa12, pa13, pa14, pa15, pa21, pa22, pa23, pa24, pa25;
  27. // variables pour récupérer nb de points
  28. int w11, w12, w13, w14, w15, w21, w22, w23, w24, w25;
  29. int r11, r12, r13, r14, r15, r21, r22, r23, r24, r25;
  30. // creation du premier processus general - equipe 1
  31. pg1=fork();
  32. if (pg1==0) {
  33. // creation pipe a partager entre pg1 et ses 5 sous processus
  34. // signale erreur si pb à la création d'un pipe
  35. if(pipe(pip1) == -1)
  36. {
  37.  perror("Erreur à la création du tube de communication 1." );
  38.  exit(-1);
  39. }
  40. // création des 5 sous processus - equipe 1
  41. pa11=fork();
  42. pa12=fork();
  43. pa13=fork();
  44. pa14=fork();
  45. pa15=fork();
  46. //appelle les fonctions selon type de processus
  47. switch(fork())
  48. {
  49.  case -1 :
  50.   perror("Erreur lors de la création du fils." );
  51.   exit(-1);
  52.  case 0 :
  53.   fils1();
  54.   break;
  55.  default :
  56.   pere1();
  57.   break;
  58. }
  59. return(0);
  60. }
  61. //creation du deuxième processus general - equipe 2
  62. pg2=fork();
  63. if (pg2==0) {
  64. // creation pipe a partager entre pg2 et ses 5 sous processus
  65. // signale erreur si pb à la création d'un pipe
  66. if(pipe(pip2) == -1)
  67. {
  68.  perror("Erreur à la création du tube de communication 3." );
  69.  exit(-1);
  70. }
  71. // création des 5 sous processus - equipe 2
  72. pa21=fork();
  73. pa22=fork();
  74. pa23=fork();
  75. pa24=fork();
  76. pa25=fork();
  77. //appelle les fonctions selon type de processus
  78. switch(fork())
  79. {
  80.  case -1 :
  81.   perror("Erreur lors de la création du fils." );
  82.   exit(-1);
  83.  case 0 :
  84.   fils2();
  85.   break;
  86.  default :
  87.   pere2();
  88.   break;
  89. }
  90. return(0);
  91. exit(0);
  92. }
  93. }// fin main
  94. // equipe 1
  95. void pere1(){
  96. // mise en place du timing
  97. //alarm(20);
  98. //while(20) {
  99. // sélection des fichiers
  100. int i;
  101. for (i=0; i<4; i++) {
  102. rand_a_b(min, max);
  103. char buff2 [4];
  104. // transforme le résultat en string
  105. sprintf(buff2, "%d", nb_arrivee);
  106. // ecriture et transmission des n° de fichiers via un pipe
  107. close(pip1[0]);
  108. printf("[Père :]Ecriture dans le tube de communication 1.\n" );
  109. if(write(pip1[1],  buff2, 4) > 4)
  110. {
  111.  perror("Erreur lors de l'écriture dans le tube de communication 1." );
  112.  exit(-1);
  113. }
  114. wait(NULL);
  115. close(pip1[1]);
  116. }
  117. }
  118. void fils1(){
  119. while(1) {
  120. // verifie si il a recut un signal SIG_QUIT
  121. signal(SIGQUIT, verif);
  122. //lit le n° de fichier  
  123. int car_lu;
  124. close(pip1[1]);
  125. printf("[Fils :]Attente de lecture\n" );
  126. car_lu=read(pip1[0], buff, 4);
  127. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  128. close(pip1[0]);
  129. // ajoute  
  130. // ecrit
  131. exit(0);
  132. }}
  133. // equipe 2
  134. void pere2(){
  135. // mise en place du timing
  136. //alarm(20);
  137. //while(20) {
  138. int j;
  139. for (j=0; j<4; j++) {
  140. // sélection des fichiers
  141. rand_a_b(min, max);
  142. char buff2 [4];
  143. sprintf(buff2, "%d", nb_arrivee);
  144. // ecriture et transmission des n° de fichiers via un pipe
  145. close(pip2[0]);
  146. printf("[Père :]Ecriture dans le tube de communication 2.\n" );
  147. if(write(pip2[1], buff2, 4) > 4)
  148. {
  149. perror("Erreur lors de l'écriture dans le tube de communication 2." );
  150.  exit(-1);
  151. }
  152. wait(NULL);
  153. close(pip2[1]);
  154. }
  155. }
  156. void fils2(){
  157. while(1) {
  158. // verifie si il a recut un signal SIG_QUIT
  159. signal(SIGQUIT, verif);
  160. //lit le n° de fichier  
  161. int car_lu;
  162. close(pip2[1]);
  163. printf("[Fils :]Attente de lecture\n" );
  164. car_lu=read(pip2[0], buff, 4);
  165. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  166. close(pip2[0]);
  167. exit(0);
  168. }
  169. }
  170. void verif(int num_sig) {
  171. if (num_sig==3) {
  172.  printf("je suis le processus %d et je suis mort", getpid());
  173.  exit(1);
  174.   }
  175. // réarme pour qu'unix ne repositionne pas le traitement par défaut
  176. signal(num_sig, verif);
  177. }
  178. int rand_a_b(int min, int max){
  179. nb_arrivee = rand()%(max-min)+min+1999;
  180. printf("nb d'arrivee %d : nb de depart %d : ", nb_arrivee , nb_arrivee-1999);
  181. return (nb_arrivee);
  182. }

mood
Publicité
Posté le 30-05-2011 à 12:46:51  profilanswer
 

n°2079164
shaoyin
Posté le 30-05-2011 à 16:23:44  profilanswer
 

effa a écrit :


 

Code :
  1. // création des 5 sous processus - equipe 1
  2. pa11=fork();
  3. pa12=fork();
  4. pa13=fork();
  5. pa14=fork();
  6. pa15=fork();
  7. //appelle les fonctions selon type de processus
  8. switch(fork())
  9. {
  10.  case -1 :
  11.   perror("Erreur lors de la création du fils." );
  12.   exit(-1);
  13.  case 0 :
  14.   fils1();
  15.   break;
  16.  default :
  17.   pere1();
  18.   break;
  19. }
  20. return(0);
  21. //creation du deuxième processus general - equipe 2
  22. pg2=fork();
  23. if (pg2==0) {
  24. // creation pipe a partager entre pg2 et ses 5 sous processus
  25. // signale erreur si pb à la création d'un pipe
  26. if(pipe(pip2) == -1)
  27. {
  28.  perror("Erreur à la création du tube de communication 3." );
  29.  exit(-1);
  30. }
  31. // création des 5 sous processus - equipe 2
  32. pa21=fork();
  33. pa22=fork();
  34. pa23=fork();
  35. pa24=fork();
  36. pa25=fork();
  37. //appelle les fonctions selon type de processus
  38. switch(fork())
  39. {
  40.  case -1 :
  41.   perror("Erreur lors de la création du fils." );
  42.   exit(-1);
  43.  case 0 :
  44.   fils2();
  45.   break;
  46.  default :
  47.   pere2();
  48.   break;
  49. }



 
Bon, j'avoue que je n'ai pas tout lu, mais déjà tes appels à "fork" sont foireux... C'est après chaque appel à cette fonction qu'il faut tester le code retour, sinon ton processus père va effectivement créer 5 fils, mais actuellement chaque fils qu'il crée engendre à son tour autant de processus que de fils restant à créer. Autant dire que ton processus père prend un sacré coup de vieux puisqu'il devient rapidement arrière-arrière-arrière grand père !
 
Ensuite, dans tes "switch", il ne faut surtout pas appeler "fork" à nouveau, parce que tu vas recréer un nouveau processus (comme s'il n'y en avait pas déjà assez...).
 

n°2079173
effa
Posté le 30-05-2011 à 16:35:01  profilanswer
 

merci, j'ai changé ca et d'autres choses :  
 

Code :
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <sys/wait.h>
  6. #include <sys/msg.h>
  7. #include <sys/sem.h>
  8. #include <signal.h>
  9. void pere1();
  10. void pere2();
  11. void fils1();
  12. void fils2();
  13. void verif();
  14. int rand_a_b();
  15. //creation des tubes en lecture et en ecriture - 1 pour chaque equipe
  16. int pip1[2], pip2[2];
  17. // variables pour la sélection aléatoire des fichiers :
  18. int num_fichier=0;
  19. int min = 0000;
  20. int max = 9999;
  21. int main()
  22. {
  23. // les processus (pg1 sous processus pa1.1 a 5 et processus pg2 avec sous processus pa2.1 a 5)
  24. pid_t pg1,pg2;
  25. // variables pour récupérer nb de points
  26. int w11, w12, w13, w14, w15, w21, w22, w23, w24, w25;
  27. int r11, r12, r13, r14, r15, r21, r22, r23, r24, r25;
  28. // variable permettant d'appliquer le signal  
  29. int sig=0;
  30. // creation du premier processus general - equipe 1
  31. pg1=fork();
  32. if (pg1==0) {
  33. // creation pipe a partager entre pg1 et ses 5 sous processus
  34. // signale erreur si pb à la création d'un pipe
  35. if(pipe(pip1) == -1)
  36. {
  37.  perror("Erreur à la création du tube de communication 1." );
  38.  exit(-1);
  39. }
  40. // création des 5 sous processus - equipe 1
  41. // et appelle les fonctions selon type de processus
  42. int nb = 0;
  43. pid_t pid;
  44. do
  45. {
  46.    pid = fork ();
  47.    if(pid==0){
  48.        fils1();}
  49.    nb++;
  50. } while (nb < 5);
  51. pere1();
  52. }
  53. //creation du deuxième processus general - equipe 2
  54. pg2=fork();
  55. if (pg2==0) {
  56. // creation pipe a partager entre pg2 et ses 5 sous processus
  57. // signale erreur si pb à la création d'un pipe
  58. if(pipe(pip2) == -1)
  59. {
  60.  perror("Erreur à la création du tube de communication 3." );
  61.  exit(-1);
  62. }
  63. // création des 5 sous processus - equipe 2
  64. // et appelle les fonctions selon type de processus
  65. int nb = 0;
  66. pid_t pid;
  67. do
  68. {
  69.    pid = fork ();
  70.    if(pid==0){
  71.        fils2();}
  72.    nb++;
  73. } while (nb < 5);
  74. pere2();
  75. }
  76. // compteur de points au niveau du processus grand-père :
  77. // statut : exit(0) => 0 en cas de mort ou d'échec, exit(1) => 1 en cas de reussite
  78. int total_equipe1;
  79. int total_equipe2;
  80. w11 = wait(&r11);
  81. r11 = WEXITSTATUS (r11);
  82. w12 = wait(&r12);
  83. r12 = WEXITSTATUS (r12);
  84. w13 = wait(&r13);
  85. r13 = WEXITSTATUS (r13);
  86. w14 = wait(&r14);
  87. r14 = WEXITSTATUS (r14);
  88. w15 = wait(&r15);
  89. r15 = WEXITSTATUS (r15);
  90. total_equipe1 = r11+r12+r13+r14+r15;
  91. w21 = wait(&r21);
  92. r21 = WEXITSTATUS (r21);
  93. w22 = wait(&r22);
  94. r22 = WEXITSTATUS (r22);
  95. w23 = wait(&r23);
  96. r23 = WEXITSTATUS (r23);
  97. w24 = wait(&r24);
  98. r24 = WEXITSTATUS (r24);
  99. w25 = wait(&r25);
  100. r25 = WEXITSTATUS (r25);
  101. total_equipe2 = r21+r22+r23+r24+r25;
  102. if (total_equipe1 > total_equipe2)
  103. {
  104. printf("l'equipe 1 gagne avec %d points contre %d points pour l'équipe 2", total_equipe1, total_equipe2);
  105. }
  106. else {
  107. if (total_equipe1 < total_equipe2)
  108. {
  109. printf("l'equipe 2 gagne avec %d points contre %d points pour l'équipe 1", total_equipe2, total_equipe1);
  110. }
  111. else {
  112. printf("les deux équipes dont à égalité avec %d points", total_equipe2);
  113. }
  114. }
  115. return (0);
  116. }// fin main
  117. // equipe 1
  118. void pere1(){
  119. // mise en place du timing
  120. alarm(20);
  121. while(20) {
  122. // sélection des fichiers
  123. rand_a_b(min, max);
  124. // ecriture et transmission des n° de fichiers via un pipe
  125. close(pip1[0]);
  126. printf("[Père :]Ecriture dans le tube de communication 1.\n" );
  127. write(pip1[1],  &num_fichier, sizeof(int));
  128. //EOF est envoyé aux processus lisant les données écrites dans le tube
  129. close(pip1[1]);
  130. wait(NULL);
  131. }
  132. }
  133. void fils1(){
  134. // verifie si il a recut un signal SIG_QUIT
  135. signal(SIGQUIT, verif);
  136. if (sig==1) exit(0);
  137. //lit le n° de fichier  
  138. close(pip1[1]);
  139. printf("[Fils :]Attente de lecture\n" );
  140. read(pip1[0], &num_fichier, sizeof(int));
  141. printf("[Fils :]Contenu de la lecture : %s\n",&num_fichier);
  142. close(pip1[0]);
  143. exit(1);
  144. }
  145. // equipe 2
  146. void pere2(){
  147. // mise en place du timing
  148. alarm(20);
  149. while(20) {
  150. // sélection des fichiers
  151. rand_a_b(min, max);
  152. // ecriture et transmission des n° de fichiers via un pipe
  153. close(pip2[0]);
  154. printf("[Père :]Ecriture dans le tube de communication 2.\n" );
  155. write(pip2[1],  &num_fichier, sizeof(int));
  156. //EOF est envoyé aux processus lisant les données écrites dans le tube
  157. close(pip2[1]);
  158. wait(NULL);
  159. }
  160. }
  161. void fils2(){
  162. // verifie si il a recut un signal SIG_QUIT
  163. signal(SIGQUIT, verif);
  164. if (sig==1) exit(0);
  165. //lit le n° de fichier  
  166. close(pip2[1]);
  167. printf("[Fils :]Attente de lecture\n" );
  168. read(pip2[0], &num_fichier, sizeof(int));
  169. printf("[Fils :]Contenu de la lecture : %s\n",&num_fichier);
  170. close(pip2[0]);
  171. exit(1);
  172. }
  173. // utilitaires communs  
  174. void verif(int num_sig) {
  175. if (num_sig==3) {
  176.  printf("je suis le processus %d et je suis mort", getpid());
  177.  sig=1;
  178.  exit(0);
  179.   }
  180. // réarme pour qu'unix ne repositionne pas le traitement par défaut
  181. signal(num_sig, verif);
  182. }
  183. int rand_a_b(int min, int max){
  184. num_fichier = rand()%(max-min)+min;
  185. printf("n° de fichier à conquérir ", num_fichier );
  186. return (num_fichier);
  187. }

n°2079183
shaoyin
Posté le 30-05-2011 à 16:45:00  profilanswer
 

Sauf erreur de ma part, la deuxième équipe est créée une fois que la fonction "pere1" est terminée, ce qui n'est sûrement pas ce que tu souhaites ?
 
Si tu regardes de près les "pères" des deux équipes doivent faire exactement la même chose, c'est à dire créer 5 fils puis appeler la fonction pereX(). Donc je te suggère de mettre ce code dans une fonction ("foo", par exemple).
Ensuite, dans ton main, tu appelles deux fois fork() pour créer tes deux pères. Après chaque appel, tu invoques ta fonction "foo" si tu es dans le processus fils.
 
Ainsi, ton programme crée les deux pères, et devient libre de faire autre chose, comme compter les points par exemple !

n°2079506
404 Not Fo​und
Hacker Vaillant
Posté le 31-05-2011 à 14:24:46  profilanswer
 

man fork
 
De rien [:zoubidawa]

n°2079812
effa
Posté le 01-06-2011 à 13:03:06  profilanswer
 

Bonjour,  
J'ai amélioré les choses (j'espere) grace à vous.  
j'aimerais suivre tes conseils shaoyin, mais je ne vois pas comment faire dans la mesure, ou d'apres moi il me faut deux pipes, et que ces deux pipes doivent etre declarees en dehors du main pour une question de portée, non ?
du coup, je suis obligée de faire deux fonctions : pere1 et pere2 et fils1 et fils2
non ????
 
Soyez indulgents, je debute, je stresse et j'ai mon exam qui arrive  :cry:  
 
 

Code :
  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <unistd.h>
  4. #include <stdlib.h>
  5. #include <stddef.h>
  6. #include <sys/wait.h>
  7. #include <sys/msg.h>
  8. #include <sys/sem.h>
  9. #include <signal.h>
  10. #include <string.h>
  11. #include <sys/file.h>
  12. void pere1();
  13. void pere2();
  14. void fils1();
  15. void fils2();
  16. int verif();
  17. int rand_a_b();
  18. //variables des tubes en lecture et en ecriture - 1 pour chaque equipe
  19. int pip1[2], pip2[2];
  20. char buff[4];
  21. // variables pour la sélection aléatoire des fichiers :
  22. int num_fichier=0;
  23. int min = 0000;
  24. int max = 9999;
  25. FILE *f= NULL;
  26. int main()
  27. {
  28. // les processus (pg1 sous processus pa1.1 a 5 et processus pg2 avec sous processus pa2.1 a 5)
  29. pid_t pg1,pg2;
  30. // variables pour récupérer nb de points
  31. int total_equipe1=0;
  32. int total_equipe2=0;
  33. // creation du premier processus general - equipe 1
  34. pg1=fork();
  35. if (pg1==0) {
  36. // creation pipe a partager entre pg1 et ses 5 sous processus
  37. // signale erreur si pb à la création d'un pipe
  38. if(pipe(pip1) == -1)
  39. {
  40.  perror("Erreur à la création du tube de communication 1." );
  41.  exit(-1);
  42. }
  43. // création des 5 sous processus - equipe 1
  44. // et appelle les fonctions selon type de processus
  45. int nb = 0;
  46. pid_t pid;
  47. do
  48. {
  49.    pid = fork ();
  50.    if(pid==0){
  51.        fils1();}
  52.    nb++;
  53. } while (nb < 5);
  54. pere1();
  55. // compteur de points equipe 1
  56. // statut : exit(0) => 0 en cas de mort ou d'échec, exit(1) => 1 en cas de reussite
  57. int tot1;
  58. while(wait(&tot1) != -1){
  59. total_equipe1 += WEXITSTATUS(tot1);
  60. }
  61. }
  62. //creation du deuxième processus general - equipe 2
  63. pg2=fork();
  64. if (pg2==0) {
  65. // creation pipe a partager entre pg2 et ses 5 sous processus
  66. // signale erreur si pb à la création d'un pipe
  67. if(pipe(pip2) == -1)
  68. {
  69.  perror("Erreur à la création du tube de communication 2." );
  70.  exit(-1);
  71. }
  72. // création des 5 sous processus - equipe 2
  73. // et appelle les fonctions selon type de processus
  74. int nb = 0;
  75. pid_t pid;
  76. do
  77. {
  78.    pid = fork ();
  79.    if(pid==0){
  80.        fils2();}
  81.    nb++;
  82. } while (nb < 5);
  83. pere2();
  84. // compteur de points equipe 2
  85. // statut : exit(0) => 0 en cas de mort ou d'échec, exit(res) => valeur de 'res' en cas de reussite
  86. int tot2;
  87. while(wait(&tot2) != -1){
  88. total_equipe2 += WEXITSTATUS(tot2);
  89. }
  90. }
  91. // qui a gagné ?
  92. if (total_equipe1 > total_equipe2)
  93. {
  94. printf("l'equipe 1 gagne avec %d points contre %d points pour l'équipe 2", total_equipe1, total_equipe2);
  95. }
  96. else {
  97. if (total_equipe1 < total_equipe2)
  98. {
  99. printf("l'equipe 2 gagne avec %d points contre %d points pour l'équipe 1", total_equipe2, total_equipe1);
  100. }
  101. else {
  102. printf("les deux équipes dont à égalité avec %d points", total_equipe2);
  103. }
  104. }
  105. return (0);
  106. }// fin main
  107. // equipe 1
  108. void pere1(){
  109. // mise en place du timing
  110. alarm(20);
  111. while(1) {
  112. // sélection des fichiers
  113. rand_a_b(min, max);
  114. // ecriture et transmission des n° de fichiers via un pipe
  115. close(pip1[0]);
  116. printf("[Père :]Ecriture dans le tube de communication 1.\n" );
  117. write(pip1[1],  &num_fichier, sizeof(int));
  118. //EOF est envoyé aux processus lisant les données écrites dans le tube
  119. close(pip1[1]);
  120. }
  121. }
  122. void fils1(){
  123. // initialisation de la variable permettant d'incrémenter le compteur avec le nombre de points gagnés
  124. int res = 0;
  125. // initialisation de la variable signal  
  126. int sig =0;
  127. // a répéter tant que le pipe n'est pas vide et tant que la sortie n'est pas explicitement demandée  
  128. do {
  129. // verifie si il a recut un signal SIG_QUIT
  130. signal(SIGQUIT, verif);
  131. if (sig==1) exit(0);
  132. //lit le n° de fichier  
  133. close(pip1[1]);
  134. printf("[Fils :]Attente de lecture\n" );
  135. read(pip1[0], buff, 4);
  136. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  137. close(pip1[0]);
  138. // transforme le int num_fichier en string et crée le nom de fichier  
  139. char s[10];
  140. sprintf(s,"F%d.bin",buff);
  141. // ouverture du ficher en lecture / ecriture binaire / à la fin
  142. f= fopen(s,ab+);
  143. // verrou exclusif et non bloquant sur le fichier  
  144. int l;
  145. l = flock(f, LOCK_EX | LOCK_NB);
  146. //si l=-1 alors, le fichier est deja utilisé, mise en attente et nouvelle tentative :
  147. if (l==-1) {
  148. do {
  149. sleep(5);
  150. l = flock(f, LOCK_EX | LOCK_NB);} while (l==-1);
  151. // pid et ppid :
  152. pid_t a = getpid();
  153. pid_t b = getppid();
  154. int c;
  155. int p;
  156. // ecriture du n° d'équipe (ppid) et du pid
  157. fwrite(&b, sizeof(int), 1, f);
  158. fwrite(&a, sizeof(int), 1, f);
  159. // on remonte de deux infos pour lire le ppid précédent inscrit - 1 info = 4 octets
  160. do
  161. { fseek (f, -16 , SEEK_CUR);
  162. // lecture du ppid  
  163. fread(&c, sizeof(c), 1, f);
  164. // comparaison des deux ppid  
  165. // si ils sont différents, on lit le pid, on envoie le signal au processus concerné  
  166. if (c!=b) {
  167. fread (&p, sizeof(p), 1, f);
  168. kill (p, SIG_QUIT)
  169. }
  170. // et on remonte de deux infos tant que l'on trouve un ppid différent
  171. } while (c!=b);
  172. // sinon, on ferme le fichier
  173. // fermeture du fichier
  174. fclose(f);
  175. // on délock  
  176. flock (f, LOCK_UN);
  177. res++;
  178. } while (read(pip1[0], buff, 4)>0;
  179. exit(res);
  180. }
  181. // equipe 2
  182. void pere2(){
  183. // mise en place du timing
  184. alarm(20);
  185. while(1) {
  186. // sélection des fichiers
  187. rand_a_b(min, max);
  188. // ecriture et transmission des n° de fichiers via un pipe
  189. close(pip2[0]);
  190. printf("[Père :]Ecriture dans le tube de communication 2.\n" );
  191. write(pip2[1],  &num_fichier, sizeof(int));
  192. //EOF est envoyé aux processus lisant les données écrites dans le tube
  193. close(pip2[1]);
  194. }
  195. }
  196. void fils2(){
  197. // initialisation de la variable permettant d'incrémenter le compteur avec le nombre de points gagnés
  198. int res = 0;
  199. // initialisation de la variable signal  
  200. int sig =0;
  201. // a répéter tant que le pipe n'est pas vide et tant que la sortie n'est pas explicitement demandée  
  202. do {
  203. // verifie si il a recut un signal SIG_QUIT
  204. signal(SIGQUIT, verif);
  205. if (sig==1) exit(0);
  206. //lit le n° de fichier  
  207. close(pip2[1]);
  208. printf("[Fils :]Attente de lecture\n" );
  209. read(pip2[0], buff, 4);
  210. printf("[Fils :]Contenu de la lecture : %s\n",buff);
  211. close(pip2[0]);
  212. // transforme le int num_fichier en string et creation du nom de fichier  
  213. char s[10];
  214. sprintf(s,"F%d.bin",buff);
  215. // ouverture du ficher en lecture / ecriture binaire / à la fin
  216. f= fopen(s,ab+);
  217. // verrou exclusif et non bloquant sur le fichier  
  218. int l;
  219. l = flock(f, LOCK_EX | LOCK_NB);
  220. //si l=-1 alors, le fichier est deja utilisé, mise en attente et nouvelle tentative :
  221. if (l==-1) {
  222. do {
  223. sleep(5);
  224. l = flock(f, LOCK_EX | LOCK_NB);} while (l==-1);
  225. // pid et ppdi :
  226. pid_t a = getpid();
  227. pid_t b = getppid();
  228. int c;
  229. // ecriture du n° d'équipe (ppid) et du pid
  230. fwrite(&b, sizeof(int), 1, f);
  231. fwrite(&a, sizeof(int), 1, f);
  232. // on remonte de deux infos pour lire le ppid précédent inscrit - 1 info = 4 octets
  233. do
  234. { fseek (f, -16 , SEEK_CUR);
  235. // lecture du ppid  
  236. fread(&c, sizeof(c), 1, f);
  237. // comparaison des deux ppid  
  238. // si ils sont différents, on lit le pid, on envoie le signal au processus concerné  
  239. if (c!=b) {
  240. fread (&p, sizeof(p), 1, f);
  241. kill (p, SIG_QUIT)
  242. }
  243. // et on remonte de deux infos tant que l'on trouve un ppid différent
  244. } while (c!=b);
  245. // sinon, on ferme le fichier
  246. // fermeture du fichier
  247. fclose(f);
  248. // on délock  
  249. flock (f, LOCK_UN);
  250. res++;
  251. } while (read(pip1[0], buff, 4)>0;
  252. exit(res);
  253. }
  254. // utilitaires communs  
  255. int verif(int num_sig) {
  256. if (num_sig==3) {
  257.  printf("je suis le processus %d et je suis mort", getpid());
  258.  sig=1;
  259.  return sig;
  260.   }
  261. // réarme pour qu'unix ne repositionne pas le traitement par défaut
  262. signal(num_sig, verif);
  263. }
  264. int rand_a_b(int min, int max){
  265. num_fichier = rand()%(max-min)+min;
  266. printf("n° de fichier à conquérir ", num_fichier );
  267. return (num_fichier);
  268. }


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  C, linux et les pipes

 

Sujets relatifs
[C# .NET] Crash d'une DataGridViewcours C++ concis ?
[C] Interpreteur de commandes - MultipipesProgrammer une communication via liaison RS232 en C
[RESOLU] linux bash caseerreur de syntaxe, probleme langage C
Buffer / Buffer overflow en C et en Java[C/C++/C#] Aspirateur de sites
Problème avec un alphabeta en C pour othello[Objective-C] Création d'image reçue via socket
Plus de sujets relatifs à : C, linux et les pipes


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR