//irc-logger.c : Bot de log IRC

#include <stdio.h> //Nécessaire au FILE

#include <netdb.h> //Bloc Fonctions Sockets
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
   #include <sys/socket.h>
#include <sys/ioctl.h>
#define h_addr h_addr_list[0]

typedef enum { false, true } bool; //Definition du type booléen

int vrecv(int);  //Déclaration des prototypes des fonctions utilisées
bool debloq_sock(int);
bool cnect(int,char *,int);
int recu(int,char *);
void erreur(void);

int main() {

	int sock = socket(AF_INET, SOCK_STREAM,0); //Identifiant de la connexion
	int bytesRecv; //Nombre de bytes reçues pendant un envoi du serveur distant

	char *messages = malloc(500),*bufferRecv = malloc(1024); //Buffers d'envoi et de réception

	FILE *log; //Identifiant du fichier
	
	char *serveur = malloc(30); //Nom du serveur
	int port; //Port
	
	char *pseudo_bot = malloc(30); //Pseudo du bot
	
	char *fichier_log = malloc(15);	//Nom du fichier de logs
	strcpy(fichier_log,"/tmp/irc_logs");	
	
	printf("Veuillez entrer l'adresse du serveur :\t"); //Demande d'informations à l'utilisateur
	scanf("%s",serveur);	
	printf("Veuillez entrer le port du serveur :\t");
	scanf("%d",&port);
	printf("\nVeuillez entrer le pseudo du bot :\t");
	scanf("%s",pseudo_bot);	
	
	printf("\nConnexion à %s:%d... ",serveur,port);	
	
	if (cnect(sock,serveur,port) > 0) { //Si la connexion a réussi...
	
			printf("Ouverture du fichier %s... ",fichier_log,serveur,pseudo_bot);	//Ouverture du fichier
			if ((log = fopen(fichier_log,"at")) == NULL) erreur();	
			printf("Ok\n\n");	
			
			strcpy(messages,"NICK "); //Ecriture et envoi du message d'authentification au serveur
			strcat(messages,pseudo_bot);
			strcat(messages,"\r\nUSER ");
			strcat(messages,pseudo_bot);
			strcat(messages," . . :");
			strcat(messages,pseudo_bot);
			strcat(messages,"\r\n");			
   		printf("Envoi : %s\n",messages);   
			send(sock,messages,strlen(messages),0); 
			
			while (1) //Reception de tous les messages jusqu'à déconnexion (Ping Timeout)
				switch(recu(sock,bufferRecv)) { //A-t-on reçu quelque chose ?
					case -2: //La connexion n'est pas active
					case -1: break; //Non
					case 0:	printf("Fermeture de la connexion\n"); exit(0); break; //La connexion vient de se terminer
				   default: //Oui, on l'écrit (+ traitement des données)
				   	fprintf(log,"%s\n",bufferRecv);
				}	
					
	}
	else erreur();
	
	free(bufferRecv); //On libère toute la mémoire qu'on a pu réserver
	free(pseudo_bot);	
	free(messages);	
	free(serveur);
	free(fichier_log);	
	
	close(sock);	//On ferme la connexion
	
	fclose(log); //On ferme le fichier
	
	return 0;
}

bool cnect(int sock,char *hote,int port) { //Fonction de connexion à un serveur et un port donné
	if (sock > 0) {
		struct sockaddr_in clientService;
      clientService.sin_family = AF_INET;
      struct hostent *HostInfo;
      if (HostInfo = gethostbyname(hote)) { //Résoud le nom d'hôte
      	struct in_addr **a;   
         a=(struct in_addr **)HostInfo->h_addr_list;
         if (*a) {           
         	clientService.sin_addr.s_addr = inet_addr(inet_ntoa(**a)); 
         	clientService.sin_port = htons( port );
         }
         else { close(sock); printf("Echec de résolution\n"); }
      }
      else { close(sock); printf("Echec de résolution\n"); }
      if ( connect( sock,(struct sockaddr*) &clientService, sizeof(clientService) ) == -1) { //Connexion
			close(sock);      	
      	return false;
      }
		else 	if (debloq_sock(sock)) return true;	
				else {
					printf("Erreur dans le débloquage du socket\n");
					return false;
				}
	}
	else printf("Erreur d'initialisation du socket\n");
	close(sock);
	return false;
}

int recu(int sock,char *bufferRecv) { //A-t-on reçu qqch sur cette socket non-bloquante ?

   int bytesRecv=-2;
  
 	if(vrecv(sock) > 0) {
 
 		bytesRecv=-1;
      
   	if((bytesRecv = recv(sock,bufferRecv,1024,0)) > 0)
   		bufferRecv[bytesRecv] = 0; 
	   
   	return bytesRecv;
 	} 
}

int vrecv(int sock) { //Vérifie que l'ensemble des données du socket est encore actif
          fd_set ensemble;
          FD_ZERO(&ensemble);
          FD_SET(sock,&ensemble);
          return FD_ISSET(sock,&ensemble);
}

bool debloq_sock(int sock) { //Debloquage d'un socket
          u_long argp=1;
          printf("Ok\nCréation d'un socket non-bloquant... ");
          ioctl(sock, FIONBIO, &argp);
          if (!argp) {
             printf("Echec\nSocket non-bloquant, deuxi%cme tentative\n",132);
             ioctl(sock, FIONBIO, &argp);
          }
          if (!argp) { printf("Echec\n"); return false; }
          printf("Ok\n"); return true;
} 

void erreur() {

	printf("Echec\nFermeture du programme\n");
	exit(1);
}