/*  streamSer.c  -  sockets */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <stdio.h>
#include <errno.h>

#define   PORT_SERVEUR  2222

#include "creerSocket.h"
#include "streamOp.h"

/**********************************************************************/
/*                            LE SERVICE                              */
/**********************************************************************/
void service(int sock_service)
{
 int  ok;
 long l;

 ok = readLong(sock_service,&l);
 if (ok==-1 || ok==0) { perror("readLong"); exit(EXIT_FAILURE); }

 l++;
 ok = writeLong(sock_service,&l);
 if (ok==-1 || ok==0) { perror("writeLong"); exit(EXIT_FAILURE); }
}
/**********************************************************************/
/*                          Pour les zombies                          */
/**********************************************************************/

void eliminer_zombie(int signum)
{
 pid_t pid;
 printf("Terminaison d'un processus de service"
        " detectee avec le signal %d\n",signum);
 do {
     pid = waitpid(-1,NULL,WNOHANG);
 } while (pid!=-1 && pid!=0);
}

void initSignalAction(int signum, void(*fct)(int))
{
  struct sigaction action;

  action.sa_handler = fct;
  sigfillset( &(action.sa_mask) );
  action.sa_flags = 0;

  if (sigaction(signum,&action, NULL) != 0)
     fprintf(stderr,"Signal %d non capture\n",signum);
}
/**********************************************************************/


int main (void) {

  int                sock_ecoute, sock_service;

  unsigned short     port;

  struct sockaddr_in adr ;
  socklen_t          lgradr ;

  pid_t  pid;
                                             /* SIGCHLD : fin d'un */
  initSignalAction(SIGCHLD,eliminer_zombie); /*   processus fils   */

  port = PORT_SERVEUR;
  sock_ecoute = creerSocket(&port, SOCK_STREAM);

  if (listen(sock_ecoute,5)==-1) { perror("listen"); exit(EXIT_FAILURE); }

  while (1) {

    printf("Attente de demande de connexion...\n");
    
    lgradr=sizeof(struct sockaddr_in);
    sock_service = accept(sock_ecoute, (struct sockaddr*)&adr, &lgradr);

    if (sock_service==-1) {
                            if (errno!=EINTR) perror("accept");
                            continue;
    }

    pid = fork();

    switch (pid) {

      case -1 : perror("fork");          /* En cas d'erreur   */
                close(sock_ecoute);      /* de fork, on ferme */ 
                close(sock_service);     /* les sockets et on */
                exit(EXIT_FAILURE);      /* arrete le serveur */
                break;

      case  0 : close(sock_ecoute);      /* Le fils traite la */
                service(sock_service);   /* demande. Une fois */
                close(sock_service);     /* le service rendu, */
                exit(EXIT_SUCCESS);      /* on arrete le fils */
                break;

      default : close(sock_service);     /* Le pere ne traite */
                break;                   /* pas la demande et */
                                         /* va vers le while..*/
    }
  }

  return EXIT_SUCCESS;
}