/*
	Copyright (c) 1994,1995 Laishev Ruslan R. All Right reserved !!!
*/

#include	<stdio.h>
#include	<stdlib.h>
#include	<starlet.h>
#include	<lib$routines.h>
#include	<libdef.h>
#include	<cmbdef.h>
#include	<descrip.h>
#include	<ssdef.h>
#include	<iodef.h>
#include	<lnmdef.h>
#include	<signal.h>
#include	<dvidef.h>
#include	<devdef.h>
#include	<string.h>
#include	<time.h>
#include  	<errno.h>
#include  	<types.h>
#include	<unixio.h>
#include	<file.h>
#include	<signal.h>

#include	<socket.h>
#include	<in.h>
#include	<netdb.h>
#include	<inet.h>
#include 	<ucx$inetdef.h>	/* INET symbol definitions */
#include	"zcrypt.h"


#define	 SESS_TYPE 	 	char	sess_type		[3]
#define	 SESS_MODE		char	sess_mode		[2]
#define	 SESS_NUMBER		char	sess_number		[4]
#define	 INPUT_SEQ_NUMBER	char	input_seq_number	[6]
#define	 OUTPUT_SEQ_NUMBER	char	output_seq_number	[6]
#define	 FS1			1
#define	 FS5			3

char	 PAI_OS  [] = 	"#PAXXXXXXXXXXCOPNFINOU";
char	 PAI_OS_R[] =	"#PAXXXXXXXXXXCOPN";
struct	 PAI_OS_R_	{
		SESS_TYPE;
		SESS_MODE;
		SESS_NUMBER;
		INPUT_SEQ_NUMBER;
		OUTPUT_SEQ_NUMBER;
			} PAI_OS_R_;

char	 PAI_CS [] =	"#STXXXXXXXXXXCCLS";

struct	 PAI_PKT	{
		char	sig	[3];
		SESS_NUMBER;
		OUTPUT_SEQ_NUMBER;
		char	type	[4];
			} *PAI_PKT_P;

        int     sock_1;               		/* socket */
static  char  	message[16];
static 	struct  sockaddr_in sock2_name;    	/* Address struct for socket2.*/
        struct  hostent          hostentstruct;  /* Storage for hostent data.  */
        struct  hostent         *hostentptr;    /* Pointer to hostent data.   */
        static  char             hostname[256];  /* Name of local host.        */
char	Host [1024];
int	Port;

int		linp;


TZCryptError	 s;

const	char	Password []  = "yues8a";
const	char	FingerPrint[]= "IO";

int	MBX_b_sz;


/*
---------------------------------------------------------------------
*/
void	log_message ( const char *msg )
{
FILE		*logfile;
unsigned long 	 current_time;
char 		*current_time_str;
char		*log_file_name;
int		 time_len;

	if ( ! (log_file_name = getenv ("PAI_IP_LOG")) )
		return;
/*
      		log_file_name = "pai_ip.log";
*/

  	if ( ! (logfile = fopen ( log_file_name, "a+" )) )
		{
  		if ( ! (logfile = fopen ( log_file_name, "w" )) )
			{
			perror ("Open Log file");
			sys$exit (0);
			}
		}

	time ( &current_time );
	current_time_str = ctime ( &current_time );
	time_len = strlen ( current_time_str );

	fprintf (logfile, "%.*s, %s\n", time_len - 1, current_time_str, msg);
	fclose (logfile);
}
void	log_error ( const char *prefix, int vms_status )
{
   char   msg[1024];

	sprintf (msg, "%s,Error code=:%d",prefix,vms_status );
	log_message ( msg );
	if ( vms_status )
		{
		sprintf (msg, "Error text=:%s", strerror ( EVMSERR, vms_status ) );
		log_message ( msg );
		}
}
/*-----------------------------------------------------------*/
void	PAI_sock_shut	(int	socket)
{
	if ( 0 > shutdown(socket,2) )	
		log_error ("shutdown",errno);
 	if ( 0 > close (socket) )	
		log_error ("close",errno);
}
/*-----------------------------------------------------------*/
int	PAI_sock_init	(const char *Host,int Port)
{
        if ( 0 > (sock_1 = socket (AF_INET, SOCK_STREAM, 0)) )
		{ 
                log_error( "socket",errno);
		exit(0);
		}
        if ((hostentptr = gethostbyname (Host)) == NULL) 
		{
                log_error( "gethostbyname",errno);
		PAI_sock_shut(sock_1);
		exit (0);
		}
		
 	hostentstruct = *hostentptr;

        sock2_name.sin_family = hostentstruct.h_addrtype;
	sock2_name.sin_port = htons(Port);
        sock2_name.sin_addr = * ((struct in_addr *) hostentstruct.h_addr);

	if (0 > connect(sock_1,(struct sockaddr *) &sock2_name,
			sizeof (sock2_name)) )
 		{
		log_error("connect",errno);
		PAI_sock_shut(sock_1);
		return -1;
		}
	return	0;
}
/*-----------------------------------------------------------*/
int	PAI_Write	(char *ss,int l)
{
char	buff0 [ 512 ];
int	wait_f;

	sprintf(buff0,"Encrypt message,size =%d",l);
	log_message(buff0);

	if ( ceOk != (s = Encrypt (ss,l,&l,MBX_b_sz,FingerPrint,Password)) )
		{
		log_error(CryptError(s),0);
		return	-1;
		}

	wait_f = 0;

	while (1)            
		{

		if (wait_f)	
			{
			sleep(30);
                        wait_f = 0;
			}

		log_message("Send messages to remote node's");

		if (!PAI_sock_init (Host,Port))
   			{
 			if ( 0 > send(sock_1,ss,l, 0) )
				{
				log_error ("send",errno);
				PAI_sock_shut(sock_1);
       	                        wait_f = 1;
				continue;	
				}

			buff0 [0 ] = 0;

			if ( 0 > (linp = recv(sock_1, buff0 ,sizeof (buff0), 0)) )
		       		{
				log_error ("recv",errno);
				PAI_sock_shut(sock_1);
       	                        wait_f = 1;
				continue;
				}

			PAI_sock_shut(sock_1);

			if ( ceOk != (s = Decrypt (buff0,linp,&linp,FingerPrint,Password)) )
				{
				log_error(CryptError(s),0);
       	                        wait_f = 1;
				continue;
				}

			if (!strcmp(buff0,"OkMsg") )
				return 0;

   			}
		else	wait_f = 1;             
		}
}
/*-----------------------------------------------------------*/
int	PAI_Main	(int MSG_BUF_S)
{
char	*MSG_BUF,
	*MSG_BUF_P;
short	 MSG_BUF_L;

	$DESCRIPTOR(MBX_dsc_inp,"MLA1$MFSERV");
	$DESCRIPTOR(MBX_dsc_out,"MFSERV$MLA1");

int	 MBX_hnd_inp,
	 MBX_hnd_out;

int	 status;

struct	 io_status_block {
	 short	int	cnd,
			cnt;
		int	dev;
			} iosb;
		
char	buff0 [512];

/*	Create permanent mailbox's for input & output message's
*/
	log_message("Opening MLA1$MFSERV & MFSERV1 mailboxe's");
	
	if (SS$_NORMAL != (status = sys$crembx(1,
				&MBX_hnd_inp,0,0,0,0,&MBX_dsc_inp,
				0)) )
		{
		log_error("sys$crembx-inp",status);
		sys$exit (status);
		}

	if (SS$_NORMAL != (status = sys$crembx(1,
				&MBX_hnd_out,0,0,0,0,&MBX_dsc_out,
				0)) )
		{
		log_error("sys$crembx-out",status);
		sys$exit (status);
                }
		
/*	Marked for death - starring :	Steven Sigal		
*/
	sys$delmbx(MBX_hnd_inp);
	sys$delmbx(MBX_hnd_out);

/*	Allocate area of memory for I/O buffer
*/
	if (NULL == (MSG_BUF = (char *)malloc (MSG_BUF_S)) )
		{
		log_error("Allocation I/O buffer",errno);
		exit (0);
		}

/*	Opening ST400/PAI Session	for output message's
	1. Send PAI_OPEN_SESSION
*/
	log_message("Send Open_ST400/PAI_Session for output message's");

	status = SS$_NOREADER;	
	while ( status != SS$_NORMAL )
		{
		status = sys$qiow (	0,
				MBX_hnd_inp,
				IO$_WRITEVBLK|IO$M_READERCHECK|IO$M_NORSWAIT,
				&iosb,
				0,0,
				PAI_OS,		
				sizeof(PAI_OS),
				0,0,0,0);

		if ( iosb.cnd == SS$_NOREADER )
			{
			log_error("sys$qiow-mbx-inp",SS$_NOREADER);
			sys$exit ( SS$_NOREADER );
			}
		}

/*
	2. Reading PAI_OPEN_SESSION_REPLY & validate it
*/
	log_message("Waiting reply Open_ST400/PAI_Session for output message's");

	status = SS$_NOWRITER;
	while (status != SS$_NORMAL )
		{
		status = sys$qiow (	0,
				MBX_hnd_inp,
				IO$_READVBLK|IO$M_WRITERCHECK,
				&iosb,
				0,0,
				MSG_BUF,			
				MSG_BUF_S,
				0,0,0,0);

		if ( iosb.cnd == SS$_NOWRITER )
			{
			log_error("sys$qiow-mbx-inp",SS$_NOWRITER);
			sys$exit ( SS$_NOWRITER );
			}
		if ( !strncmp (MSG_BUF,PAI_OS_R,sizeof(PAI_OS_R)-1) )
			break;	
		}

	memcpy((void *)	&PAI_OS_R_,
			 MSG_BUF + sizeof(PAI_OS_R)-1,
		sizeof	(PAI_OS_R_));

	log_message("Received OK to Open_ST400/PAI_Session for output message's");

	sprintf	(buff0,
		"Session Type             - %3.3s\n"\
		"Session Mode             - %2.2s\n"\
		"Session Number           - %4.4s\n"\
		"Input Seq Number         - %6.6s\n"\
		"Output Seq Number        - %6.6s\n",
		&PAI_OS_R_.sess_type,&PAI_OS_R_.sess_mode,
		&PAI_OS_R_.sess_number,
		&PAI_OS_R_.input_seq_number,&PAI_OS_R_.output_seq_number);

	log_message(buff0);

/*	Loop of reading message from mailbox (MFSERV$MLA1)
*/
	while ( 1 )
		{
		status = SS$_NOWRITER;
		while ( status != SS$_NORMAL )
			{
			log_message("Wait message from ST400\n");
			status = sys$qiow (	0,
					MBX_hnd_out,
					IO$_READVBLK|IO$M_WRITERCHECK,
					&iosb,
					0,0,
					MSG_BUF,			
					MSG_BUF_S,
					0,0,0,0);

			if ( iosb.cnd == SS$_NOWRITER )
				{
				log_error("sys$qiow-mbx-out",SS$_NOWRITER);
				sys$exit ( SS$_NOWRITER );
				}
			sprintf(buff0,"status = %d, %17.17s",status,MSG_BUF);
			log_message(buff0);
			}

		sprintf(buff0,"%17.17s",MSG_BUF);
		log_message(buff0);

		MSG_BUF_L = iosb.cnt;
		PAI_PKT_P = (struct PAI_PKT *) MSG_BUF;

		if ( !memcmp(PAI_PKT_P->type,"MMSG",4) ||
			!memcmp(PAI_PKT_P->type,"MRPL",4) )
			{
			if (NULL!=(MSG_BUF_P=(char *)
					memchr(MSG_BUF,FS5,MSG_BUF_L)) )
				{
				sprintf(buff0,"%17.17s %d bytes",
					MSG_BUF,
					MSG_BUF_P - MSG_BUF -
					sizeof(PAI_PKT) + 1 
					);
				log_message(buff0);

				PAI_Write (MSG_BUF+sizeof(PAI_PKT),
					   MSG_BUF_P - MSG_BUF -
					   sizeof(PAI_PKT) + 1 );

				memcpy (PAI_PKT_P->type,"RCVD",4);
				
				sprintf(buff0,"Send to ST400 Ok-%17.17s %d bytes",
					PAI_PKT_P,
					sizeof(PAI_PKT));

				log_message(buff0);
				status = sys$qio (	0,
				MBX_hnd_out,
				IO$_WRITEVBLK|IO$M_READERCHECK|IO$M_NORSWAIT,
				&iosb,
				0,0,
				PAI_PKT_P,			
				sizeof(PAI_PKT),
				0,0,0,0);
				}
			}
		else	{
			log_message("Check for CLOSE Session");
			if ( !memcmp(MSG_BUF,PAI_CS,sizeof(PAI_CS)-1) )
				{
				log_message("Received Close_ST400/PAI_Session for output message's");
				free ((void *) MSG_BUF);
				return 0;
				}
			}
		}

	return	0;
}

int	PAI_Info	(void)
{

union	buff	{
	char	trnl_name [64];
	int	info;
		} buff;

int	status;
short	ret_l;	

struct	item_list	{
	unsigned short	 buff_l,
			 item_c;
	char		*buff_p;
	short		*buff_l_p;
	unsigned	 term;
			} item_list = { sizeof(buff.trnl_name), LNM$_STRING,
					buff.trnl_name,&ret_l,0};

char	s0 [ ] = "LNM$SYSTEM_TABLE";
char	s1 [ ] = "MLA1$MFSERV";
char	s2 [ ] = "MBAXXXXXXX:";

	$DESCRIPTOR(tbl_name,s0);
	$DESCRIPTOR(log_name,s1);
	$DESCRIPTOR(mbx_name,s2);

/*	Check translation logical name MLA1$MFSERV in system logical name 
	table.
*/
	status = -1;
	while (status != SS$_NORMAL)
		{
		status = sys$trnlnm (0,&tbl_name,&log_name,0,&item_list);
		if (status != SS$_NORMAL)
			sleep (30);
		}
	sleep (10);

/*	Get mailbox_device default_buffer_size
*/
	mbx_name.dsc$w_length = ret_l;
	memcpy(mbx_name.dsc$a_pointer,buff.trnl_name,ret_l);
/*	for (;ret_l != 0;ret_l--)
		*(*mbx_name.dsc$a_pointer+ret_l) = *(buff.trnl_name+ret_l);
        	
*/	
	item_list.item_c = DVI$_DEVBUFSIZ;
	status = sys$getdvi (0,0,&mbx_name,&item_list,0,0,0,0);

	if (status == SS$_NORMAL)
		return buff.info;


/*	Return errorr signal
*/
	return -1;
}


void	main	(void)
{

char	buff0 [256];
char	ports [32];

	fgets(buff0,255,stdin);
	
	if ( sscanf (buff0, "%[^:]:%[0-9]",Host,ports) < 2 )
		{
		puts(Host);
		puts(ports);
		log_error ("Please check value with /ON=..",SS$_IVDEVNAM);
		sys$exit (SS$_IVDEVNAM);
	        }

	if ( gethostbyname (Host) == NULL) 
		{
		log_error ("Check device name",SS$_IVDEVNAM);
		sys$exit (SS$_IVDEVNAM);
	        }             			

	Port = atoi (ports);

	if ( (Port <= 0) || (Port > 16000) )
		{ 
		log_error ("Check port name",SS$_IVDEVNAM);
		sys$exit (SS$_IVDEVNAM);
                }
	
	sprintf(buff0,"Starting Host=%s, Port=%d",Host,Port);
	log_message (buff0);

	log_message("Copyright (c) 1994,1995 Laishev Ruslan R. All Right reserved !!!");
	log_message("ST400/PAI Message's Receiver v1.0");

	while ( 1 )
		{
		if ( 0 < (MBX_b_sz = PAI_Info()) )
			{
			sprintf(buff0,"MAILBOX size =%d",MBX_b_sz);
			log_message(buff0);
			PAI_Main (MBX_b_sz);
			}
		}

}