Bonjour tlm,
voici exactement la description de mon problème  mon problème:
1 - j'ai une variable buffer sur laquelle je me met ce que je recoit avec recv sur chaque socket
2 - tous les données qui arrive dans buffer doivent être stocker dans une variable gloable pointé par tab.
3 - pour ne pas alourdir le serveur, il faut que chaque fois ou je traite des éléments dans tab, je les enlève et je libère l'espace mémoire qui a été allouée pour ne pas arriver à un point où tab devient tres grand
 
1 j'ai reussit à le faire,
par contre 2 et 3, je ne sais pas comment les faire, svp, pouvez vous m'aidez et me dire comment faire ca ?? (je suis débutante en C)
 
merci ,
Sara
 
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#define MAXPENDING 5    /* Max connection requests */
#define BUFFSIZE 32
 
void Die(char *mess) {perror(mess); exit(1);}
 
void HandleClient(int sock, char *tab) {
 
 char buffer[BUFFSIZE];
 int i, received = -1;
 /* Receive message */
 if ((received = recv(sock, buffer, BUFFSIZE, 0)) < 0) {
  Die("Failed to receive initial bytes from client" );
 }
 
 /* Send bytes and check for more incoming data in loop */
 while (received > 0) {
  /* Send back received data */
  if (send(sock, buffer, received, 0) != received) {
   Die("Failed to send bytes to client" );
  }
  /* Check for more data */
  if ((received = recv(sock, buffer, BUFFSIZE, 0)) < 0) {
   Die("Failed to receive additional bytes from client" );
  }
  for(i=0; i < 4; i++){
   printf("%.2x\n",buffer[i]);
  }
 }
 close(sock);
}
 
int main(int argc, char *argv[]){
 
 int serversock, clientsock;
 struct sockaddr_in echoserver, echoclient;
 char *tab;
 
 if (argc != 2) {
  fprintf(stderr, "USAGE: echoserver <port>\n" );
               exit(1);
 }
 
 /* Create the TCP socket */
 if ((serversock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  Die("Failed to create socket" );
 }
 
 printf("Bonjour 1\n" );
 /* Construct the server sockaddr_in structure */
 memset(&echoserver, 0, sizeof(echoserver));       /* Clear struct */
 echoserver.sin_family = AF_INET;                  /* Internet/IP */
 echoserver.sin_addr.s_addr = htonl(INADDR_ANY);   /* Incoming addr */
 echoserver.sin_port = htons(atoi(argv[1]));       /* server port */
 printf("Bonjour 2\n" );
 
 /* Bind the server socket */
 if (bind(serversock, (struct sockaddr *) &echoserver, sizeof(echoserver)) < 0) {
  Die("Failed to bind the server socket" );
 }
 
 printf("Bonjour 3\n" );
 
 /* Listen on the server socket */
 if (listen(serversock, MAXPENDING) < 0) {
  Die("Failed to listen on server socket" );
 }
 
 printf("Bonjour 4\n" );
 /* Run until cancelled */
 while (1) {
  unsigned int clientlen = sizeof(echoclient);
               /* Wait for client connection */
               if ((clientsock =
                  accept(serversock, (struct sockaddr *) &echoclient, &clientlen)) < 0) {
                 Die("Failed to accept client connection" );
               }
               fprintf(stdout, "Client connected: %s\n", inet_ntoa(echoclient.sin_addr));
               HandleClient(clientsock, tab);
 }
}

balises code stp

dsl    
voici le code avec la balise code
 

 
Vraiment pas claire ta question.
 
Ton protocole à l'air synchrone. Ce que tu reçois, tu le renvoies à l'emetteur. Donc j'en déduit que les points 2 et 3 ... ne servent à rien. Si à la limite tu ne renvoyais pas la même quantité que ce que tu reçois, la bufferisation serait pertinente.
 
Ou alors c'était pour faire des logs, mais la purge serait asynchrone dans ce cas.
 
Bref, pas clair du tout  

S'il s'agit d'un TP c'est pas un TP de débutant.
 
Bon, le mécanisme de remplissage d'un tableau dynamique en continu est simple
1) tu définis une taille initiale pour ton tableau et tu stockes cette taille dans "size". Puis tu alloues ton tableau

et tu initialises une variable "nb" à 0. Cette variable contiendra le nb d'éléments réellement présents dans ton tableau. Pour bien faire, il faudrait regrouper le tableau, la variable "size" et la variable "nb" dans une structure vu qu'elles vont ensemble mais on va pas compliquer
2) dès que tu dois stocker un élément

• tu commences par regarder si nb est égal à "size". Si c'est le cas ça veut dire que t'as plus de place pour stocker cet élément donc si c'est le cas tu augmentes "size" de "N" puis tu réalloues de l'espace pour "tab"

• tu stockes cet élément dans tab[nb]
• tu incrémentes nb

Voilà la base. Un bon programmeur vérifie en plus le retour du malloc voir si l'allocation a réussi (faut donc gérer si ça rate) et récupère le retour du realloc dans un autre pointeur que "tab" (pour ne pas perdre "tab" si le ralloc rate) et si le realloc ne rate pas, récupère alors le nouveau pointeur dans "tab"

 
Concernant la partie "libération" c'est un peu plus compliqué. En fait ça dépend comment tu traites ton "tab"
1) si tu traites tes éléments en partant de la fin (LIFO), alors pas de pb. A chaque élément traité tu décrémentes "nb". Le prochain ajout viendra prendre la place de l'élément traité.
2) si tu traites en partant du début, (FIFO) je vois pas trop comment faire ça simplement. Tu peux utiliser alors un tableau parallèle de gestion des indices libres ou alors abandonner l'idée du tableau dynamique pour le remplacer par une liste chaînée. Mais c'est absolument pas du niveau "débutant"...

Le plus simple serait de gerer le tableau comme un buffer circulaire:
On pointe sur la zone d'ajout, et la zone de traitement.
On verifie a chaque ajout qu'il reste un minimum de place, sinon, realloc.
Et on arrive en bout de traitement quand on on pointe au meme endroit que la zone d'ajout.
A+,

merci les mecs pour vos réponse
en fait je voudrais bien implémenter une FIFO (bien sur le champ data sera un pointeur sur char ... c'est le contenu du buffer recu) .... pouvez vous m'expliquez svp comment faire
Merci

http://mapage.noos.fr/emdel/clib.htm
Module FIFO (basique : octets)
Module GFIFO (Générique, n'importe quelle données)
 
Pose des questions si tu ne comprends pas.