#include "tcp-udp_sys.h"

#undef open
#undef close
#undef read
#undef write
#undef unlink

#include <unistd.h>

int Open(char *path, int aflags , int mode);

int Close(int fd);

int Read(int fd, char *buffer, int contador);

int Write(int fd, char *buffer, int contador);

int Unlink(char *path);

int desc_path(char *path, char *protocolo, char *sr_cl, char *serv, 
	      char *puerto, char *nombclien, char *port_clien);

char *cortar_path(char *path);


int Open(char *path, int aflags , int mode)
{       

  char *protocolo, *sr_cl, *serv, *puerto, *nombclien, *port_clien;
  char *path_aux;
  int sockfd, nfd;
  int j=0;
  int i=0;
  struct sockaddr_in serv_addr,cli_addr;
  char *cort_path;        
  struct hostent *host, *client;   
  char *ip_serv, *ip_client;
  int realfile=0;
  int fd_dup;
      
  path_aux = (char *)malloc(128 *sizeof(char));
  cort_path = (char *)malloc(128 *sizeof(char));
  serv = (char *)malloc(32 *sizeof(char));
  protocolo = (char *)malloc(32 *sizeof(char));
  sr_cl = (char *)malloc(32 *sizeof(char));
  puerto = (char *)malloc(32 *sizeof(char));
  nombclien = (char *)malloc(128 *sizeof(char));
  port_clien = (char *)malloc(32 *sizeof(char));
  ip_serv = (char *)malloc(128 *sizeof(char));
  ip_client = (char *)malloc(128 *sizeof(char));

  strcpy(path_aux,path);
  desc_path(path_aux, protocolo, sr_cl, serv, puerto, nombclien, port_clien);

  if ((strcmp(protocolo,"")==0) || (strcmp(sr_cl,"")==0) || 
      (strcmp(serv,"")==0) || (strcmp(puerto,"")==0))
    {
      return open(path,aflags,mode);
    }
  if (strcmp(protocolo,"")==0)
    realfile=1;
  else if (protocolo=="UDP")
    realfile=0;
  else if (protocolo=="TCP")
    realfile=0;
 
  if (strcmp(sr_cl,"")==0)
    realfile=1;
  else if (sr_cl=="servidor")
    realfile=0;
  else if (sr_cl=="cliente")
    realfile=1;
  
  if (realfile)
    return open(path,aflags,mode);

  host=gethostbyname(serv);	 		
  if (host != NULL)
    {
      ip_serv= inet_ntoa( *(struct in_addr *) (host->h_addr_list[0]));
    }
  else 
    {
      printf("nombre de maquina incorrecto\n");
      return -1;
    }
     
  if (strcmp(nombclien,""))  
    {       
      if (port_clien==NULL)
	return open(path,aflags,mode);

      strcpy(cort_path, cortar_path(path_aux));/*quitamos el ultimo elemento del path*/
      for(j=0;j<1024;j++)/*buscamos newnfd gracias a la comparacion del path*/
	{	
	if ((fichero[j].path)!=NULL)		
	  if (strcmp((fichero[j].path),(cort_path))==0)
	    break;   
	}
      if (j==1024)
	return open(path,aflags,mode);

      for(i=0;i<1024;i++)
      	{
	  if ((fichero[j].newnfd[i].dir_cli)!=NULL)
	    {
	      if ((strcmp((fichero[j].newnfd[i].dir_cli),(nombclien))==0) && 
		  ((fichero[j].newnfd[i].port)==atoi(port_clien)))
		break;
	    }
	}	
      if (i==1024)
	{
	  printf("error en open\n");
	  return -1;
	}
      nfd=i;
      fichero[j].newnfd[nfd].path = path_aux;
      if (aflags==100)
	fichero[j].newnfd[nfd].cerrado = 0;
      fd_dup=dup(nfd);
      duplicados[fd_dup]=nfd;
      fichero[j].newnfd[nfd].cont++;

      return (fd_dup); 
    }
  else
    {
      if (aflags!=100)
	{
	  for(j=0;j<1024;j++)/*buscamos el path en el vector de estado*/
	    {	
	      if ((fichero[j].path)!=NULL)		
		if (strcmp((fichero[j].path),path)==0)
		  break;   
	    }
	  if (j==1024)
	    return open(path,aflags,mode);
	  else
	    {
	      fd_dup=dup(j);
	      duplicados[fd_dup]=j;
	      fichero[j].cont++;

	      return fd_dup;
	    }
	}
      else
	{
	  if (strcmp(protocolo,"TCP")==0) 
	    {  
	      if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
		{
		  printf("error socket\n"); 
		  return -1;
		}
	      
	      fd_dup=dup(sockfd);
	      duplicados[fd_dup]=sockfd;
	      fichero[sockfd].cont = 2;

	      if (strcmp(sr_cl,"cliente")==0) 
		{
		  bzero((char *) &serv_addr, sizeof(serv_addr));  
		  serv_addr.sin_family = AF_INET;	 		 
		  serv_addr.sin_addr.s_addr = inet_addr(ip_serv);
		  serv_addr.sin_port = (atoi(puerto));
		  
		  fichero[sockfd].protocolo = TCP;
		  fichero[sockfd].dir_serv = ip_serv;
		  fichero[sockfd].sr_cl = cliente;
		  fichero[sockfd].port=atoi(puerto);
		  fichero[sockfd].path = path_aux;
  
		  if (connect(sockfd, (struct sockaddr *) &serv_addr,
			      sizeof(serv_addr)) < 0)		    
		    {
		      bzero((char *) &fichero[sockfd], sizeof(fichero[sockfd]));
		      printf("client: can not connect to server\n");
		      close(sockfd);
		      close(fd_dup);
		      bzero((char *) &duplicados[fd_dup], sizeof(duplicados[fd_dup]));
		      return -1;
		    }
		}
	      else if (strcmp(sr_cl,"servidor")==0)
		{		 
		  fichero[sockfd].protocolo = TCP;
		  fichero[sockfd].port = atoi(puerto);
		  fichero[sockfd].path = path_aux;
		  fichero[sockfd].dir_serv = ip_serv;////
		  
		  bzero((char *) &serv_addr, sizeof(serv_addr));  
		  serv_addr.sin_family = AF_INET;
		  serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
		  serv_addr.sin_port = (fichero[sockfd].port);
		  
		  fichero[sockfd].sr_cl = servidor;
		  
		  if (bind(sockfd, (struct sockaddr *) &serv_addr, 
			   sizeof(serv_addr)) < 0)
		    {
		      bzero((char *) &fichero[sockfd], sizeof(fichero[sockfd]));
		      printf("server: can not bind local address\n");
		      close(sockfd);
		      close(fd_dup);
		      bzero((char *) &duplicados[fd_dup], sizeof(duplicados[fd_dup]));
		      return -1;
		    }		  
		  listen(sockfd, 5);
		}
	      else
		return open(path,aflags,mode);
	    }
	  else if (strcmp(protocolo,"UDP")==0)
	    {              		
	      if (strcmp(sr_cl,"servidor")==0)
		{
		  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
		    {
		      printf("error socket\n");
		      return -1;
		    }
		  
		  fd_dup=dup(sockfd);
		  duplicados[fd_dup]=sockfd;
		  
		  fichero[sockfd].cont = 2;
		  fichero[sockfd].protocolo = UDP;		   
		  fichero[sockfd].port=atoi(puerto);
		  fichero[sockfd].path = path_aux;
		  fichero[sockfd].dir_serv = ip_serv;
		  
		  bzero((char *) &serv_addr, sizeof(serv_addr));  
		  serv_addr.sin_family = AF_INET;
		  serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
		  serv_addr.sin_port = (fichero[sockfd].port);
		  
		  if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) 
		    {
		      bzero((char *) &fichero[sockfd], sizeof(fichero[sockfd]));
		      printf("server: can not bind local address\n");
		      close(sockfd);
		      close(fd_dup);
		      bzero((char *) &duplicados[fd_dup], sizeof(duplicados[fd_dup]));
		      return -1;
		    }
		  
		  fichero[sockfd].sr_cl = servidor;
		}
	      else if (strcmp(sr_cl,"cliente")==0)
		{	      		 
		  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
		    {
		      printf("error socket\n");      		  
		      return -1;
		    }

		  fd_dup=dup(sockfd);
		  duplicados[fd_dup]=sockfd;

		  fichero[sockfd].protocolo = UDP;		   
		  fichero[sockfd].port=atoi(puerto);
		  fichero[sockfd].path = path_aux;		 
		  fichero[sockfd].cont = 2;
		  
		  bzero((char *) &serv_addr, sizeof(serv_addr));  
		  serv_addr.sin_family = AF_INET;
		  serv_addr.sin_addr.s_addr = inet_addr(ip_serv);
		  serv_addr.sin_port = (fichero[sockfd].port);	
		  
		  bzero((char *) &cli_addr, sizeof(cli_addr));  
		  cli_addr.sin_family = AF_INET;
		  cli_addr.sin_addr.s_addr = htonl(INADDR_ANY);
		  cli_addr.sin_port = htons(0);
		  
		  
		  if (bind(sockfd, (struct sockaddr *) &cli_addr, sizeof(cli_addr)) < 0) 
		    {
		      bzero((char *) &fichero[sockfd], sizeof(fichero[sockfd]));
		      printf("client: can not bind local address\n");		
		      close(sockfd);
		      close(fd_dup);
		      bzero((char *) &duplicados[fd_dup], sizeof(duplicados[fd_dup]));
		      return -1;
		    }
		  
		  fichero[sockfd].sr_cl = cliente;
		  fichero[sockfd].dir_serv = ip_serv;		
		}
	      else
		return open(path,aflags,mode);
	    }
	  else
	    return open(path,aflags,mode);
	}
      return (fd_dup);
    }
}



int Close(int fd)
{  
  int j=0;
  struct sockaddr peer;
  int peerlen;

  peerlen=sizeof(peer);
  if (getsockname(fd,&peer,&peerlen)==-1)
    {
      return close(fd);
    }

  if (fichero[fd].path==NULL)
    {
      for(j=0;j<1024;j++)
	{	      
	  if ((fichero[j].newnfd[fd].path)!=NULL)
	    {
	      break;
	    }
	}
      if (j==1024)/*el fichero es un duplicado*/
	{
	  if (fichero[duplicados[fd]].path==NULL)
	    {
	      for(j=0;j<1024;j++)
		{	      
		  if ((fichero[j].newnfd[duplicados[fd]].path)!=NULL)
		    {
		      break;
		    }
		}
	      fichero[j].newnfd[duplicados[fd]].cont--;
	      if (fichero[j].newnfd[duplicados[fd]].cont==0)
		{
		  bzero((char *) &fichero[j].newnfd[duplicados[fd]], 
			sizeof(fichero[j].newnfd[duplicados[fd]]));
		  close(duplicados[fd]);
		}
	    }
	  else
	    {
	      fichero[duplicados[fd]].cont--;
	      if (fichero[duplicados[fd]].cont==0)
		{
		  bzero((char *) &fichero[duplicados[fd]], 
			sizeof(fichero[duplicados[fd]]));
		  close(duplicados[fd]);
		}
	    }	      
	  
	  bzero((char *) &duplicados[fd], sizeof(duplicados[fd]));
	  close(fd);
	}
      else /*el fichero no es un duplicado*/
	{
	  fichero[j].newnfd[fd].cont--;
	  fichero[j].cont--;
	  if (fichero[j].cont==0)
	    {
	      bzero((char *) &fichero[j], sizeof(fichero[j]));
	      close(fd);
	      close(j);
	    }
	  else	  
	    {    
	      if (fichero[j].newnfd[fd].cont==0)
		{
		  bzero((char *) &fichero[j].newnfd[fd], sizeof(fichero[j].newnfd[fd]));
		  close(fd);
		}
	      else
		fichero[j].newnfd[fd].cerrado=1;
	    }
	}
    }  
  else /*el fichero no es un duplicado*/
    {
      fichero[fd].cont--;
      if (fichero[fd].cont==0)
	{
	  bzero((char *) &fichero[fd], sizeof(fichero[fd]));      
	  close(fd);
	}
      else
	{
	  fichero[fd].dir_serv = NULL;
	}
    }
  
  return 0;
}



int Read(int fd, char *buffer, int contador)
{
  int newsockfd,clilen,peerlen;
  struct sockaddr_in cli_addr;
  struct sockaddr_in peer;
  struct sockaddr new_peer;
  int new_peerlen;
  int numbytes;
  char var[1024];
  char *ip_client;
  char *puerto;
  char *dir_port;
  
  bzero((char *) &cli_addr, sizeof(cli_addr));
  ip_client = (char *)malloc(128 *sizeof(char));
  puerto = (char *)malloc(128 *sizeof(char));
  dir_port = (char *)malloc(128 *sizeof(char));
  bzero(buffer, sizeof(buffer));
  bzero((char *) &peer, sizeof(peer));

  new_peerlen=sizeof(new_peer);
  if (getsockname(fd,&new_peer,&new_peerlen)==-1)
    {
      numbytes=read(fd,buffer,contador);
      return numbytes;
    }

  if ((fichero[duplicados[fd]].path != NULL) && (fichero[duplicados[fd]].protocolo == TCP) && 
      (fichero[duplicados[fd]].sr_cl == servidor))
    
    {         
      newsockfd = accept(duplicados[fd],(struct sockaddr *)&cli_addr, &clilen);
      if (newsockfd < 0)
	{
	  printf("server accept error\n");
	  return -1;
	}
      strcpy(ip_client,inet_ntoa(cli_addr.sin_addr));
      strcpy(buffer,ip_client);
      strcat(buffer,":");
      sprintf(var,"%d",cli_addr.sin_port);
      strcat(buffer,var);
      fichero[duplicados[fd]].newnfd[newsockfd].dir_cli=ip_client;	
      fichero[duplicados[fd]].newnfd[newsockfd].port=(int)cli_addr.sin_port;
      fichero[duplicados[fd]].newnfd[newsockfd].cont=1;
      fichero[duplicados[fd]].cont++;

      return 0;
    }          
  else if (fichero[duplicados[fd]].protocolo == UDP)
    {            
      numbytes=recvfrom(duplicados[fd], buffer, contador, 0, (struct sockaddr *)&peer, &peerlen);
      
      strcpy(ip_client,inet_ntoa(peer.sin_addr));
      fichero[duplicados[fd]].dir_port_client = ip_client;
      fichero[duplicados[fd]].port = peer.sin_port;
      
      strcat(fichero[duplicados[fd]].dir_port_client,":");
      sprintf(puerto,"%d",peer.sin_port);
      strcat(fichero[duplicados[fd]].dir_port_client,puerto);      
      
      return numbytes;      
    }   
  else
    {
      numbytes = read(duplicados[fd], buffer, contador);

      return numbytes;	
    }  
}


int Write(int fd, char *buffer, int contador)
{
  
  struct sockaddr_in serv_addr, cli_addr;
  int nbytes;
  char *dir_cli;
  struct sockaddr peer;
  int peerlen;
  fd_set rfds;
  struct timeval tv;
  int valret;
  char c;

  peerlen=sizeof(peer);
  if (getsockname(fd,&peer,&peerlen)==-1)
    {
      nbytes=write(fd,buffer,contador);

      return nbytes;
    }

  dir_cli = (char *)malloc(128 *sizeof(char));

  if (fichero[duplicados[fd]].protocolo == UDP)
    {
      if (fichero[duplicados[fd]].sr_cl == servidor)
	{
          bzero((char *) &cli_addr, sizeof(cli_addr));
          cli_addr.sin_family = AF_INET;
	  dir_cli=strtok(fichero[duplicados[fd]].dir_port_client,":");
	  cli_addr.sin_addr.s_addr = inet_addr(dir_cli);
          cli_addr.sin_port = (fichero[duplicados[fd]].port);

          return (sendto(duplicados[fd], buffer, contador, 0, 
			 (struct sockaddr *)&cli_addr, sizeof(cli_addr)));
	}  
      else
	{	 
	  bzero((char *) &serv_addr, sizeof(serv_addr));
	  serv_addr.sin_family = AF_INET;
	  serv_addr.sin_addr.s_addr = inet_addr(fichero[duplicados[fd]].dir_serv);
	  serv_addr.sin_port = (fichero[duplicados[fd]].port);

	  return (sendto(duplicados[fd], buffer, contador, 0, 
			 (struct sockaddr *)&serv_addr, sizeof(serv_addr)));
	}
    }
  else
    {
      FD_ZERO(&rfds);
      FD_SET(fd, &rfds);
      
      tv.tv_sec = 0;
      tv.tv_usec = 0;
      
      valret = select(fd+1, &rfds, NULL, NULL, &tv);
      
      if (valret)
	{
	  bzero(&c, 1);
	  read(duplicados[fd],&c,1);
	  if (c=='\0')
	    {
	      printf("\nconexión rota\n");
	      return -1;
	    }
	}
      nbytes=write(duplicados[fd], buffer, contador);
      if (nbytes<0)
	printf("error al escribir en el buffer\n"); 

      return nbytes;
    }
}


int Unlink(char *path)
{
  int i=1024;
  int j=1024;
  
  for(j=0;j<1024;j++)
    {	
      if ((fichero[j].path)!=NULL)
	{
	  if (strcmp(fichero[j].path,path)==0)
	    break;   
	}
      for(i=0;i<1024;i++)
      	{
	  if ((fichero[j].newnfd[i].path)!=NULL)
	    {
	      if ((strcmp(fichero[j].newnfd[i].path,path)==0))
		break;
	    }
	}
      if (i!=1024)
	break;
    }
  if (j==1024)
    {
      return unlink(path);
    }
  else
    {      
      if (i!=1024)/*el path es largo*/
	{
	  return Close(i);
	}
      else /*el path es corto*/
	{
	  return Close(j);
	}
    }
}


int read_dir(char *path, struct stat_fich files[])
{
  int j=0;
  int i=0;
  int salir=0;
  int cont=0;
  char *path_aux;
  char *p;
  char *puerto;

  path_aux=(char*)malloc(sizeof(char)*128);  
  p=(char*)malloc(sizeof(char)*128);
  if (strcmp(path,"/")==0)
    {
      for (j=0;j<1024;j++)
	{	
	  if (fichero[j].path!=NULL)		
	    {
	      if (fichero[j].dir_serv!=NULL)
		{
		  files[j].file=(char*)malloc(sizeof(char)*128);
		  strcpy(files[j].file,fichero[j].path);	      
		}
	      while (i!=1024)
		{
		  if (fichero[j].newnfd[i].cont > 0)    
		    break;
		  i++;
		}
	      if (i!=1024)
		{
		  files[i].file=(char*)malloc(sizeof(char)*128);
		  strcpy(files[i].file,fichero[j].path);
		  strcat(files[i].file,"@connect");
		}
	      i=0;	
	      cont++;
	    }   
	}      
      return cont;
    }
  else     
    {     
      j=0;
      strcpy(path_aux,path);      
      p=strtok(path_aux, "@");
      if (p==NULL)
	return -1;

      while (j!=1024) /*buscamos el directorio "virtual"*/
	{
	  if (fichero[j].path!=NULL)
	    if (strcmp(fichero[j].path,p)==0)
	      break;
	  j++;
	}
      if (j==1024)
	return -1;
      
      for (i=0;i<1024;i++)
	{
	  if ((fichero[j].newnfd[i].path)!=NULL)
	    {
	      files[i].file=(char*)malloc(sizeof(char)*128);
	      strcpy(files[i].file,fichero[j].newnfd[i].dir_cli);
	      strcat(files[i].file,":");
	      puerto=(char*)malloc(sizeof(char)*128);
	      sprintf(puerto,"%d",fichero[j].newnfd[i].port);
	      strcat(files[i].file,puerto);	      
	      cont++;
	    }
	}
      return cont;      
    }
}



int desc_path(char *path, char *protocolo, char *sr_cl, char *serv, 
	      char *puerto, char *nombclien, char *port_clien)
{
  char *p, *s;
  char *maq_port, *maq_port_clien, *maq_port_serv;
  int i = 1;   
  size_t lon;
  int k=0;
    
  p=(char*)malloc(sizeof(char)*32);
  s=(char*)malloc(sizeof(char)*128);
  maq_port=(char*)malloc(sizeof(char)*32);
  maq_port_serv=(char*)malloc(sizeof(char)*32);
  maq_port_clien=(char*)malloc(sizeof(char)*32);

  strcpy(s, path);
  p = strtok(s, "/");
  strcpy(protocolo,p);
  while(p) 
    {
      p=strtok(NULL, "/");
      if (i==1)
	{
	  if (p==NULL)
	    break;
	  strcpy(sr_cl,p);
	}
      if (i==2)
	{
	  if (p==NULL)
	    break;
	  maq_port=p;
	}
      if (i==3)
	{
	  if (p!=NULL)
	    {	      	
	      k=1;
	      lon=strcspn(maq_port,"@");
	      strncat(maq_port_serv,maq_port,lon);
	      strcpy(maq_port_clien,p);
	      strcpy(nombclien, strtok(maq_port_clien, ":"));
	      strcpy(port_clien,strtok(NULL, ":"));
	    }
	  else
	    nombclien=p;
	}
      i++;	  
    }

  if (i<3)
    return 0;
  if (k==1)
    strcpy(serv, strtok(maq_port_serv, ":"));
  else
    strcpy(serv, strtok(maq_port, ":"));
  strcpy(puerto,strtok(NULL, ":"));
 
  return (0);
}

char *cortar_path(char *path)
{
  char *s;
  char *st, *path_aux, *st_aux;
  int i;
  int lon;

  st = (char *)malloc(128 *sizeof(char));
  st_aux = (char *)malloc(128 *sizeof(char));
  path_aux = (char *)malloc(128 *sizeof(char));

  strcpy(path_aux,path);
  s = strtok(path_aux, "/");
  strcat(st,"/");
  strcat(st,s);
  for (i=1;i<3;i++)
    {   
      s=strtok(NULL, "/");
      strcat(st,"/");
      strcat(st,s);
    }
  lon=strcspn(st,"@");
  strncat(st_aux,st,lon);

  return st_aux;         
}