#include <stdio.h>
#include <stdlib.h>
#include <mem.h>
#include <string.h>
#include <dos.h>
#include "ipx.h"
#include "spx.h"

#define our_socket 0x5353
#define your_socket 0x4343
#define ecb_num 5
#define max_message 26

struct SPXECB ecb_list[ecb_num],listen_ecb;
struct SPXHEADER header_list[ecb_num],listen_header;
struct STABUF reply_buffer;
volatile int event_completed_flag,term_flag;

void far listen_esr(void)
	{
	_AX=_ES;
	_DS=_AX;
	event_completed_flag=1;
	}

void far listen_esr(void)
	{
	_AX=_ES;
	_DS=_AX;
	term_flag=1;
	}
void make_connection(char *packet_ptr,
		     int packet_len,unsigned int *connect_id)
	{
	int i,j;
	unsigned int old_time;

	open_socket(our_socket);
	for(i=0;i<ecb_num;i++)
		{
		memset(&ecb_list[i],0,sizeof(struct SPXECB));
		memset(&header_list[i],0,sizeof(struct SPXHEADER));
    		
		ecb_list[i].event_service_routine=listen_esr;
		ecb_list[i].socket_number=our_socket;
    		ecb_list[i].packet_count=2;
    		ecb_list[i].packet[0].address=&header_list[i];
    		ecb_list[i].packet[0].length=sizeof(struct SPXHEADER);
    		ecb_list[i].packet[1].address=packet_ptr;
	 	ecb_list[i].packet[1].length=*packet_len;
	
		spx_listen_for_sequenced_packet(&ecb_list[i]);
        	}
		
	event_completed_flag=0;
	memset(&listen_ecb,0,sizeof(struct SPXECB));
	memset(&listen_header,0,sizeof(struct SPXHEADER));

	listen_ecb.event_service_routine=listen_esr;
	listen_ecb.socket_number=our_socket;
    	listen_ecb.packet_count=1;
    	listen_ecb.packet[0].address=&receive_header;
    	listen_ecb.packet[0].length=sizeof(struct SPXHEADER);

	spx_listen_for_connection(&listen_ecb);

	old_time=get_interval_marker();
	while(listen_ecb.in_use)
		{
		printf("Waiting for connection...\n");
		if (get_interval_marker()-old_time>18.2*60)
			{
			*connect_id=0;
			return;
			}
		connect_id=listen_ecb.connection_id;
		}
	}

int send(void *packet_ptr,int packet_len,unsigned int connect_id)
	{
	struct SPXECB send_ecb;
	struct SPXHEADER send_header;
	unsigned int connection_id;

	memset(&send_ecb,0,sizeof(struct SPXECB));
	memset(&send_header,0,sizeof(struct SPXHEADER));

	send_ecb.packet_count=2;
	send_ecb.packet[0].address=&send_header;
	send_ecb.packet[0].length=sizeof(struct SPXHEADER);
	send_ecb.packet[1].address=packet_ptr;
	send_ecb.packet[1].length=packet_len;
	connection_id=connect_id;

	spx_send_sequenced_packet(&send_ecb,connection_id);

	while (send_ecb.in_use)
		ipx_relinquish_control();
	if (send_ecb.completion_code==0)
		return(1);
	else
		return(0);
	}

void terminate_connection(unsigned int connection_id)
	{
	struct SPXECB term_ecb;
	struct SPXHESDER term_header;

	memset(&term_ecb,0,sizeof(struct SPXECB));
	memset(&term_header,0,sizeof(struct SPXHEADER));

	term_flag=0;
	term_ecb.event_service_routine=term_esr;
	term_ecb.packet_count=1;
	term_ecb.packet[0].address=&send_header;
	term_ecb.packet[0].length=sizeof(struct SPXHEADER);
	
	spx_terminate_connection(&term_ecb,connection_id);

	while (!term_flag)
	close(our_socket);
	return;
	}

main()
	{
	int i,j,k,message_len;
	unsigned int *p;
	unsigned int connect_id;
	char send_message[100];

	j=0;
	i=ipx_spx_installed();
	if (i<1) 
		{
		printf("!!SPX is not loaded, please load SPX first.\n")
		return;
		}
	
	p=(unsigned int *)malloc(2);
	make_connection(send_message,message_len,p);

	connect_id=*p;
	free(p);
	if (!connect_id)
		{
		close_socket(our_socket);
		printf("\n!No other station answer me,
			   the connection can not be established!\n");
		return;
		}
	
	memset(&reply_buffer,0,sizeof(struct STABUF));
	spx_set_connection_status(&reply_buffer,connect_id);

	while(1)
		{
		printf("SPX communication testing message(type'Exit' to Quit):\n");
		gets(sent_message);
		if (!strcmp(send_message,"Exit")) break;
		i=send(send_message,message_len+1,connect_id);
		if (i==1)
			{
			 j=j+1;
			 printf("Message %d has been sent!\n\n",j);
			}
		else
			{
			 printf("Fail to send!\n");
			 break;
			}
		}
	terminate_connection(connect_id);
	}