/*	Component of the D-ITG 2.4 Platform
 *
 * 	
 *	copyright	: (C) 2004  	by Stefano Avallone, Alessio Botta, Donato Emma, 
 *					Salvatore Guadagno, Antonio Pescape'
 *					DIS Dipartimento di Informatica e Sistemistica				 
 *					(Computer Science Department)
 *					University of Naples "Federico II"	
 *	email:		: {stavallo, pescape}@unina.it, {abotta, demma, sguadagno}@napoli.consorzio-cini.it
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *      (at your option) any later version.
 */
 
 




#define SOL_IP IPPROTO_IP

#include "../common/ITG.h"

#ifdef LINUX_OS
#include <netdb.h>
#include "newran.h"		
#include <sys/wait.h>
#include <math.h>
#include <netinet/tcp.h>	
#include <netinet/ip.h>
#include <sys/timeb.h>
#include <sys/shm.h>
#include <pthread.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#endif

#ifdef WIN32
#include "newran/newran.h"	
#include <math.h>
#include <sys/timeb.h>
#include <time.h>
#include <signal.h>
#endif

#include "../common/thread.h"
#include "../common/timestamp.h"
#include "../common/serial.h"
#include "traffic.h"
#include "../common/pipes.h"
#include "ITGSend.h"

#ifdef LINUX_OS
const char DefaultLogFile[] = "/tmp/ITGSend.log";
const char DefaultRecvLogFile[] = "/tmp/ITGRecv.log";
#endif
#ifdef WIN32
char DefaultLogFile[] = "ITGSend.log";
char DefaultRecvLogFile[] = "ITGRecv.log";
#endif
const char DefaultDestIP[] = "127.0.0.1";


flowDescriptor flows[MAX_NUM_THREAD];		
signalChannel signalChannels[MAX_NUM_THREAD];	
pthread_t h_flowParser[MAX_NUM_THREAD];		
flowParserParams parserParams[MAX_NUM_THREAD];	
int multiFlows = 0;
struct addrinfo *logHost = 0;
struct sockaddr_in ManagerIP;
socklen_t ManagerIPslen = sizeof(ManagerIP);
int isFirst = 1;
int isFirstThread = 1;
int isFirstThreadRttm = 1;
int signalChanCount = 0;
char logFile[DIM_LOG_FILE];	
int logging = 0;		
int logremoto = 0;
int logSock;
int logSockSignaling;
int namelogReceiver = 0;
bool setPriority = false;
ofstream out;			
BYTE protoTxLog = DEFAULT_PROTOCOL_TX_LOG;
BYTE protoTx_ServerLogReceiver = DEFAULT_PROTOCOL_TX_LOG_OPZ;
struct addrinfo *serverLogReceiver = 0;

char logFileReceiver[DIM_LOG_FILE];
int logServer = 0;
int managerMode;
int managerSock;
#ifdef LINUX_OS
pthread_mutex_t mutex;
pthread_mutex_t mutexLog;
pthread_mutex_t mutexErrLog;
#endif
#ifdef WIN32
HANDLE mutex;
HANDLE mutexLog;
#endif
char nameProgram[]="ITGSend";


int modeManager(int argc, char *argv[])
{

	int flowCount = 0;

	managerMode = 1;	
	multiFlows = 1;
	struct addrinfo* localHost = 0;
	int size_r = 0, size_s = 0;
	char buffer[80];

	signal(SIGINT, Terminate);
	printf("Press Ctrl-C to terminate\n");

	argv++;
	argc--;
	parserMultiFlows(argv, argc);


	 getaddrinfo("0.0.0.0", NULL, NULL, &localHost);
	 managerSock = socket(localHost->ai_family, SOCK_DGRAM, 0);
	if (managerSock <0)
			printf("XXX error socket()!\n");


	
	SET_PORT(localHost, htons(DEFAULT_PORT_SENDER_MANAGER));
	
	if (bind(managerSock, localHost->ai_addr, localHost->ai_addrlen)) {
			printf("XXX error bind()!\n");
	}


	do {
		size_r = recvfrom(managerSock, buffer, sizeof(buffer), 0,(struct sockaddr *) &ManagerIP, &ManagerIPslen);
#ifdef DEBUG
		printf("Data receveid from SignalManager %d, \n",size_r);
#endif

		buffer[size_r] = '\n';
		buffer[size_r + 1] = '\0';
		
		strcpy(parserParams[flowCount].line, buffer);
		
		parserParams[flowCount].flowId = flowCount + 1;

		
		memmove(buffer + 2 * sizeof(int), buffer, size_r);
		((int *) buffer)[0] = MNG_FLOWSTART;	
		((int *) buffer)[1] = size_r;	

                size_s = sendto(managerSock, buffer, size_r + 2 * sizeof(int), 0,  (struct sockaddr *) &ManagerIP, ManagerIPslen);
#ifdef DEBUG
		printf("Notify ITGManager about the start of the generation %d, \n",size_s);
#endif

		CREATE_THREAD(&parserParams[flowCount], flowParser, NULL, h_flowParser[flowCount]);
		if (h_flowParser[flowCount] < 0) {
			cerr << "Cannot create a process to handle flow " << flowCount +
			    1 << endl;
		}
		flowCount++;
	} while (1);
 return 0;
}


int modeScript(int argc, char *argv[])
{
	char temp[MAX_NUM_THREAD];
	char line[MAX_NUM_THREAD];
	int flowCount = 0;

	multiFlows = 1;
	FILE *batch;

	if ((batch = fopen(argv[0], "r")) == NULL) {
		
		perror("ITGServer Main: ");
		memClean();
		cerr << "Cannot open '" << argv[0] << "' for reading" << endl;
		exit(1);
	}
	argv++;
	argc--;
	parserMultiFlows(argv, argc);
	
	if (fgets(line, sizeof(line) - 1, batch) == NULL) {
		cerr << "errore" << endl;
		memClean();
		exit(1);
	}

	
	strcpy(temp, line);
	do {
		
		strcpy(parserParams[flowCount].line, temp);
		
		parserParams[flowCount].flowId = flowCount + 1;
		CREATE_THREAD(&parserParams[flowCount], flowParser, NULL, h_flowParser[flowCount]);
		if (h_flowParser[flowCount] < 0) {
			perror("ITGSend Main: ");
			cerr << "Cannot create a process to handle flow "
			    << flowCount + 1 << endl;
		}
		flowCount++;
	} while (fgets(temp, sizeof(temp) - 1, batch));
	fclose(batch);


	
	joinThread(flowCount, h_flowParser);
 return 0;
}


int modeCommandLine(int argc, char *argv[])
{
#ifdef DEBUG
	printf("modeCommandLine() started\n");
#endif
	parserParams[0].flowId = 1;
	argvToString(argv, argc, parserParams[0].line);
	flowParser(&parserParams[0]);
	
	return (0);
}

int main(int argc, char *argv[])
{
	
	strcpy(programName, argv[0]);
	argv++;
	argc--;
 	if (!argc) {
		printf("\nMissing argument!!!\nTry ITGSend -h or --help for more information\n");
		exit(1);
	} else if (((argv[0][0] == '-') && (argv[0][1] == 'h')) || ((argv[0][0] == '-')
		&& (argv[0][1] == '-') && (argv[0][2] == 'h'))) {
		printHelp();
		exit(1);
	}

	
	MUTEX_THREAD_INIT(mutex);
	MUTEX_THREAD_INIT(mutexLog);
	strcpy(logFile, DefaultLogFile);
	strcpy(logFileReceiver, DefaultRecvLogFile);
#ifdef WIN32
	MUTEX_THREAD_INIT(mutex_numPipes);
	if (!InitializeWinsock(MAKEWORD(1, 1))) {
		printf("** ERROR ** WSAStartup() failed\n");
		exit(1);
	}
#endif

	for (int i = 0; i < MAX_NUM_THREAD; i++) {
		signalChannels[i].socket = -1;
		signalChannels[i].flows = 0;
		signalChannels[i].errorLog = false;

	}

	
	if ((argc > 0) && (argv[0][0] == '-') && (argv[0][1] == 'Q'))
		modeManager(argc, argv);
	else if ((argc > 0) && (argv[0][0] != '-') && (findL7Proto(argv[0]) == LX_ERROR_BYTE)) {
		modeScript(argc, argv);
	} else {
		modeCommandLine(argc, argv);
	}

	
	Terminate(0);

} 

void parserMultiFlows(char *argv[], int argc)
{
	strcpy(logFile, DefaultLogFile);
	getaddrinfo(DefaultDestIP, NULL, NULL, &logHost);
	SET_PORT(logHost, htons(DEFAULT_LOG_PORT));
	protoTxLog = DEFAULT_PROTOCOL_TX_LOG;

	getaddrinfo(DefaultDestIP, NULL, NULL, &serverLogReceiver);
	SET_PORT(serverLogReceiver, htons(DEFAULT_LOG_PORT));
	protoTx_ServerLogReceiver = DEFAULT_PROTOCOL_TX_LOG_OPZ;

	while (argc > 0) {
		if (argv[0][0] == '-') {
			switch (argv[0][1]) {
			case 'h':
				printHelp();
				Terminate(0);
				break;
			case 'l':
                logging = 1;
				if ((argc < 2) || (argv[1][0] == '-') || !findL7Proto(argv[1])) {
					strcpy(logFile, DefaultLogFile);
					argc -= 1;
					argv += 1;
				} else {
					strcpy(logFile, argv[1]);
					argc -= 2;
					argv += 2;
				}
				break;				
			case 'L':
				logging = 1;
				logremoto = 1;
				
				if ((argc < 2) || (argv[1][0] == '-') || 
                            (findL7Proto(argv[1]) != LX_ERROR_BYTE)){	
				    argc -= 1;
					argv += 1;
				} else {    
                            
                            if (findL4Proto(argv[1]) == LX_ERROR_BYTE){
                   				if (logHost)
                                   freeaddrinfo(logHost);
                                 
                                if (getaddrinfo(argv[1], NULL, NULL, &logHost))
                                  ReportErrorAndExit("General parser",
            					    " Invalid log-server address or protocol", programName, 0);
                       		    argc -= 1;
                     		    argv += 1;				            
               		        } else {  
                                
           						protoTxLog = findL4Proto(argv[1]);
            					argc -= 1;
		       				    argv += 1;
                            }  
                            if ((argc >= 2) && (argv[1][0] != '-') && (findL7Proto(argv[1]) == LX_ERROR_BYTE)) {
                                   if (findL4Proto(argv[1]) == LX_ERROR_BYTE){
                        				if (logHost)
                                       freeaddrinfo(logHost);
                                     
                                     if (getaddrinfo(argv[1], NULL, NULL, &logHost))
                                       ReportErrorAndExit("General parser",
            					       " Invalid log-server address", programName, 0);
                       		         argc -= 2;
                     		         argv += 2;				            
               		               } else {  
                                        
                    			     	protoTxLog = findL4Proto(argv[1]);
            					        argc -= 2;
	       				                argv += 2;
                                    }  
                             } 
                             else {
                       		    argc -= 1;
                     		    argv += 1;                                                       
               		         }  
                 } 
				break;
			case 'X':
				logServer = 1;
				
				if ((argc < 2) || (argv[1][0] == '-') || 
                            (findL7Proto(argv[1]) != LX_ERROR_BYTE)){	
				    argc -= 1;
					argv += 1;
				} else {    
                            
                            if (findL4Proto(argv[1]) == LX_ERROR_BYTE){
                   				if (serverLogReceiver)
                   				freeaddrinfo(serverLogReceiver);
                                 
                                if (getaddrinfo(argv[1], NULL, NULL, &serverLogReceiver))
                                  ReportErrorAndExit("General parser",
            					    " Invalid log-server address or protocol", programName, 0);
                       		    argc -= 1;
                     		    argv += 1;				            
               		        } else {  
                                
           						protoTx_ServerLogReceiver = findL4Proto(argv[1]);
            					argc -= 1;
		       				    argv += 1;
                            }  
                            if ((argc >= 2) && (argv[1][0] != '-') && (findL7Proto(argv[1]) == LX_ERROR_BYTE)) {
                                   if (findL4Proto(argv[1]) == LX_ERROR_BYTE){
                       				if (serverLogReceiver)
                       					freeaddrinfo(serverLogReceiver);
                                     
                                     if (getaddrinfo(argv[1], NULL, NULL, &serverLogReceiver))
                                       ReportErrorAndExit("General parser",
            					       " Invalid log-server address", programName, 0);
                       		         argc -= 2;
                     		         argv += 2;				            
               		               } else {  
                                        
                    			     	protoTx_ServerLogReceiver = findL4Proto(argv[1]);
            					        argc -= 2;
	       				                argv += 2;
                                    }  
                             } 
                             else {
                       		    argc -= 1;
                     		    argv += 1;				            
               		         }  
                 } 
				break;
			case 'x':
	            namelogReceiver = 1;
	            if ((argc < 2) || (argv[1][0] == '-') || !findL7Proto(argv[1])){
					argc -= 1;
					argv += 1;
				} else {
			     	strcpy(logFileReceiver, argv[1]);
					argc -= 2;
					argv += 2;
				}
				break;
			} 
		} 
	} 
} 


void *flowParser(void *param)
{
	int argc;
	char *argv[200];
	char *token;
	flowParserParams *para = (flowParserParams *)param;
#ifdef WIN32
	struct _timeb tstruct;
#endif
	char *ManagerMsg = NULL;
	double seed = 0.0;
#ifdef LINUX_OS
	timeval timeout;