Voir la source de 2014:04:08:TP:C:Socket

[[category:EPITA:TP:20132014]]

== Introduction ==

Voici la base de code d'un serveur TCP:

<source lang="C">
int main(int argc, char *argv[])
{
  int fd_accept;
  socklen_t rlen;
  int port = 4242;
  struct sockaddr_in local;
  struct sockaddr_in remote;

  /* Initialisation */
  memset(&local, 0, sizeof(local));
  local.sin_family = AF_INET;
  local.sin_addr.s_addr = htonl(INADDR_ANY);
  local.sin_port = htons(port);

  /* On cree la socket */
  fd_accept = socket(AF_INET, SOCK_STREAM, 0);

  /* On associe la socket */
  bind(fd_accept, (struct sockaddr*)&local, sizeof(local));

  /* On passe en mode ecoute */
  listen(fd_accept, 5);

  /* La boucle principale */
  for(;;)
    {
      int fd;
      /* Initialisation de la structure remote */
      memset(&remote, 0, sizeof(remote));
      remote.sin_family = AF_INET;
      rlen = sizeof(remote);

      /* On attend les connexions */
      fd = accept(fd_accept, (struct sockaddr*)&remote, &rlen);
      /* remote contient des informations sur la connexion */

      /* Ici on traite la connexion */

    } 
}
</source>

== Exercices ==

* '''Compléter le code précédant avec les en-têtes à inclure (pensez à utiliser <tt>man</tt> … )'''

On va maintenant implémenter un petit serveur dont le but est d'envoyer un fichier (toujours le même) vers le client. On se fixe un petit protocole simple, décrit par l'échange suivant (après établissement de la connexion):

<pre>
client: GET\r\n\r\n
server: SIZE taille\r\n\r\n
client: OK\r\n\r\n
server: ... envoie du fichier ...
</pre>

Les séquences <tt>\r\n\r\n</tt> correspondent à un double retour chariot dans la norme ''telnet'' (différent du ''line-feed'' Unix <tt>\n</tt> seul.)

La taille du fichier est la taille en octets (donc la taille de la transmission après reception du <tt>OK</tt>.)

Le fichier est envoyé tel quel par le serveur.

La fin de la connexion est à la responsabilité du client (comme dans tout bon protocole TCP), le serveur doit attendre en lecture sur la connexion la fin de fichier pour fermer la socket.

* '''Implémenter le ''parsing'' des messages du client à partir d'un file descriptor en lecture (comme ça vous pourrez tester sur l'entrée standard.)'''
<source lang="C">
/* read_get(fd) lit le message GET et renvoie 1 si tout va bien et 0 sinon */
int read_get(int fd);
/* read_ok(fd) lit le message OK et renvoie 1 si tout va bien et 0 sinon */
int read_okt(int fd);
</source>
''Note: les messages du client sont de taille fixe, donc il vous suffit de lire sur la socket jusqu'à avoir le bon nombre d'octet (7 pour le premier message et 6 pour le second.)''

* '''Implémenter le protocol à partir d'une paire de file-descriptors'''
<source lang="C">
int protocol(char *file, int fdin, int fdout);
</source>
On utilise une paire de fd pour pouvoir tester avec l'entrée et la sortie standard avant de passer au réseau, lorsque l'on utilisera le réseau, on donnera le même fd pour les deux paramètres. Si l'une des lectures (<tt>GET</tt> et <tt>OK</tt>) échoue vous devez sortir immédiatement avec 0, sinon vous renverez 1 à la fin.

Penser à la commande <tt>stat(2)</tt> pour récupérer la taille du fichier.

* '''Intéger tout ça dans le code du serveur en utilisant <tt>fork(2)</tt>'''

Si la fonction <tt>protocol</tt> échoue (retour 0) vous devez fermer la socket immédiatement, sinon il vous faudra attendre (avec <tt>read(2)</tt>) la fermeture côté client.

== Bonus ==

Vous pouvez améliorer votre serveur:

* En utilisant <tt>sendfile(2)</tt>
* En utilisant <tt>select(2)</tt> avec un ''timeout'' pour limiter l'attente de la fin de connexion

Et si vous n'avez vraiment rien à faire remplacer la gestion des connexions multiples par un usage intelligent de <tt>select(2)</tt>.