//codigo fuente de programa medidor de congestion

#include "def.h"
 
int main (int argc , char *argv[]){

  // ========================
  // declaracion de variables
  // ======================== 

  pid_t pid_01 , pid_02;             // pid de los procesos hijos 
   
  int pipa[2];                       // arreglo para los descriptores de la pipa
  int i;                             // contador de iteraciones
  int j;                             // variable auxiliar
  int sec_int;                       // valor entero secuencia paquete
  int buf_sec[RANGO];                // buffer que almacena secuencia paquetes
  int flag;                          // controlador de argumentos 
  int lim;                           // limite de tasa de perdidas

  double time_float;                 // valor flotante tiempo de paquetes
  double loss_max;                   // valor tasa perdida maxima
            
  char linea[80];                    // buffer que almacena linea entrante
  char *sec_str;                     // string secuencia paquete
  char *time_str;                    // string tiempo de paquetes
  char *user;                        // string destinatario e-mail

  FILE *log , *datos;                // decriptores de archivos       


  // ===========================
  // inicializacion de variables
  // ===========================
  
  i = 0;  
  loss_max = 0;

  lim = atoi (argv[3]);
  user = argv[2];

  for (j = 0 ; j < RANGO ; ++j)
    buf_sec[j] = -1;

  if (argc == 2){                                  // si solo se ingresa host remoto, se abre solo el arhivo datos  
    if ((datos = fopen ("datos" , "w")) == NULL ){
      printf ("error al abrir archivo datos\n");
      exit (1);
    }
    fprintf (datos , "0\t0\t0\n");
    flag = 0;
    fclose (datos);
  }
  else if (argc == 4){                            // si se ingresa limite de tasa y destinatario, se abre solo archivo log
    if ((log = fopen ("log" , "w")) == NULL){
      printf ("error al abrir archivo log\n");
      exit (1);
    }
    flag = 1;
    fprintf (log , "# E-mail generado por el programa : medidor de congestion\n");
    fprintf (log , "# Destinatario %s\n" , user);  
    fprintf (log , "# Host remoto %s supero el limite de tasa de perdida %3i por ciento\n\n" , argv[1] , lim);
    fclose (log);
  }
  else{                                                 // si faltan o sobran argumentos, imprime mensaje de error
    printf ("problemas con los argumentos\n");
    exit (1);
  }
  
  // ==================
  // creacion de enlace
  // ==================
 
  if (pipe (pipa) < 0){        // crea pipa    
    perror ("pipe");
    exit (1);
  }

  // ====================
  // crecion proceso ping
  // ====================

  if ((pid_01 = fork ()) < 0){     
    printf ("error al crear proceso ping\n");
    exit (1);
  } 

  // ===================
  // inicio proceso ping
  // ===================

  else if (pid_01 == 0){
    dup2 (pipa[ESCRITURA] , SAL_EST);                        // agrega salida estandar a la puerta de escritura
    close (pipa[LECTURA]);                                   // cierra  de puerta de lectura
    execl ("/bin/ping" , "ping" , argv[1]  , (char *) 0 );   // ejecuta comando ping
    perror ("exec");
    _exit(127);
  }  

  // ================
  // fin proceso ping
  // ================
  
  else{
    if (flag == 0){

      // ========================
      // creacion proceso gnuplot
      // ========================

      if ((pid_02 = fork ()) < 0){
        printf ("error al crear proceso gnuplot\n");
        exit (1);
      }

      // ======================
      // inicio proceso gnuplot
      // ======================

      if (pid_02 == 0){
        sleep (3);  
        execl ("/usr/bin/gnuplot" , "gnuplot" , "set.gnu" , 0);  // ejecuta comando gnuplot
      }

      // ===================
      // fin proceso gnuplot 
      // ===================
   
    } 
  }    
  
  // ==============================
  // lectura desde entrada estandar
  // ==============================

  close (pipa[ESCRITURA]);                 // cierra puerta de escritura 
  dup2 (pipa[LECTURA] , ENT_EST);          // agrega entrada estandar a puerta de lectura
  read (ENT_EST , linea , 51);  
  
  while (1){

    read (ENT_EST , linea , 65);

    strtok (linea , "=");
    sec_str = strtok (NULL , " ");                         // obtencion string con secuencia de paquete

    strtok (NULL , "=");
    strtok (NULL , "=");
    time_str = strtok (NULL , " ");                        // obtencion string con tiempo de paquete

    sec_int = atoi (sec_str);                              // conversion de string a entero
    time_float = atof (time_str);                          // conversion de string a flotante

    loss_max = promedio (i , sec_int , buf_sec);           // calculo de tasa de perdida maxima

    if (flag == 0){                                        // ingresa a escribir en archivo datos para generar grafico
      if ((datos = fopen ("datos" , "a+")) == NULL){
        printf ("error al abrir archivo datos \n");
        exit (1);
      }
      fprintf (datos , "%4i\t%0.1f\t%0.1f\n" , sec_int , time_float , loss_max*100);
      fclose (datos);
    }

    else if (flag == 1){                                   // ingresa a escribir en archivo log para generar e-mail
       if ((log = fopen ("log" , "a+")) == NULL){
          printf ("error al abrir archivo log \n");
          exit (1);
       }
       fprintf (log , "# Paquete : %4i \t" , sec_int);
       fprintf (log , "Tiempo : %4.1f \t" , time_float);
       fprintf (log , "Tasa Perdida : %4.1f%\n" , loss_max*100);
       fclose (log); 
       
       if ((loss_max*100) >= lim)
         mail(user);
    }
    i++;
  }
  close (pipa[LECTURA]);        // cierre de entrada de lectura
  return 0;
}