onjour à tous,

Je souhaiterai faire une manip pour savoir Combien de clients mon système va placer dans la file d’attente après qu’un serveur ait effectué un listen(..., 1) avant de refuser les connexions ?

Question 1 : comment dois-je faire pour saturer mon système de manière à trouer le nombre maximal de clients.

Question 2 : Je joins les codes client et serveur que j'utilise. Quand je compile j'ai une erreur sur le code serveur et je ne comprends pas pourquoi.

Question 3 : quelle commande dois-je appliquer pour savoir le nombre de clients que mon système met dans la file d'attente ?

Merci d'avance pour votre aide 

Code serveur :

 
 /* serveur.c
 Repondre en synchrone aux demandes de connexion sur une socket.
 */
 # include "sys. h"
 
char *
answersync(char * port, int (* fun)(int ) ) {
struct addrinfo * info, * p;
struct addrinfo indices;
int fd, t;
int toclient ;
struct sockaddr fromaddr;
unsigned int len = sizeof fromaddr;
 
 
memset(&indices, 0, sizeof indices) ;
indices. ai_flags = AI_PASSIVE; // accepter de toutes les machines
indices. ai_family = AF_INET; // seulement IPv4
indices. ai_socktype = SOCK_STREAM; // seulement TCP
 
t = getaddrinfo(0, port, &indices, &info);
if ( t != 0)
return "answer: cannot get info on port";
 
// Ouvrir la socket
for(p = info; p != 0; p = p−>ai_next){
fd = socket(p−>ai_family, p−>ai_socktype, 0); // fabriquer la socket
if ( fd >= 0)
break;
 }
if (p == 0)
return "answer: pas moyen d'avoir une socket";
 
t = 1; // re−utiliser l ' adresse
t = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &t, sizeof t);
if ( t < 0){
perror("setsockopt");
fprintf (stderr, "answer: on continue quand meme\n");
 }
 
 if (bind(fd, p−>ai_addr, p−>ai_addrlen) < 0){ // donne lui un role
 close( fd);
return "answer: pas moyen de binder la socket";
 }
 
freeaddrinfo(info);
 
t = listen ( fd, 1); // on veut des connexions par ici
if ( t < 0){
close( fd);
return "answer: pas moyen d'ecouter sur la socket";
 }
 
for(;;) {
toclient = accept(fd, &fromaddr, &len); // accept
if ( toclient < 0)
return "answer: pas moyen d'accepter\n";
 
fun(toclient ) ;
close( toclient ) ;
 }
 }
 
# if DEBUG
 /*
 Un serveur d'echo pour tester
 */
int
foo(int n){
char c;
int t;
 
printf( "J' ai un client \n");
while((t = read(n, &c, 1)) > 0)
if (write(n, &c, 1) != 1){
perror("write") ;
break;
 }
if ( t < 0)
perror("read");
printf( "Je n'ai plus ce client \n");
return 0;
 }
 
 int
main(int ac, char * av[]) {
char * p;
p = answersync(av[1], foo);
 
perror(p);
return 1;
}
# endif /* DEBUG */

Code client :

 
/* client.c
 Renvoie une connexion vers un serveur, ou -1
 */
# include "sys.h"
 
static int alldigit(char * s)
{
  for (; *s != 0; s++) if (!isdigit(*s)) return 0 ;
  return 1 ;
}
 
int dial(char * machine, char * port)
{
  struct sockaddr_in socdesc ;
  struct servent * sp ;
  struct hostent * hp ;
  int s,
	t,
	nport ;
 
 /* transforme service et machine */
  if (! alldigit(port))
  {
    sp= getservbyname(port, "tcp") ;
    if (sp == NULL) return -1 ;
    nport= sp->s_port ;
  }
 
  else nport= htons(atoi(port)) ;
 
  hp= gethostbyname(machine) ;
  if (hp == 0) return -1 ;
 
  memset((char *)&socdesc, 0, sizeof socdesc) ; /* fabrique la structure server */
  memcpy((char *)&socdesc.sin_addr, hp->h_addr, hp->h_length) ;
  socdesc.sin_family= hp->h_addrtype ;
  socdesc.sin_port= nport ;
 
  s= socket(AF_INET, SOCK_STREAM, 0) ; /* fabrique la socket */
  if (s < 0) return -1;
 
  t = connect(s, (struct sockaddr *)&socdesc, sizeof socdesc);
  if (t < 0) return -1;
  else return s;
}
 
# if DEBUG
main (int ac, char * av[])
{
  char buffer[512] ;
  int t,
	fd= dial(av[1], av[2]) ;
 
  while((t= read(0, buffer, sizeof buffer)) > 0)
  {
    write (fd, buffer, t) ;
    t= read(fd, buffer, sizeof buffer) ;
    printf("Recu %d octets en echo\n", t) ;
    write(1, buffer, t);
  }
}
# endif

Code sys.h

 
/* sys.h
Inclure
 */
# include <sys/types.h>
# include <sys/socket.h>
# include <netinet/in.h>
# include <stdio.h>
# include <netdb.h>
# include <unistd.h>
# include <ctype.h>
# include <stdlib.h>
# include <signal.h>
# include <string.h>
# include <assert.h>
 
int dial(char * host, char * port);          // client
char * answer(char * port, int (*fun)(int)); // serveur