Select avec écriture non bloquante

Version imprimable

24/05/2006, 11h48
Invité

Select avec écriture non bloquante

Bonjour tout le monde ! Je sais que le sujet du select est largement aborde ici, mais je n'ai pas trouve ce dont j'avais besoin...
Quelqu'un pourrait il m'expliquer un peu comment marche le select pour de l' _ecriture_ "non bloquant" (a supposer que ca existe bien).

En gros, omment faire pour utiliser le fd_set write dans un select?
24/05/2006, 12h12
Skyounet

Je n'ai pas tres bien compris que veux tu faire exactement.

Je sais pas si ca peux t'aider mais voila.
Voici les descripteurs des entrées/sorties standard

STDIN 0
STDOUT 1
STDERR 2

Il y a des macros pour ca mais me rappelle plus lesquelles.
24/05/2006, 12h14
je®ome

STDIN_FILENO
STDOUT_FILENO
STDERR_FILENO

sont les macros correspondant.
24/05/2006, 12h21
Invité
Erm, desole de m'etre (tres) mal exprime. Je reprends en creusant un peu plus.

Je travaille actuellement sur un serveur qui doit gerer des sockets, et doit pouvoir ecrire/lire dessus : j'utilise donc un select().
Pour la lecture, tout se passe tres bien, pas de probleme avec ca ! Mais je n'arrive pas a comprendre comment implementer un fd_set writefds et l'utiliser avec le select.
Toutes mes certitudes se resument a une ligne :
Code:

1 2 select(fd_max + 1, &fd_read, &fd_write, NULL, &tv)
Comment faire pour le write ? Ou faire des SET, des ISSET, pour que ca fonctionne ? Comment remplir un buffer et, s'il est rempli SETer un fd du fd_set pour dire a select de lire ?
24/05/2006, 16h10
Emmanuel Delahaye

Citation:

Envoyé par NaeiKinDus

Bonjour tout le monde ! Je sais que le sujet du select est largement aborde ici, mais je n'ai pas trouve ce dont j'avais besoin...
Quelqu'un pourrait il m'expliquer un peu comment marche le select pour de l' _ecriture_ "non bloquant" (a supposer que ca existe bien).

En gros, omment faire pour utiliser le fd_set write dans un select?

Un écriture synchrone n'est blocante que pendant le temps de l'écriture. Ca pose un problème ? En général, on s'en contente, parce que le mécanisme d'écriture est bufferisé et gère déjà tout ce qu'il faut...

Mais si tu y tiens vraiment, on peut réinventer la roue et faire des écritures asynchrones, mais il ne faut pas enchainer avant d'avoir été prévenu de la fin de l'écriture en cours. Il suffit de programmer le bon champ de select (ecriture) et de tester le bon bit (celui du flux sortant). Ca risque d'être assez compliqué, car il va falloir buffériser les demande d'écriture...

Je te laisse lire la doc de select().

Ce sont les correcteurs de nos projets qui demandent que le select gere aussi le writefds...
J'ai tente de contourner le probleme en faisant ca :
-> Le client se connecte, le serveur lui envoie un message.

Le select()

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
 
void            do_serv(t_env *env)
{
  int            i;
  int            fd_max;
  fd_set        fd_read;
  fd_set        fd_write;
  struct timeval    tv;
 
  tv.tv_sec = 5;
  tv.tv_usec = 0;
  while (1)
    {
      fd_max = 0;
      FD_ZERO(&fd_read);
      FD_ZERO(&fd_write);
      for (i = 0; i < MAX_FD; i++)
    {
      if (env->fd_type[i] != FD_FREE)
        {
          FD_SET(i, &fd_read);
          fd_max = i;
          if (env->buff_written[i][0])
        FD_SET(i, &fd_write);
        }
    }
      if (select(fd_max + 1, &fd_read, &fd_write, NULL, &tv) == -1)
    print_error("select", env);
      for (i = 0; i < MAX_FD; i++)
    {
      if (FD_ISSET(i, &fd_read))
        env->fct_read[i](i, env);
      if (FD_ISSET(i, &fd_write))
        env->fct_write[i](i, env);
    }
  }
}

La fonction d'ecriture

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
void    client_write(int fd, t_env *env)
{
  int    ret;
 
  if ((ret = write(fd, env->buff_written[fd], strlen(env->buff_written[fd]))) == -1)
    {
      print_error("write", env);
    }
  memset(env->buff_written[fd], '\0', strlen(env->buff_written[fd]));
  free(env->buff_written[fd]);
}

Et la structure qui se balade et contient toutes les infos (le env)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
typedef struct    s_env
{
  int    map_x;
  int    map_y;
  int    port;
  char    **teams;
  char    ***map;
  char    *buff;
  int    verbose;
  int    max_players;
  int    cronos;
  fct    fct_read[MAX_FD];
  fct    fct_write[MAX_FD];
  char    fd_type[MAX_FD];
  char    *buff_written[MAX_FD];
}        t_env;

Enfin donc, pour envoyer un message au connecte, je fais :

Code:

1
2
3
4
 
  env->buff_written[cs] = xmalloc(10 * sizeof(char), env);
  memset(env->buff_written[cs], '\0', strlen(tmp));
  sprintf(env->buff_written[cs], "%d %d\n", env->map_x, env->map_y);

Voila a peu pres ce que j'ai pu comprendre du man select() et de cette page :

http://www710.univ-lyon1.fr/~jciehl/Public/MAN/man2/select_tut.2.html