Salut tout le monde,

Voila je travaille sur un TP de programmation système en C sous linux.
Je vous expose le sujet de mon TP afin que vous puissiez comprendre mon problème :

Ecrivez un programme qui crée deux sous process communiquant par pipe. Le premier sous process (fils1) écrit une chaine dans le pipe. Celle-ci est lue par l'autre sous process (fils2) et imprimmée sur stdout. Le buffer de lecture du sous process fils2 sera de longueur 20.
- fils 1 écrit une chaine dont la longueur est INCONNUE et aléatoire entre 10 et 100. Gérer les codes de retour de lecture sur pipe pour programmer une terminaison du deuxième process.
- Si le premier envoie plusieurs messages, tous de longueurs inconnue du process de lecture, comment faire pour que ce dernier puisse reconstituer les messages d'origine ? Inventer et implémenter une solution.

Mon programme actuel envoie bien la chaine sur mon fils2 mais celui ne traite pas les dépassement sur son buffer :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
 
void
thread (int p[2], int thrd_nb)
{
  char buff1[100], buff2[20];
  int n;
  int *ptr;
 
  if (thrd_nb == 0)
    {
      close (p[0]);
      n = read (STDIN_FILENO, (void *) buff1, 100);
      write (p[1], (void *) buff1, n);
    }
  else if (thrd_nb == 1)
    {
      close (p[1]);
      n = read (p[0], (void *) buff2, sizeof(buff2));
      if(n >= sizeof(buff2)){ 
      fprintf(stdout,"buffer overflow...\n");
      if(ptr =(char *)malloc(sizeof(n))==NULL){
	perror("malloc");
	exit(EXIT_FAILURE);
	}
       ptr=&buff1;
       fprintf(stdout,"lecture en mémoire: %s \n",ptr);
       	}
      fprintf (stdout, "Lecture du pipe: ");
      fflush (stdout);
    write (STDOUT_FILENO, (void *) buff2, sizeof(buff2));}
}
 
int
main ()
{
 
  int i, pid, p[2];
 
  if (pipe (p) != 0)
    {
      perror ("pipe");
      exit (EXIT_FAILURE);
    }
  for (i = 0; i < 2; i++)
    {
      pid = fork ();
      switch (pid)
	{
	case -1:
	  perror ("fils1");
	  exit (EXIT_FAILURE);
	  break;
	case 0:
	  thread (p, i);
	  return EXIT_SUCCESS; break;
	default:
	  break;
	}
    }
  while (wait (NULL) > 0)
    ;
  return EXIT_SUCCESS;
}
Je pensais faire un malloc pour mon buffer (buff2) fils2 afin d'y stocker la valeurs entière envoyé par fils1.
Mais j'avoue m’emmêler les pinceaux sur son utilisation étant encore débutant...

Cordialement.