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

#include "kbhit.h"
#include "gotoxy.h"

struct hsm_set_struct
{
/* unsigned char ip[100]; */
 unsigned char port[100];
 unsigned char delay[100];
 unsigned int  ammount;
 unsigned char date_time[100];
 unsigned short int flag_update;
 struct hsm_set_struct *next;
};
/* Comment for HSM_Settings

   int flag_update - Update or not anything in HSM_Settings [0-7]
   0 -- nothing
   1 -- PORT
   2 -- DELAY
   4 -- AMMOUNT+DATE_TIME
   
   3 -- PORT + DELAY
   5 -- PORT + AMMOUNT+DATE_TIME
   6 -- DELAY + AMMOUNT+DATE_TIME
   7 -- PORT + DELAY + AMMOUNT+DATE_TIME
   
   8 -- KILL ME, PLZ

*/




typedef struct hsm_set_struct HSM_Settings;

static HSM_Settings *hsm_settings_head = NULL;


HSM_Settings* init_settings( FILE* ); 
void* hsm_thread( void* );
void write_log( char* );
int get_date_time( unsigned char* );
void draw_table(void);
void* draw_result( void* );
void add_device( void );
int ultra_scanf ( unsigned char *, int, int, int, int );
void send_exit2thread(unsigned char*);
void write_settings( void );
int print_xy(char*, int, int);
void change_settings ( void );
void del_device ( void );

static pthread_mutex_t  log_mutex = PTHREAD_MUTEX_INITIALIZER; /* File-Log*/
static pthread_mutex_t  print_xy_mutex = PTHREAD_MUTEX_INITIALIZER; /* Dislay cursor and writing */
static pthread_mutex_t  flag_update_mutex = PTHREAD_MUTEX_INITIALIZER; /* Set flag_update in thread's table for monitoring */
static short int stop_working = 0; /* 0 - Working, 1 - Stop Working. For Draw_Result */

HSM_Settings* init_settings( FILE *in )
{
 HSM_Settings *hsm_settings_last = NULL;
 HSM_Settings *hsm_settings_cur = NULL;
 unsigned char c;
 unsigned int i, i2, ammount;
  
 printf("Loading...\n\n");
 for( c = fgetc(in); !feof(in); )
  {
   if ( c == '#' ) /* #comment-line */
    {
     for (; !feof(in) && c != '\n'; c = fgetc(in) );
	 continue;
    }
   if ( c == ' ' || c == '\n' || c == '\t' ) 
    {
	 c = fgetc(in); 
	 continue;
	}
	
   if ( c >= '0' && c <= '9' )
    {
	  
	 if ( hsm_settings_head == NULL ) /* first time of reading */
	  { 
	   hsm_settings_head = (HSM_Settings*) malloc(sizeof(HSM_Settings));
	   
	   if ( hsm_settings_head == NULL )
	    {
		 printf("Unable to allocate memory for settings\n");
		 return NULL;
		}

	   ammount = 1;
	   hsm_settings_head->next = NULL;
	   hsm_settings_cur = hsm_settings_head;
	  } 
	 else /* not first time of reading */
      {
	   if ( hsm_settings_head->next == NULL ) /* second time of reading */
	    {
		 hsm_settings_last = (HSM_Settings*) malloc( sizeof(HSM_Settings) );
		 if ( hsm_settings_last == NULL )
          {
		   printf("Unable to allocate memory for settings\n");
		   free (hsm_settings_head);
		   return NULL;
		  }
		  
		 ammount += 1; 
		 hsm_settings_head->next = hsm_settings_last;
         hsm_settings_last->next = NULL;
		 
		 hsm_settings_cur = hsm_settings_last;
		 
		 
		}
	   else /* third, etc... time of reading */
	    {
		 if ( ammount == 9 ) break; /* No more, than 9 devices */
		 hsm_settings_cur = (HSM_Settings*) malloc( sizeof(HSM_Settings) );
		 if ( hsm_settings_cur == NULL )
          {
		   printf("Unable to allocate memory for settings\n");
		   
		   for ( ; hsm_settings_head != NULL; )
		    {
			 hsm_settings_cur = hsm_settings_head->next;
			 free (hsm_settings_head);
			 hsm_settings_head = hsm_settings_cur;
			}
		   
		   return NULL;
		  }
		  
		 ammount += 1;	 
         hsm_settings_last->next = hsm_settings_cur;
		 hsm_settings_cur->next = NULL;
		 hsm_settings_last = hsm_settings_cur;
		 
		
		}
	   
      }
	  
	 /* Reading format <IP>:<PORT>:<DELAY> */
	 
	 
	/* <IP>: */
	/* for ( i = 0; !feof(in) && c != ':' && c != '\n'; c = fgetc(in), i++ )
	  {
	    if ( (c >= '0' && c <= '9') || c == '.' ) hsm_settings[hsm_index].ip[i] = c;
		else
		 {
		  printf("Incorrect symbol [%c] in IP-string. Byte: [%d]\n", c, ftell(in)-1);
		  free( hsm_settings );
		  return NULL;
		 }
	  }
	 hsm_settings[hsm_index].ip[i] = 0; */
	 
	 
	 
	 
	 /* <PORT>: */
	 for ( i = 0; !feof(in) && c != ':' && c != '\n'; c = fgetc(in), i++ )
	  {
	    if ( c >= '0' && c <= '9' ) hsm_settings_cur->port[i] = c;
		else
		 {
		  printf("Incorrect symbol [%c] in PORT-string. Byte: [%d]\n", c, ftell(in)-1);
		  for ( ; hsm_settings_head != NULL; )
		   {
			hsm_settings_cur = hsm_settings_head->next;
			free (hsm_settings_head);
			hsm_settings_head = hsm_settings_cur;
		   } 
		  return NULL;
		 
		 }
	  }
	 hsm_settings_cur->port[i] = 0; 
	 
	 
	 /* <DELAY>\n */
	 for ( c = fgetc(in), i = 0; !feof(in) && c != '\n' && c != ' '; c = fgetc(in), i++ )
	  {
	    if ( c >= '0' && c <= '9' ) hsm_settings_cur->delay[i] = c;
		else
		 {
		  printf("Incorrect symbol [%c] in DELAY-string. Byte: [%d]\n", c, ftell(in)-1 );
		  for ( ; hsm_settings_head != NULL; )
		   {
			hsm_settings_cur = hsm_settings_head->next;
			free (hsm_settings_head);
			hsm_settings_head = hsm_settings_cur;
		   }
		  return NULL;
		 }
	  }
	 hsm_settings_cur->delay[i] = 0;

	} /* end of IF ( c >= '0' && c <= '9' ) */
   else
    {
	 printf("Incorrect symbol [%c] in file. Byte: [%d]\n", c, ftell(in)-1 );
	 for ( ; hsm_settings_head != NULL; )
	  {
	   hsm_settings_cur = hsm_settings_head->next;
	   free (hsm_settings_head);
	   hsm_settings_head = hsm_settings_cur;
      }
	 return NULL;
	}
   
  }/* end of FOR() */
  
  
  /* Checking for correct data */
  
  for ( hsm_settings_cur = hsm_settings_head; hsm_settings_cur != NULL; hsm_settings_cur = hsm_settings_cur->next )
   {
     /* Checking for IP-string for something near ***.**.*.*** */
    /* for ( i = 0; hsm_settings[hsm_index].ip[i] != '.' && hsm_settings[hsm_index].ip[i] != 0; i++)
	  text[i] = hsm_settings[hsm_index].ip[i];
	 text[i] = 0; 
	 	 
	 if ( text[0] == 0 || text[0] == '0' || atoi( (const char*)text ) > 255 )
	  {
	   printf("Incorrect IP: [%s]\n", hsm_settings[hsm_index].ip);
	   free( hsm_settings );
	   return NULL;
	  }
	 i++;
	 
	 for ( i2 = 0; hsm_settings[hsm_index].ip[i] != '.' && hsm_settings[hsm_index].ip[i] != 0; i++, i2++)
	  text[i2]=hsm_settings[hsm_index].ip[i];
	 text[i2]=0; 
	 
	 if ( text[0] == 0 || (text[0] == '0' && text[1] != 0) || atoi( (const char*)text ) > 255 )
	  {
	   printf("Incorrect IP: [%s]\n", hsm_settings[hsm_index].ip);
	   free( hsm_settings );
	   return NULL;
	  }
	 i++;
	 
	 
	 for ( i2 = 0; hsm_settings[hsm_index].ip[i] != '.' && hsm_settings[hsm_index].ip[i] != 0; i++, i2++)
	  text[i2]=hsm_settings[hsm_index].ip[i];
	 text[i2]=0; 
	 
	 if ( text[0] == 0 || (text[0] == '0' && text[1] != 0) || atoi( (const char*)text ) > 255 )
	  {
	   printf("Incorrect IP: [%s]\n", hsm_settings[hsm_index].ip);
	   free( hsm_settings );
	   return NULL;
	  }
	 i++;
	 
     for ( i2 = 0; hsm_settings[hsm_index].ip[i] != 0; i++, i2++)
	  text[i2]=hsm_settings[hsm_index].ip[i];
	 text[i2]=0;
	 
	 for ( i2 = 0; text[i2] != 0; i2++ )
	  {
	    if ( text[i2] < '0' || text[i2] > '9')
	     {
		  printf("Incorrect IP: [%s]\n", hsm_settings[hsm_index].ip);
		  free( hsm_settings );
	      return NULL;
		 }
	  }
	 if ( text[0] == 0 || (text[0] == '0' && text[1] != 0) || atoi( (const char*)text ) > 255 )
	  {
	   printf("Incorrect IP: [%s]\n", hsm_settings[hsm_index].ip);
	   free( hsm_settings );
	   return NULL;
	  } */
	  
	  
	  
	  
	 /* Checking for PORT-string for something near **** */
	 
	if ( hsm_settings_cur->port[0] == '0' || atoi( (const char*)hsm_settings_cur->port ) > 65536 )
	 {
	  printf("Incorrect PORT: [%s]\n", hsm_settings_cur->port);
	  for ( ; hsm_settings_head != NULL; )
	   {
	    hsm_settings_cur = hsm_settings_head->next;
	    free (hsm_settings_head);
	    hsm_settings_head = hsm_settings_cur;
       }
	  return NULL;
	 }
	  
	  
	/* Checking for DELAY-string for something near **** */
	 
	if ( hsm_settings_cur->delay[0] == '0' && hsm_settings_cur->delay[1] != 0 )
	 {
	  printf("Incorrect DELAY: [%s]\n", hsm_settings_cur->delay);
	  for ( ; hsm_settings_head != NULL; )
	   {
	    hsm_settings_cur = hsm_settings_head->next;
	    free (hsm_settings_head);
	    hsm_settings_head = hsm_settings_cur;
       }
	  return NULL;
	 } 

    pthread_mutex_lock(&flag_update_mutex); 
    hsm_settings_cur->flag_update = 7; /* PORT + DELAY + AMMOUNT+DATE_TIME */
	pthread_mutex_unlock(&flag_update_mutex);
	
   } /* end of FOR (checking for correct data) */
   

 return hsm_settings_head;
}

int get_date_time( unsigned char *date_time )
{
 time_t t=time(NULL);
 struct tm *tm=localtime(&t);
 char temp[100]={0};
 
 sprintf((char*)date_time, "\0");
 
 if ( tm->tm_mday<10 ) sprintf( temp, "0%d_", tm->tm_mday );
 else sprintf( temp, "%d_", tm->tm_mday );
 strcat( (char*)date_time, temp );
 
 if ( tm->tm_mon+1<10 ) sprintf( temp, "0%d_", tm->tm_mon+1 );
 else sprintf( temp, "%d_", tm->tm_mon+1 );
 strcat( (char*)date_time, temp );
 
 sprintf( temp, "%d ", tm->tm_year+1900 );
 strcat( (char*)date_time, temp );
     
 if ( tm->tm_hour<10 ) sprintf( temp, "0%d:", tm->tm_hour );
 else sprintf( temp, "%d:", tm->tm_hour );
 strcat( (char*)date_time, temp );
     
     
 if ( tm->tm_min<10 ) sprintf( temp, "0%d:", tm->tm_min );
 else sprintf( temp, "%d:", tm->tm_min );
 strcat( (char*)date_time, temp );
     
     
 if ( tm->tm_sec<10 ) sprintf( temp, "0%d", tm->tm_sec );
 else sprintf( temp, "%d", tm->tm_sec );
 strcat( (char*)date_time, temp );
 
 

 return 0;
}

void *hsm_thread (void *arg)
{
 HSM_Settings *hsm_settings = (HSM_Settings*)arg;
 
 char date_time[100]={0};
 int sock, listener;
 struct sockaddr_in addr;
 char buf[1024];
 int bytes_read;
 char text[1024];
 int i;
 int delay = 0, udelay = 0;
 
 /* Flag_update, proverka flaga, mutex */
 
 hsm_settings->ammount = 0;
 get_date_time( hsm_settings->date_time );
 
 
 pthread_mutex_lock(&flag_update_mutex); 
 if ( hsm_settings->flag_update != 4 &&
      hsm_settings->flag_update != 5 &&
	  hsm_settings->flag_update != 6 &&
	  hsm_settings->flag_update != 7 &&
	  hsm_settings->flag_update != 8 )
   hsm_settings->flag_update += 4; /* AMMOUNT+DATE_TIME */
 pthread_mutex_unlock(&flag_update_mutex);
 
   
 sprintf(text, "PORT: %s DELAY: %s Started", hsm_settings->port, hsm_settings->delay);
 write_log(text); 
 
 listener = socket(AF_INET, SOCK_STREAM, 0);
 
 if (listener < 0)
  {
   sprintf(text, "Unable to make LISTENER-SOCKET. PORT: %s", hsm_settings->port);
   write_log(text);
   hsm_settings->flag_update = 8; /* KILL_ME */
   return NULL;
  }
  
 addr.sin_family = AF_INET;
 addr.sin_port = htons( atoi( (const char*)hsm_settings->port ) );
 addr.sin_addr.s_addr = htonl( INADDR_ANY );
  
 if ( bind(listener, (struct sockaddr *)&addr, sizeof(addr)) <0 )
  {
   sprintf(text, "Unable to BIND SOCKET. PORT: %d", atoi( (const char*)hsm_settings->port ));
   write_log(text);
   hsm_settings->flag_update = 8; /* KILL_ME */
   close(listener);
   return NULL;;
   
  }
   
 listen(listener, 1);
  
 
 for(;;) /* MAIN FOR */
  {
   
   sock = accept( listener, NULL, NULL );
   if ( sock < 0 )
    {
	 sprintf(text, "Unable to ACCEPT connection. PORT: %s", hsm_settings->port);
     write_log( text );
    }
   for(;;) 
    {
	 i = 0;
	 udelay = atoi( (const char*)hsm_settings->delay ) * 1000;
	 delay = 0;
	 
	 if ( udelay > 999999 )
	   for ( ; udelay > 999999; udelay -= 1000000 )
	     delay++;
		 
     bytes_read = recv(sock, buf, 1024, 0);
     
     if ( bytes_read <= 0 ) break; /* Client closed socket */
	 
	 
     hsm_settings->ammount++;
     get_date_time( hsm_settings->date_time );

	 pthread_mutex_lock(&flag_update_mutex); 
	 if ( hsm_settings->flag_update != 4 &&
	      hsm_settings->flag_update != 5 &&
		  hsm_settings->flag_update != 6 &&
		  hsm_settings->flag_update != 7 &&
		  hsm_settings->flag_update != 8 )
	  hsm_settings->flag_update += 4; /* AMMOUNT+DATE_TIME */
	 pthread_mutex_unlock(&flag_update_mutex);

     sprintf(text, "PORT: %s Incoming: [%s]", hsm_settings->port, buf );
     write_log(text); 
	 
     if (strcmp(buf, "/EXIT") == 0) 
      {
	   sprintf(text, "PORT: %s Received \"/EXIT\" signal. SOCKET CLOSED", hsm_settings->port);
	   write_log(text);
       break;
      } 
     
     sleep( delay );
     usleep( udelay );
	 
	 sprintf(text, "HSM OK");
	 strcat(buf, text);
	 
	 bytes_read += 6;
	 
     send (sock, buf, bytes_read, 0);
    
    }    

   close(sock);    
   
   if (strcmp(buf, "/EXIT") == 0)
    {
	 close(listener);
     break;
	} 
  }
 return NULL;
}

void write_log(char *text)
{
 FILE *log_file;
 unsigned char datetime[100];
 
 get_date_time( datetime );
 
 pthread_mutex_lock(&log_mutex); /* Semaphore for critical-area "Writing to Log-File" */
 
 log_file = fopen("hsm_emul.log", "at");
 if ( log_file != NULL )
  {
   fprintf(log_file, "%s ", datetime);
   fprintf(log_file, "%s\n", text);
   fflush(log_file);
   fclose(log_file);
  }
 
 pthread_mutex_unlock(&log_mutex);
  
}

void draw_table()
{
 int x = 2, y = 1;
 
 print_xy("       Monitoring of HSM Emulators (Racall)", x, y);
 print_xy("|------------------------------------------------|", x, y+2);
 print_xy("| PORT  | DELAY  |AMMOUNT|   DATE / TIME         |", x, y+3);
 print_xy("|------------------------------------------------|", x, y+4);
 print_xy("|       |        |       |                       |", x, y+5);
 print_xy("|------------------------------------------------|", x, y+6);
 print_xy("|       |        |       |                       |", x, y+7);
 print_xy("|------------------------------------------------|", x, y+8);
 print_xy("|       |        |       |                       |", x, y+9);
 print_xy("|------------------------------------------------|", x, y+10);
 print_xy("|       |        |       |                       |", x, y+11);
 print_xy("|------------------------------------------------|", x, y+12);
 print_xy("|       |        |       |                       |", x, y+13);
 print_xy("|------------------------------------------------|", x, y+14);
 print_xy("|       |        |       |                       |", x, y+15);
 print_xy("|------------------------------------------------|", x, y+16);
 print_xy("|       |        |       |                       |", x, y+17);
 print_xy("|------------------------------------------------|", x, y+18);
 print_xy("|       |        |       |                       |", x, y+19);
 print_xy("|------------------------------------------------|", x, y+20);
 print_xy("|       |        |       |                       |", x, y+21);
 print_xy("|------------------------------------------------|", x, y+22);
  

}


void* draw_result(void *arg)
{
 HSM_Settings *hsm_settings_cur;
 HSM_Settings *hsm_settings_cur2;
 HSM_Settings *hsm_settings_prev;
 char text[1024];
 
 int x = 2, y, y2, i, last_y, hsm_index;
 
 for (; stop_working == 0; ) /* stop_working == 1 will stop every thread */
  { 
   for ( y = 6, hsm_settings_cur = hsm_settings_head, hsm_settings_prev = NULL; 
                hsm_settings_cur != NULL; // No more, than 9 devices will be displayed
                hsm_settings_prev = hsm_settings_cur, hsm_settings_cur = hsm_settings_cur->next, y+=2 )
    {
	
     if ( hsm_settings_cur->flag_update != 0 )
	  {
	   pthread_mutex_lock(&flag_update_mutex);
	   
	   
	   if ( hsm_settings_cur->flag_update == 1 || /* PORT */
	        hsm_settings_cur->flag_update == 3 || /* PORT + DELAY */
			hsm_settings_cur->flag_update == 5 || /* PORT + AMMOUNT+DATE_TIME */
			hsm_settings_cur->flag_update == 7 )  /* PORT + DELAY + AMMOUNT+DATE_TIME */
        {
		 print_xy("     ", 4, y); 
		 print_xy( (char*)hsm_settings_cur->port, x+2, y);
		 hsm_settings_cur->flag_update -= 1;
		}
	   if ( hsm_settings_cur->flag_update == 2 || /* DELAY */
	        hsm_settings_cur->flag_update == 3 || /* PORT + DELAY */
			hsm_settings_cur->flag_update == 6 || /* DELAY + AMMOUNT+DATE_TIME */
			hsm_settings_cur->flag_update == 7 )  /* PORT + DELAY + AMMOUNT+DATE_TIME */
        {
		 print_xy("      ", 12, y);
		 print_xy( (char*)hsm_settings_cur->delay, x+10, y);
		 hsm_settings_cur->flag_update -= 2;
		}
	   if ( hsm_settings_cur->flag_update == 4 || /* AMMOUNT+DATE_TIME */
	        hsm_settings_cur->flag_update == 5 || /* PORT + AMMOUNT+DATE_TIME */
		    hsm_settings_cur->flag_update == 6 || /* DELAY + AMMOUNT+DATE_TIME */
		    hsm_settings_cur->flag_update == 7 )  /* PORT + DELAY + AMMOUNT+DATE_TIME */
        {
         print_xy("     ", 21, y);
		 sprintf(text, "%d", hsm_settings_cur->ammount); 
		 print_xy(text, x+19, y);
		 
		 print_xy("                   ", 30, y);
         print_xy( (char*)hsm_settings_cur->date_time, x+28, y);
		 hsm_settings_cur->flag_update -= 4;
		}
		
	   if ( hsm_settings_cur->flag_update == 8 ) /* KILL_ME */
        {
		 for ( hsm_index = 1, hsm_settings_cur2 = hsm_settings_head; hsm_settings_cur2->next != NULL; hsm_settings_cur2 = hsm_settings_cur2->next, hsm_index++ );
 
         last_y = ( hsm_index * 2 ) + 4; /* last y-coordinate in list */
		 
		 for ( ; last_y != y-2; last_y -= 2 ) 
		  {
		   print_xy("       ", 3, last_y);
           print_xy("        ", 11, last_y);
           print_xy("       ", 20, last_y);
           print_xy("                   ", 30, last_y);
		  } 
		 
		 for ( y2 = y, hsm_settings_cur2 = hsm_settings_cur->next; hsm_settings_cur2 != NULL; hsm_settings_cur2 = hsm_settings_cur2->next, y2 += 2 )
		  {
		   print_xy( (char*)hsm_settings_cur2->port, x+2, y2);
		   print_xy( (char*)hsm_settings_cur2->delay, x+10, y2);
		   sprintf(text, "%d", hsm_settings_cur2->ammount); 
		   print_xy(text, x+19, y2);
		   print_xy( (char*)hsm_settings_cur2->date_time, x+28, y2);
		  }
		 
		 sprintf( text, "PORT: %s SOCKET CLOSED", hsm_settings_cur->port );
		 write_log( text );
		 
		 /* Kill_me, pls */
		 if ( hsm_settings_cur == hsm_settings_head && hsm_settings_cur->next == NULL )
		  {
		   /* single */
		   hsm_settings_head = NULL;
		   free( hsm_settings_cur );
		   pthread_mutex_unlock(&flag_update_mutex);
		   continue;
		  }
		  
		 if ( hsm_settings_cur == hsm_settings_head && hsm_settings_cur->next != NULL )
		  {
		   /* first, not single */
		   hsm_settings_head = hsm_settings_cur->next;
		   free( hsm_settings_cur );
		   pthread_mutex_unlock(&flag_update_mutex);
		   continue;
		  }
		  
		 if ( hsm_settings_cur != hsm_settings_head && hsm_settings_cur->next == NULL )
		  {
		   /* last, not single */
		   hsm_settings_prev->next = NULL;
		   free ( hsm_settings_cur );
		   pthread_mutex_unlock(&flag_update_mutex);
		   continue;
		  }
		  
		 if ( hsm_settings_cur != hsm_settings_head && hsm_settings_cur->next != NULL )
          {
			/* between */
		    hsm_settings_prev->next = hsm_settings_cur->next;
			free ( hsm_settings_cur );
			pthread_mutex_unlock(&flag_update_mutex);
			continue;
          }
        }		
	   pthread_mutex_unlock(&flag_update_mutex);
	  }
    }
   print_xy("\n", 1, 1);
   usleep(100000);
   
  }
 
 return NULL;
}


void add_device( )
{
 HSM_Settings *hsm_settings_cur;
 HSM_Settings *hsm_settings_last;
 unsigned char port[100], delay[100];
 int i = 0, y = 6;
 char text[1024];
 
 pthread_attr_t attr;
 pthread_t info;
 
 if ( hsm_settings_head == NULL )
  i = 0;  
 else 
  for ( i = 1, hsm_settings_last = hsm_settings_head; hsm_settings_last->next != NULL; i++, hsm_settings_last = hsm_settings_last->next);
 
 if ( i == 9 )
  {
   write_log( "Unable to add more than 9 devices" );
   return; /* nizzya */
  } 
 
 for ( ; i > 0; i-- ) y = y + 2;
 
 print_xy("[", 3, y); print_xy("]", 9, y);
 
 if ( ultra_scanf(port, 5, 4, y, 1) == -1 )
  {
   print_xy(" ", 3, y); print_xy(" ", 9, y);
   return;
  }
 
 print_xy(" ", 3, y); print_xy(" ", 9, y);
 
 /* Checking for PORT-string for something near **** */
 if ( port[0] == '0' || atoi( (const char*)port ) > 65536 )
  {
   print_xy("     ", 4, y);
   sprintf(text, "ADD_DEVICE: Incorrect PORT: [%s]", port);
   write_log(text);
   return;
  }
 for ( hsm_settings_cur = hsm_settings_head; hsm_settings_cur != NULL; hsm_settings_cur = hsm_settings_cur->next)
  {
   if ( strcmp((const char*)port, (const char*)hsm_settings_cur->port) == 0 )
    {
	 print_xy("     ", 4, y);
     sprintf(text, "ADD_DEVICE: Incorrect PORT: [%s]", port);
     write_log(text);
     return;
	}
  
  }

 print_xy("[", 11, y); print_xy("]", 18, y);
 
 if ( ultra_scanf(delay, 6, 12, y, 1) == -1 )
  {
   print_xy("     ", 4, y);
   print_xy(" ", 11, y); print_xy(" ", 18, y);
   return;
  
  }
 
 print_xy(" ", 11, y); print_xy(" ", 18, y);
	  
 /* Checking for DELAY-string for something near **** */
 if ( delay[0] == '0' && delay[1] != 0 )
  {
   print_xy("     ", 4, y);
   print_xy("       ", 12, y);
   sprintf(text, "ADD_DEVICE: Incorrect DELAY: [%s]", delay);
   write_log(text);
   return;
  } 
 
 if ( hsm_settings_head == NULL )
  {
   hsm_settings_head = malloc( sizeof(HSM_Settings) );
   if ( hsm_settings_head == NULL )
    {
	 print_xy("     ", 4, y);
     print_xy("       ", 12, y);
	 write_log("Unable to allocate memory for creating HSM-device");
	 return;
    }

   	strcpy( (char*)hsm_settings_head->port, (const char*)port );
    strcpy( (char*)hsm_settings_head->delay, (const char*)delay );	 
	
	pthread_mutex_lock(&flag_update_mutex); 
	hsm_settings_head->flag_update = 3; /* PORT + DELAY */
	pthread_mutex_unlock(&flag_update_mutex); 
	
	hsm_settings_head->next = NULL;
	
	if ( pthread_create(&info, NULL, hsm_thread, (void*)hsm_settings_head) != 0 )
     {
      sprintf(text, "Unable to start HSM-device PORT: [%s] DELAY: [%s]", hsm_settings_cur->port, hsm_settings_cur->delay);
      write_log( text );
     }
	
	return;
  }
  
 hsm_settings_cur = malloc( sizeof(HSM_Settings) );
 if ( hsm_settings_cur == NULL )
  {
   print_xy("     ", 4, y);
   print_xy("       ", 12, y);
   sprintf(text, "Unable to allocate memory for creating HSM-device");
   write_log( text );
   return;
  }
  
 strcpy( (char*)hsm_settings_cur->port, (const char*)port );
 strcpy( (char*)hsm_settings_cur->delay, (const char*)delay );
 hsm_settings_cur->next = NULL;
 hsm_settings_last->next = hsm_settings_cur;
 
 pthread_mutex_lock(&flag_update_mutex); 
 hsm_settings_cur->flag_update = 3; /* PORT + DELAY */
 pthread_mutex_unlock(&flag_update_mutex); 
 
 /* pthread_attr_init(&attr); */
 
 if (pthread_create(&info, NULL, hsm_thread, (void*)hsm_settings_cur) != 0)
  {
   sprintf(text, "Unable to start HSM-device PORT: [%s] DELAY: [%s]", hsm_settings_cur->port, hsm_settings_cur->delay);
   write_log( text );
  }

}

int ultra_scanf (unsigned char *text, int len, int x, int y, int opt)
{
 /* int opt: 1 -- only digits; 2 - digits, [a-z], [A-Z], '_' , '.' , '-' , '(' , ')' */

 unsigned char c = 0;
 unsigned int i = 0;
 unsigned int xx = x;
  
 for ( i = 0; i < len; i++ ) print_xy(" ", i+x, y);
  
 i = 0;
 
 print_xy("_", x, y);
 
 for ( ;; )
  {
   c = readch();
   if ( c == 27 && kbhit() == 0 ) /* Esc */
    {
	 for ( i = 0; i < 100; i++, xx++ )
	  {
	   if ( i < len ) print_xy(" ", xx, y);
	   text[i] = 0;
	  }
	 return -1;
	}
   if ( c == 27 && kbhit() == 1 )
    {
     for (c = readch(); kbhit() == 1; c = readch() );	
	 continue;
	}
      
   if ( i < len && kbhit() == 0 &&
      ( ( opt == 1 &&   (c >= '0' && c <= '9') ) || 
        ( opt == 2 && (((c >= 'a' && c <= 'z') ||( c >= '0' && c <= '9') || 
		                (c >= 'A' && c <= 'Z') || c == '_' || c == '.' || c == '-' || c == '(' || c== ')' )))))
    {
	 print_xy( (char*)&c, x, y );
     text[i] = c;
	 i++;
	 x++;
	 if ( i < len) print_xy("_", x, y);
	 continue;
	}
   if ( c == 127 && i != 0 && kbhit() == 0 ) /* BackSpace */
    {
	 i--;
	 x--;
	 if ( i < len - 1 ) print_xy("  ", x, y);
	 else print_xy(" ", x, y);
	 print_xy("_", x, y);
	 continue;
	}
   if ( c == 10 && i != 0 && kbhit() == 0 ) /* Enter */
    {
	 if ( i < len ) print_xy(" ", x, y);
	 text[i] = 0;
	 return 0;
	
	}
  } 
}


void send_exit2thread(unsigned char *port)
{
 int sock;
 struct sockaddr_in addr;
 char text[1024];
 char message[]={"/EXIT"};
 
 sock = socket(AF_INET, SOCK_STREAM, 0);
 
 if (sock < 0)
  {
   sprintf(text, "Unable to create socket to send \"/EXIT\" to PORT: %s", port);
   write_log( text );
   return;  
  }
  
  
  addr.sin_family = AF_INET;
  addr.sin_port = htons ( atoi( (const char*)port ) );
  addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
  
  
  if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
   {
    sprintf(text, "Unable to send \"/EXIT\" to PORT: %s", port);
	write_log( text );
	return;
   
   }
   
  send(sock, message, sizeof(message), 0);

  close(sock); 

}

void write_settings( )
{
 FILE *f;
 unsigned char filename[100];
 char text[1024];
 
 if ( hsm_settings_head == NULL) return;
 
 print_xy("Enter filename: ", 60, 20);
 print_xy("[", 60, 21);
 print_xy("]", 78, 21);
 if ( ultra_scanf(filename, 17, 61, 21, 2) == -1 )
  {
   print_xy("                ", 60, 20);
   print_xy("                   ", 60, 21);
   return;
  }
 
 print_xy("                ", 60, 20);
 print_xy("                   ", 60, 21);
 
 f = fopen( (const char*)filename, "wt");
 
 if ( f == NULL )
  {
   sprintf(text, "Unable to write settings to file: %s", filename);
   write_log (text);
   return;
  }
 
 for( ; hsm_settings_head != NULL ; hsm_settings_head = hsm_settings_head->next )
  fprintf( f, "%s:%s\n", hsm_settings_head->port, hsm_settings_head->delay);
 
 fflush(f);
 fclose(f);
}


int print_xy( char *text, int x, int y )
{
 pthread_mutex_lock(&print_xy_mutex); 
 
 gotoxy(x, y);
 printf("%s\n", text);
 
 pthread_mutex_unlock(&print_xy_mutex);

 return 0;
}

void change_settings ( )
{
 HSM_Settings *hsm_settings_cur;
 int i, i2, x = 11, xoffset = 7, y = 6, last_y, hsm_index; 
 unsigned char ch;
 char text[1024];
 unsigned char delay[100];
 
 if ( hsm_settings_head == NULL ) return;
 
 
 for ( hsm_index = 1, hsm_settings_cur = hsm_settings_head; hsm_settings_cur->next != NULL; hsm_settings_cur = hsm_settings_cur->next, hsm_index++ );
 
 last_y = ( hsm_index * 2 ) + 4; /* last y-coordinate in list */
 
 
 print_xy("[", x, y);
 print_xy("]", x+xoffset, y);
 
 
 for ( ;; )
  {
   ch = readch();
   
   if ( ch == 27 && kbhit() == 1 )
    {
     ch=readch();
     if ( ch == 91 )
      {
	   ch=readch();
       if ( ch == 66 )
	    {
		 print_xy(" ", x, y);
		 print_xy(" ", x + xoffset, y);
		 y += 2;
		 if ( y == last_y + 2 ) y = 6;
	    }
		  
       if ( ch == 65 )
        {  
		 print_xy(" ", x, y);
		 print_xy(" ", x + xoffset, y);
		 y -= 2;
		 if ( y == 4 ) y = last_y;
        }
		  
       print_xy("[", x, y); print_xy("]", x + xoffset, y);
	  } 
    }
   if ( ch == 27 && kbhit() == 0 )
    {
	 print_xy(" ", x, y); print_xy(" ", x + xoffset, y);
	 
	 return;
	}
	
   if ( ch == 10 && kbhit() == 0 )
    {
	 if ( ultra_scanf(delay, 6, x+1, y, 1) == -1 )
      {
       print_xy(" ", 11, y); print_xy(" ", 18, y);
	   
	   i2 = (y - 4) / 2;
	   for ( i = 1, hsm_settings_cur = hsm_settings_head; i != i2; i++, hsm_settings_cur = hsm_settings_cur->next );
	   
	   pthread_mutex_lock( &flag_update_mutex ); 
	   if ( hsm_settings_cur->flag_update != 2 &&
	        hsm_settings_cur->flag_update != 3 &&
		    hsm_settings_cur->flag_update != 6 &&
		    hsm_settings_cur->flag_update != 7 &&
			hsm_settings_cur->flag_update != 8 )
	     hsm_settings_cur->flag_update += 2; /* DELAY */
	   pthread_mutex_unlock( &flag_update_mutex ); 
	   
	   print_xy("[", 11, y); print_xy("]", 18, y);
	   continue;  
      }
	  
	 if ( delay[0] == '0' && delay[1] != 0 )
      {
       print_xy("      ", 12, y);
       sprintf(text, "CHANGE_SETTINGS: Incorrect DELAY: [%s]", delay);
       write_log(text);
	   
	   i2 = (y - 4) / 2;
	   for ( i = 1, hsm_settings_cur = hsm_settings_head; i != i2; i++, hsm_settings_cur = hsm_settings_cur->next );
	   pthread_mutex_lock( &flag_update_mutex ); 
	   if ( hsm_settings_cur->flag_update != 2 &&
	        hsm_settings_cur->flag_update != 3 &&
		    hsm_settings_cur->flag_update != 6 &&
			hsm_settings_cur->flag_update != 7 &&
		    hsm_settings_cur->flag_update != 8 )
	     hsm_settings_cur->flag_update += 2; /* DELAY */
	   pthread_mutex_unlock( &flag_update_mutex ); 
	   
	   print_xy("[", 11, y); print_xy("]", 18, y);
	   continue; 
       /* return; */
      }  
	 i2 = (y - 4) / 2; /* current index+1 in list hsm_settings_cur*** */
	 
	 
	 for ( i = 1, hsm_settings_cur = hsm_settings_head; i != i2; i++, hsm_settings_cur = hsm_settings_cur->next );
	 strcpy( (char*)hsm_settings_cur->delay, (const char*)delay );
	 
	 pthread_mutex_lock(&flag_update_mutex); 
	 if ( hsm_settings_cur->flag_update != 2 &&
	      hsm_settings_cur->flag_update != 3 &&
		  hsm_settings_cur->flag_update != 6 &&
		  hsm_settings_cur->flag_update != 7 &&
		  hsm_settings_cur->flag_update != 8 )
	  hsm_settings_cur->flag_update += 2; /* DELAY */
	 pthread_mutex_unlock(&flag_update_mutex); 
	 
	 sprintf(text, "PORT: %s Changed Delay: %s", hsm_settings_cur->port, hsm_settings_cur->delay);
     write_log(text); 
	 
	 print_xy("[", 11, y); print_xy("]", 18, y);
	 continue;  
	}
  } /* END of FOR(;;) */
  
}


void del_device ()
{
 HSM_Settings *hsm_settings_cur;
 int i, i2, y = 6, last_y, hsm_index; 
 unsigned char ch;
 char text[1024];
 unsigned char delay[100];
 
 if ( hsm_settings_head == NULL ) return;
 
 print_xy("[", 3, y); print_xy("]", 9, y);
 
 print_xy("[", 11, y); print_xy("]", 18, y);
 
 print_xy("[", 20, y); print_xy("]", 26, y);
 
 print_xy("[", 29, y); print_xy("]", 49, y);
 
 for ( ;; )
  {
   ch = readch();
   for ( hsm_index = 1, hsm_settings_cur = hsm_settings_head; hsm_settings_cur->next != NULL; hsm_settings_cur = hsm_settings_cur->next, hsm_index++ );
 
   last_y = ( hsm_index * 2 ) + 4; /* last y-coordinate in list */
   
   if ( ch == 27 && kbhit() == 1 )
    {
     ch=readch();
     if ( ch == 91 )
      {
	   ch=readch();
       if ( ch == 66 )
	    {
		 print_xy(" ", 3, y); print_xy(" ", 9, y);
 
         print_xy(" ", 11, y); print_xy(" ", 18, y);
 
         print_xy(" ", 20, y); print_xy(" ", 26, y);

         print_xy(" ", 29, y); print_xy(" ", 49, y);
		 
		 y += 2;
		 if ( y == last_y + 2 ) y = 6;
	    }
		  
       if ( ch == 65 )
        {  
		 print_xy(" ", 3, y); print_xy(" ", 9, y);
 
         print_xy(" ", 11, y); print_xy(" ", 18, y);
 
         print_xy(" ", 20, y); print_xy(" ", 26, y);

         print_xy(" ", 29, y); print_xy(" ", 49, y);		
		 
		 y -= 2;
		 if ( y == 4 ) y = last_y;
        }
       print_xy("[", 3, y); print_xy("]", 9, y);
 
       print_xy("[", 11, y); print_xy("]", 18, y);
 
       print_xy("[", 20, y); print_xy("]", 26, y);
 
       print_xy("[", 29, y); print_xy("]", 49, y);	
		
	  } 
    }
   if ( ch == 27 && kbhit() == 0 )
    {
	 print_xy(" ", 3, y); print_xy(" ", 9, y);
 
     print_xy(" ", 11, y); print_xy(" ", 18, y);
 
     print_xy(" ", 20, y); print_xy(" ", 26, y);

     print_xy(" ", 29, y); print_xy(" ", 49, y);		
	 
	 return;
	}
	
   if ( ch == 10 && kbhit() == 0 )
    {
	 i2 = (y - 4) / 2;
	 for ( i = 1, hsm_settings_cur = hsm_settings_head; i != i2; i++, hsm_settings_cur = hsm_settings_cur->next );

	 hsm_settings_cur->flag_update = 8;
	 
	 print_xy(" ", 3, y); print_xy(" ", 9, y);
 
     print_xy(" ", 11, y); print_xy(" ", 18, y);
 
     print_xy(" ", 20, y); print_xy(" ", 26, y);

     print_xy(" ", 29, y); print_xy(" ", 49, y);		
	 
	 send_exit2thread( hsm_settings_cur->port );
	 
	 return;
	   
	}  
  }
}

int main (int argc, char *argv[])
{
 FILE *input_settings;
 HSM_Settings *hsm_settings_cur = NULL;
 /* HSM_Settings *hsm_settings_head = NULL; */
 unsigned char c;
 unsigned int i;
 char text[1024];
 int ammount_threads;
 
 int arg = 0, err;
 
 char ch='x';
 int x = 55, y = 5, xoffset = 16;
 
 pthread_attr_t attr;
 pthread_t info;
 
 /* pthread_mutexattr_t  am; */
 
 pthread_attr_init(&attr);
 
 init_keyboard();
 
 if ( argc > 2 )
  {
   printf("Incorrect amount of argumets:\n\n");
   for ( i = 1; i < argc; i++ )
    {
     printf("[ %s ]\n", argv[i]);
	}
   return -1;	
  } 

 
 if ( argc == 2 ) /* Get settings from file <argv[1]> */
  {
   input_settings = fopen(argv[1], "rt");
   if ( input_settings == NULL )
    {
	 printf("Unable to open file: [ %s ]\n", argv[1]);
	 return -1;
	} 
	
   /* Initializing HSM. <IP>:<PORT>:<DELAY> */
   hsm_settings_head = init_settings( input_settings );  /* From file <input_settings> to array <hsm_settings> */
    
   if ( hsm_settings_head == NULL ) 
	{
	 printf("Unable to load settings from [ %s ]\n", argv[1]);
	 fclose( input_settings );
	 return -1;
	} 
    
   fclose( input_settings );
  
   if ( hsm_settings_head != NULL )
    {
     for ( hsm_settings_cur = hsm_settings_head; hsm_settings_cur != NULL; hsm_settings_cur = hsm_settings_cur->next)
      {
       if (pthread_create(&info, NULL, hsm_thread, (void*)hsm_settings_cur) != 0)
        {
         sprintf(text, "Unable to start HSM-device PORT: [%s]DELAY: [%s]", hsm_settings_cur->port, hsm_settings_cur->delay);
	     write_log( text );
        }
      }
    }
  }

 
 /*pthread_mutexattr_init(&am);
 if( pthread_mutex_init(&log_mutex,&am) != 0 )
  { 
   printf("Unable to initialize MUTEX\n");
   free ( hsm_settings );
   return -1;
  }*/
 
 clrscr();
 draw_table();
 print_xy("==>", x, y);
 print_xy("<==", x+xoffset, y);
 
 
 if (pthread_create(&info, NULL, draw_result, NULL) != 0)
  {
   printf("Unable to start MONITORING thread with settings:\n");
  } 

 for (;;) /* Menu */
  {
   print_xy("ADD DEVICE", 60, 5);
   print_xy("DELETE DEVICE", 60, 7);
   print_xy("CHANGE SETTINGS", 60, 9);
   print_xy("WRITE SETTINGS", 60, 11);
   print_xy("EXIT", 60, 13);
   print_xy("\n", 1, 1);
   
   ch = readch();
   if (ch == 27 && kbhit() == 1)
    {
     ch=readch();
     if ( ch == 91 )
      {
	   ch=readch();
       if (ch == 66)
	    {
		 print_xy("   ", x, y);
		 print_xy("   ", x+xoffset, y);
		 y += 2;
		 if ( y == 15 ) y = 5;
	    }
		  
       if ( ch == 65 )
        {  
		 print_xy("   ", x, y);
		 print_xy("   ", x+xoffset, y);
		 y -= 2;
		 if ( y == 3 ) y = 13;
        }	
		  
       if ( y == 5 ) xoffset = 16;
	   if ( y == 7 ) xoffset = 19;
	   if ( y == 9 ) xoffset = 21;
	   if ( y == 11) xoffset = 20;
	   if ( y == 13) xoffset = 10; 	
		 
       print_xy("==>", x, y);
	   print_xy("<==", x+xoffset, y);
	  } 
    } 
	
   if ( ch == 10 && y == 5 ) add_device( );
   
   if ( ch == 10 && y == 7 ) del_device( );
   
   if ( ch == 10 && y == 9 ) change_settings( );
   
   if ( ch == 10 && y == 11 ) write_settings ( );
   
   if ( ch == 10 && y == 13 ) /* EXIT */
    {
	
	 if (hsm_settings_head != NULL)
      {	 
	   for ( hsm_settings_cur = hsm_settings_head; hsm_settings_cur != NULL; hsm_settings_cur = hsm_settings_cur->next)
        {
         send_exit2thread(hsm_settings_cur->port);
		} 
	   free ( hsm_settings_cur );
	  }	
	  
	  stop_working = 1;
	  close_keyboard(); 
      clrscr();
      print_xy("Exiting...\n", 1, 20);
	  sleep(1); /* to allow stop every thread */
	  return 0;
	}
  } /* END Menu */
}