Select bloquand en ecriture

Version imprimable

06/06/2006, 13h03
caesarvanou

Select bloquand en ecriture

Bonjour,
Je travaille sur un projet reseau ou le server ne doit pas bloquer meme s'il envois des donnees a un client qui enfin de compte ne les lis jamais. (C'est un peu idiot mains bon c'est le sujet).
J'utilise select(2) pour monitorer des sockets en lecture et en ecriture. Pour la lecture pas de probleme ca marche impec. Pour l'ecriture, si le client ne lie pas les donnees qu'on lui envois, select me dis que je peu ecrire dessus alors que ca bloque.
Comment bien utilser select pour l'ecriture sur une socket ?
Je travaille sous NetBSD.
06/06/2006, 13h52
Seb_de_lille

tu pourrais montrer ton code pour qu'on trouve le problème.

Voila le code

J'avais oublier le plus important le code

Code:

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
 
int     boucle(int s, struct sockaddr_in *client_sin, int *client_sin_len, t_param *params)
{
  struct timeval        tv;
  int                   cs;
  int                   fd_max;
  t_client              *begin_cl;
  fd_set                readf;
  fd_set                writef;
 
typedef struct  s_message
{
  char                  *message;
  struct  s_message     *next;
}               t_message;
 
typedef struct  s_client
{
  int                   fd;
  t_message             *snd_msg;
  struct s_client       *next;
}               t_client;
 
  tv.tv_sec = 1;
  tv.tv_usec = 0;
  begin_cl = NULL;
  while (1)
    {
      fd_max = ini_fd_set(&readf, begin_cl, s);
      fd_max = ini_fd_set_out(&writef, begin_cl, fd_max);
      if (select(fd_max + 1, &readf, &writef, NULL, &tv) < 0)
        {
          perror(PROJ_NAME);
          my_putstr("close\n");
          fd_max = ini_fd_set(&readf, begin_cl, s);
          fd_max = ini_fd_set_out(&writef, begin_cl, fd_max);
        }
      else if (FD_ISSET(s, &readf))
        {
          cs = accept(s, (struct sockaddr *)client_sin, client_sin_len);
          my_putstr("accept\n");
 
          begin_cl = ajoute_liste(cs, begin_cl);
        }
      my_putstr("select\n");
      begin_cl = parse_fd_set(&readf, begin_cl);
      parse_fd_set_out(&writef, begin_cl);
    }
}

Code de ini_fd_set_out

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
int     ini_fd_set_out(fd_set *writef, t_client *cl, int s)
{
  int           fd_max;
  t_client      *crt;
 
  fd_max = s;
  crt = cl;
  while (crt)
    {
      if (crt->snd_msg)
        {
          FD_SET(crt->fd, writef);
          if (crt->fd > fd_max)
            fd_max = crt->fd;
        }
      crt = crt->next;
    }
  return (fd_max);
}

Code de parse_fd_set_out

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
void    parse_fd_set_out(fd_set *writef, t_client *cl)
{
  t_client      *cl2;
 
  cl2 = cl;
  while (cl)
    {
      if (cl->snd_msg)
        {
          if (FD_ISSET(cl->fd, writef))
            {
              my_putstr("envvoi\n");
              if (send_msg(cl->snd_msg->message, cl->fd) > 0)
                {
                  free_snd_msg(cl);
                }
            }
        }
      cl = cl->next;
    }
}

Je les infs de chaque client dans une liste chainer (t_client).

t_message est une liste chainer des messages que je veux envoyer.

10/06/2006, 12h40
caesarvanou

Ca bloque toujours, utilise-je bien le FD_ISSET ?

En mettant MSG_WAITALL ou MSG_DONTWAIT ca ne bloque pas des le premier envois mais aubout d'un certain nombre d'envois ca bloque quand meme.
Enfait ce que je ne comprends pas c'est que meme en passant par un select et donc par FD_ISSET, l'envoi de message bloque toujours.
Si quelcun a un idee sur la chose car la je seche.

Normalemet quand je fait un FD_ISSET(fd_set, socket), si je n'ai pas 0 c'est que je peus ecrire sur le socket en question. Dit - moi si je me trompe.
10/06/2006, 13h48
crocodilex

Citation:

Envoyé par caesarvanou

[...]
Pour l'ecriture, si le client ne lie pas les donnees qu'on lui envois, select me dis que je peu ecrire dessus alors que ca bloque.
[...].

Pour un dialogue de ce type (enfin si le client n'ecoute pas, ce n'est pas vraiment un dialogue), il serait préférable d'utiliser le mode UDP (à confirmer par un spécialiste réseau s'il y en a un ici).