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

/* codul de eroare returnat de anumite apeluri */
extern int errno;

struct operation
{
    int number1;
    int number2;
    int number3;
    int number4;
    int number5;
};

/* portul de conectare la server*/
int port;

/* programul */
int
main (int argc, char *argv[])
{
  int sd;            /* descriptorul de socket */
  struct sockaddr_in server;    /* structura folosita pentru conectare */
  struct operation request;    /* cererea trimisa clientului */
  char mesaj[100];
  
  int valid_input = 0, exit_flag = 0;

  /* exista toate argumentele in linia de comanda? */
  if (argc != 3)
    {
      printf ("Sintaxa: %s <adresa_server> <port>\n", argv[0]);
      return -1;
    }

  /* stabilim portul */
  port = atoi (argv[2]);

  /* cream socketul */
  if ((sd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
    {
      perror ("Eroare la socket().\n");
      return errno;
    }

  /* umplem structura folosita pentru realizarea conexiunii cu serverul */
  server.sin_family = AF_INET;
          /* familia socket-ului */
  server.sin_addr.s_addr = inet_addr(argv[1]);
        /* adresa IP a serverului */
  server.sin_port = htons (port);
          /* portul de conectare */

  /* ne conectam la server */
  if (connect (sd, (struct sockaddr *) &server,
           sizeof (struct sockaddr)) == -1)
    {
      perror ("Eroare la connect().\n");
      return errno;
    }

	/* citim mesajul de intampinare */
    if(recv(sd, mesaj, 100,0) < 0)
    {
		perror("Eroare la read()!\n");
		return errno;
    }
    printf("%s\n", mesaj);
	
  /* citirea mesajului si trimiterea catre server */
  bzero (&request, sizeof(struct operation));
 // printf ("Introduceti cele 5 numere: ");
  scanf ("%d %d %d %d %d", &request.number1, &request.number2, &request.number3, &request.number4, &request.number5);
  
	while(exit_flag == 0)
	{
		if((request.number1 > 0) && (request.number1 < 1000))
			exit_flag = 1;
		else
		{
			valid_input = 0;
			printf("OOPPS!Primul numar NU este intre 0 si 1000!\nIncercati un nou numar in acest interval!\n");
			scanf("%d", &request.number1);
		}
		if((request.number2 > 0) && (request.number2 < 1000))
			exit_flag = 1;
		else
		{
			valid_input = 0;
			printf("OOPPS!Al doilea numar NU este intre 0 si 1000!\nIncercati un nou numar in acest interval!\n");
			scanf("%d", &request.number2);
		}
		if((request.number3 > 0) && (request.number3 < 1000))
			exit_flag = 1;
		else
		{
			valid_input = 0;
			printf("OOPPS!Al treilea numar NU este intre 0 si 1000!\nIncercati un nou numar in acest interval!\n");
			scanf("%d", &request.number3);
		}
		if((request.number4 > 0) && (request.number4 < 1000))
			exit_flag = 1;
		else
		{
			valid_input = 0;
			printf("OOPPS!Al patrulea numar NU este intre 0 si 1000!\nIncercati un nou numar in acest interval!\n");
			scanf("%d", &request.number4);
		}
		if((request.number5 > 0) && (request.number5 < 1000))
			exit_flag = 1;
		else
		{
			valid_input = 0;
			printf("OOPPS!Al cincilea numar NU este intre 0 si 1000!\nIncercati un nou numar in acest interval!\n");
			scanf("%d", &request.number5);
		}
	}
	
  fflush (stdout);
  
      request.number1 = ntohl(request.number1);
      request.number2 = ntohl(request.number2);
      request.number3 = ntohl(request.number3);
      request.number4 = ntohl(request.number4);
      request.number5 = ntohl(request.number5);


  if (send (sd, &request, sizeof(struct operation), 0) <= 0)
    {
      perror ("Eroare la write() spre server.\n");
      return errno;
    }

  int result;
  /* citirea raspunsului dat de server 
     (ne blocam pina cind serverul raspunde) */
  if (recv (sd, &result, sizeof(int), 0) < 0)
    {
      perror ("Eroare la read() de la server.\n");
      return errno;
    }
    
  result = ntohl((int)result);
  
  /* afisam mesajul primit */
  printf ("Rezultatul primit este: %d\n", result);

  /* inchidem conexiunea, am terminat */
  close (sd);
}

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <errno.h>
#include <error.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <signal.h>

const int PORT_SERVER = 6440; 			/* portul folosit */
const int CLIENTI_MAXIM = 3;			/* nr maxim de clienti acceptati */

extern int errno; 						/* eroare returnata */
int nr = 0;								/* numar de clienti */
int port;								/* portul*/
struct operation request;			   	/* cererea primita de server */
int sockfd, newsockfd, frlen, servlen;
int magic;

struct operation
{
    int number1;
    int number2;
    int number3;
    int number4;
    int number5;
};
void genereaza_numar()
{
    srand(time(NULL));
    magic = rand() % 1001;
}

/*functie de tratare a semnalelor*/
void semnal (int nr_semnal) 
{
	if (nr_semnal == SIGCHLD)
	{
		wait(NULL);
		nr--; /*s-a pierdut un client*/
		printf("A iesit clientul %d!\n", nr+1);
		fflush(stdout);
		return;
	}
}

/*operatiile pentru fiecare client*/
void doprocessing(int sock)
{
	char mesaj[100];
	
	if( nr == 0)
		printf("S-a conectat un client...Avem %d client\n", nr + 1);
	else
		printf("S-a conectat un client...Avem %d clienti\n", nr + 1);
    fflush(stdout);
	
	sprintf(mesaj, "SERVER>Sunteti clientul cu numarul %d.\nSERVER>Introduceti cele 5 numere(0..1000):", nr + 1);
    
    /* trimitem mesajul de intampinare */
    if(send(newsockfd, mesaj, strlen(mesaj),0) != strlen(mesaj))
    {
	/* Eroare! */
	shutdown(newsockfd, 2);
	exit(errno);
    } 
	 
	/* am realizat conexiunea, asteptam mesajul... */
	bzero (&request, sizeof(struct operation));
	printf ("Asteptam cererea...\n");
	fflush (stdout);
      
	/* citirea mesajului */
	int nrbytes = recv (newsockfd, &request, sizeof(struct operation), 0);
	
	/*incercam sa citim datele de la client*/
	if (nrbytes <= 0)
    {
		perror ("Eroare la read() de la client.\n");
		close (newsockfd);    /* inchidem conexiunea cu clientul */
	}
	
	/*verificam integritatea datelor*/
	if (nrbytes < sizeof(struct operation))
    {
		perror ("Date primite incomplet\n");
		close (newsockfd);
    }
	
	request.number1 = ntohl(request.number1);
    request.number2 = ntohl(request.number2);
    request.number3 = ntohl(request.number3);
    request.number4 = ntohl(request.number4);
	request.number5 = ntohl(request.number5);

	printf ("Cerere primita... \n           In curs de rezolvare: %d %d %d %d %d \n", 
											request.number1, request.number2, request.number3, request.number4, request.number5);
      
      
	/* rezolvarea cererii */

	int a=0;
	int b=0;
	int c=0;
	int d=0;
	int e=0;
	int min=0;
	int result=0;

	/* diferenta dintre numarul magic si numerele primite */
	if (magic >= request.number1)
		a = magic - request.number1;
	else
		a = request.number1 - magic;

	if (magic >= request.number2)
		b = magic - request.number2;
	else
		b = request.number2 - magic;

	if (magic >= request.number3)
		c = magic - request.number3;
	else
		c = request.number3 - magic;

	if (magic >= request.number4)
		d = magic - request.number4;
	else
		d = request.number4 - magic;

	if (magic >= request.number5)
		e = magic - request.number5;
	else
		e = request.number5 - magic;

	printf("Diferentele numerelor sunt: %d %d %d %d %d\n", a, b, c, d, e);
	
	/* verificare care numar este mai aproape de numarul magic */
	if (a > b)
		min = b;
	else 
		min = a;

	if (min > c)
		min = c;

	if (min > d)
		min = d;

	if (min > e)
		min = e;
	
	printf("Diferenta minima este: %d\n", min);
	printf("a= %d, b= %d, c= %d, d= %d, e= %d\n", a, b, c, d, e);
	
	/*selectam numarul care este mai apropiat de numarul magic*/
	if(min == a) 
		result = request.number1;
	else
		if (min == b) 
			result = request.number2;
		else 
			if (min == c)  
				result = request.number3;
			else 
				if (min == d) 
					result = request.number4;
				else
					result = request.number5;
		
	printf("result = %d\n", result);
	
	printf("TEST %d\n", magic);
	printf("Numarul cel mai apropiat de cel random a fost: %d\n", result);
		
    result = htonl(result);
	
	/* returnam rapunsul clientului */
    if (send (newsockfd, &result, sizeof(int),0) <= 0)
    {
		perror ("Eroare la write() catre client.\n");
    }
    else
		printf ("Trasmitere cu succes.\n");
      /* am terminat cu acest client, inchidem conexiunea */
      close (newsockfd);
}

/*programul principal*/
int main (int argc, char * argv[])
{
	struct sockaddr_in server , from;    	/* structurile folosite de server si client */
	int port;								/* portul */
	int pid;								/* Process ID from fork() */

	
	/* setare port in cazul specificarii explicite */
	if (argc > 1)
	{
		port = atoi(argv[1]);
	}
	else
		port = PORT_SERVER;
	
	genereaza_numar();
    printf("Numarul generat este %d\n", magic);
	
	/*tratarea semnalele*/
	if (signal (SIGCHLD, semnal) == SIG_ERR)
	{
		perror("signal()");
		exit(errno);
	}
	
	/* cream un socket */
	sockfd = socket(AF_INET, SOCK_STREAM,0);
	if (sockfd <0)
	{
		perror("Eroare la socket().");
		exit(1);
	}
	
	frlen = sizeof (from);
	servlen = sizeof (server);
	
	/* pregatim structurile de date */
	bzero (&server, servlen);
	bzero (&from, frlen);
  
	/* umplem structura folosita de server */
	server.sin_family = AF_INET;    					/* stabilirea familiei de socket-uri */
	server.sin_addr.s_addr = htonl (INADDR_ANY);		/* acceptam orice adresa */
	server.sin_port = htons (port);						/* utilizam un port utilizator */
	
	/* atasam socketul */
	if (bind (sockfd, (struct sockaddr *) &server, sizeof(struct sockaddr)) == -1)
    {
		perror ("Eroare la bind().\n");
		exit(1);
    }
	
	/* punem serverul sa asculte daca vin clienti sa se conecteze */
	if (listen (sockfd, 3) == -1)
    {
		perror ("Eroare la listen().\n");
		exit(1);
    }
		
		printf ("Asteptam la portul %d...\n", port);
		fflush (stdout);
	
	/*servim in mod concurent clientii*/
	while (1) 
    {
        newsockfd = accept(sockfd, (struct sockaddr *) &from, &frlen);
        if (newsockfd < 0)
        {
            perror("Eroare la accept().\n");
            exit(1);
        }
		
		/* Verificam daca am ajuns la numarul maxim de clienti */
		if (nr == CLIENTI_MAXIM)
		{
			perror("Numar maxim de clienti atins. Incercati mai tarziu.\n");
			shutdown(newsockfd,2);
			continue;
		}
		
        /* Cream procesul copil*/
        pid = fork();
        if (pid < 0)
        {
            perror("Eroare la fork().\n");
			exit(1);
        }
        if (pid == 0)  
        {
            /* Procesul parcurs de client */
            close(sockfd);
            doprocessing(newsockfd);
            exit(0);
        }
        else
        {
            close(newsockfd);
        }
		nr++;
    }
}