//my expected acknowledgement number
      expected_ack = my_seqnum + swapbytes(tcpdatalen_out);


      send_tcp_packet();
   }

   //this code segment processes the incoming SYN from the Telnet client
   //and sends back the initial sequence number (ISN) and acknowledges
   //the incoming SYN packet
   if(SYN_IN && portaddr == MY_PORT_ADDRESS)
   {
      tcpdatalen_in = 0x01;
      flags.synflag = 1;

      setipaddrs();

      //swap the TCP source and destination ports
      temp = packet[TCP_srcport];
      packet[TCP_srcport] = packet[TCP_destport];
      packet[TCP_destport] = temp;

      //ASSEMBLE THE ACKNOWLEDGMENT
      client_seqnum=make32i(packet[TCP_seqnum],packet[TCP_seqnum+1]);
      client_seqnum = client_seqnum + swapbytes(tcpdatalen_in);
      packet[TCP_acknum] = (client_seqnum & 0xFFFF0000) >> 16;
      packet[TCP_acknum+1] = client_seqnum & 0x0000FFFF;

      if(++ISN == 0x0000 || ++ISN == 0xFFFF)
         ISN = 0x1234;
      my_seqnum = 0xFFFF3412;

      //PLACE THE ISN
	  packet[TCP_seqnum] = my_seqnum & 0x0000FFFF;
	  packet[TCP_seqnum+1] = (my_seqnum & 0xFFFF0000) >> 16;
	  //CLEAR TCP HEADER FLAGS
      packet[TCP_hdrflags] &= 0xC0FF;
      //SET THE SYN AND ACK FLAGS
      SYN_OUT;
      ACK_OUT;

      packet[TCP_cksum] = 0x00;
      //packet[TCP_cksum+1] = 0x00;

      hdr_chksum =0;
      hdrlen = 0x08;
      addr = &packet[ip_srcaddr];
      cksum();
      hdr_chksum = hdr_chksum + 256*HIGH_BYTE(packet[ip_ttlproto]);
      tcplen = swapbytes(packet[ip_pktlen]) - (LOW_BYTE(packet[ip_vers_len]) & 0x0F) *4;
      hdr_chksum = hdr_chksum + swapbytes(tcplen);
      hdrlen = tcplen;
      addr = &packet[TCP_srcport];
      cksum();
      packet[TCP_cksum]= ~(hdr_chksum + ((hdr_chksum & 0xFFFF0000) >> 16));
      echo_packet();
   }

   //this code segment processes a FIN from the Telnet client
   //and acknowledges the FIN and any incoming data.
   if(FIN_IN && portaddr == MY_PORT_ADDRESS)
   {
      if(tcpdatalen_in)
      {
         for(i=0;i<tcpdatalen_in;++i)
         {
            aux_data[i] = packet[TCP_data+i];
            application_code();
         }
      }

      flags.finflag = 1;

      ++tcpdatalen_in;

      incoming_ack =make32i(packet[TCP_acknum],packet[TCP_acknum+1]);
      if(incoming_ack <= expected_ack)
         my_seqnum = expected_ack - (expected_ack - incoming_ack);

      expected_ack = my_seqnum + swapbytes(tcpdatalen_out);
      send_tcp_packet();

   }
}
//******************************************************************
//*	Send TCP Packet
//*   This routine assembles and sends a complete TCP/IP packet.
//*   40 bytes of IP and TCP header data is assumed.
//******************************************************************
void send_tcp_packet()	
{
	unsigned int temp;

   //count IP and TCP header bytes.. Total = 40 bytes
   ip_packet_len = 40 + tcpdatalen_out;
   packet[ip_pktlen] = swapbytes(ip_packet_len);
   temp = packet[enetpacketLen11];  
   temp += tcpdatalen_out;	 
   packet[enetpacketLen11] = temp;  
   packet[enetpacketLen03] = swapbytes(temp);  

   setipaddrs();

      //swap the TCP source and destination ports
      temp = packet[TCP_srcport];
      packet[TCP_srcport] = packet[TCP_destport];
      packet[TCP_destport] = temp;

   client_seqnum=make32i(packet[TCP_seqnum],packet[TCP_seqnum+1]);
   client_seqnum = client_seqnum + swapbytes(tcpdatalen_in);
   packet[TCP_acknum] = (client_seqnum & 0xFFFF0000) >> 16;
   packet[TCP_acknum+1] = client_seqnum & 0x0000FFFF;
   packet[TCP_seqnum+1] = my_seqnum & 0x0000FFFF;
   packet[TCP_seqnum] = (my_seqnum & 0xFFFF0000) >> 16;



   packet[TCP_hdrflags] &= 0xC0FF;
   ACK_OUT;
   if(flags.finflag)
   {
      FIN_OUT;
      flags.finflag = 0;
   }

   packet[TCP_cksum] = 0x00;

   hdr_chksum =0;
   hdrlen = 0x08;
   addr = &packet[ip_srcaddr];
   cksum();
   hdr_chksum = hdr_chksum + 256*HIGH_BYTE(packet[ip_ttlproto]);
   tcplen = swapbytes(packet[ip_pktlen]) - (LOW_BYTE(packet[ip_vers_len]) & 0x0F) *4;
   hdr_chksum = hdr_chksum + swapbytes(tcplen);
   hdrlen = tcplen;
   addr = &packet[TCP_srcport];
   cksum();
   packet[TCP_cksum]= ~(hdr_chksum + ((hdr_chksum & 0xFFFF0000) >> 16));

	echo_packet();
}
//******************************************************************
//*	SETIPADDRS
//*   This function builds the IP header.
//******************************************************************
void setipaddrs(void)
{
   //move IP source address to destination address
   packet[ip_destaddr]=packet[ip_srcaddr];
   packet[ip_destaddr+1]=packet[ip_srcaddr+1];
   //make phoenix module IP address source address
   packet[ip_srcaddr]=ipaddri[0];
   packet[ip_srcaddr+1]=ipaddri[1];
   //move hardware source address to destination address
   packet[enetpacketDest01]=packet[enetpacketSrc01];
   packet[enetpacketDest23]=packet[enetpacketSrc23];
   packet[enetpacketDest45]=packet[enetpacketSrc45];
   //make phoenix module mac address the source address
   packet[enetpacketSrc01]=macaddri[0];
   packet[enetpacketSrc23]=macaddri[1];
   packet[enetpacketSrc45]=macaddri[2];

   //calculate the IP header checksum
   packet[ip_hdr_cksum]=0x00;

   hdr_chksum =0;
   hdrlen = (LOW_BYTE(packet[ip_vers_len]) & 0x0F) *4;
   addr = &packet[ip_vers_len];
   cksum();
   packet[ip_hdr_cksum]= ~(hdr_chksum + ((hdr_chksum & 0xFFFF0000) >> 16));
 }
//******************************************************************
//*	CHECKSUM CALCULATION ROUTINE
//******************************************************************
void cksum()
{
	  //hdr_chksum = 0;
      while(hdrlen > 1)
      {
	     hdr_chksum = hdr_chksum + *addr++;
         hdrlen -=2;
	  }
      if(hdrlen > 0)
	  {	
         hdr_chksum = hdr_chksum + (*addr & 0x00FF);
      	--hdrlen;
	  }		
}
//******************************************************************
//*	Echo Packet Function
//*   This routine does not modify the incoming packet size and
//*   thus echoes the original packet structure.
//******************************************************************
char echo_packet()
{
	char rc;
	unsigned int TxFID;

	TxFID = get_free_TxFID();
	if(TxFID == 0)
	 rc = 1;
	else
	{
     rc = bap_write(TxFID,rxdatalength_offset,(char*)packet,packet[enetpacketLen11]+16);
	 if(rc=send_command(TransmitReclaim_Cmd,TxFID))
		printf("\r\nTransmit failed");
	 
     do_event_housekeeping();
	}
	return(rc);
}
	
void wr_cf_data(char bapnum,char* buffer,unsigned int count)
{
	unsigned int addr,i;
	int *byteptr;
	char data_lo;

	if(bapnum)
		addr = Data1_Register;
	else
		addr = Data0_Register;

	byteptr = (int*)buffer;
	for(i=0;i<(count&0xFFFE);)
	{	
		wr_cf_io16(*byteptr++,addr); //write buffer word	
		i+=2;
	}
	if(count % 2)
	{
		data_lo = buffer[i++];		//write odd character if necessary
		wr_cf_io16(data_lo,addr);
	}
}
void wr_cf_addr(unsigned int addr)
{
	addr_hi = (make8(addr,1));
	addr_lo = addr & 0x00FF;
}

void wr_cf_reg(unsigned int reg_data,unsigned int reg_addr)
{
	TO_NIC;
	wr_cf_addr(reg_addr);
	data_out = reg_data;
	clr_WE;
	delay_ms(2);
	set_WE;
	FROM_NIC;
}
	
void wr_cf_io16(unsigned int data16,unsigned int addr)
{
	char i;

	wr_cf_addr(addr);
	data_out = LOW_BYTE(data16);
	TO_NIC;
	clr_IOWR;
	i=1;
	while(--i);
	set_IOWR;
	NOP();
	data_out = 0xFF;
	
	wr_cf_addr(addr+1);
	data_out = HIGH_BYTE(data16);
	clr_IOWR;
	i=1;
	while(--i);
	set_IOWR;
	NOP();
	data_out = 0xFF;
	FROM_NIC;
}
void wr_cf_io16s(unsigned int data16,unsigned int addr)
{
	wr_cf_addr(addr);
	data_out = LOW_BYTE(data16);
	TO_NIC;
	clr_IOWR;
	delay_ms(2);
	set_IOWR;
	NOP();
	
	wr_cf_addr(addr+1);
	data_out = HIGH_BYTE(data16);
	clr_IOWR;
	delay_ms(2);
	set_IOWR;
	NOP();
	data_out = 0xFF;
	FROM_NIC;
}

char rd_cf_reg(unsigned int reg_addr)
{
	char data,i;
	wr_cf_addr(reg_addr);
	clr_OE;
	i=1; 
	while(--i);			//read access delay
	data = data_in;
	set_OE;
	return(data);
}

unsigned int rd_cf_io16(unsigned int addr)
{
	char data_lo,data_hi,i;
	unsigned int data16;

	wr_cf_addr(addr);
	data_out = 0xFF;
	clr_IORD;
    i=3;
	while(--i);
	data_lo=data_in;
	set_IORD;
	NOP();

	wr_cf_addr(addr+1);
	clr_IORD;
    i=3;
	while(--i);
	data_hi=data_in;
	set_IORD;
	NOP();
	data16 = make16(data_hi,data_lo);
	return(data16);
}
unsigned int rd_cf_io16s(unsigned int addr)
{
	char data_lo,data_hi;
	unsigned int data16;

	wr_cf_addr(addr);
	clr_IORD;
	delay_ms(2); 			// 1 back to 2
	data_lo=data_in;
	set_IORD;
	NOP();

	wr_cf_addr(addr+1);
	clr_IORD;
	delay_ms(2);
	data_hi=data_in;
	set_IORD;
	NOP();
	data16 = make16(data_hi,data_lo);
	return(data16);
}

char  send_command(unsigned int cmd, unsigned int parm0)
{
	char cmd_code,rc;
	unsigned int cmd_status,evstat_data;

	do{
	   cmd_data = rd_cf_io16(Command_Register);
	  }while(cmd_data &  CmdBusy_Bit_Mask);
	
	wr_cf_io16(parm0, Param0_Register);
	wr_cf_io16(cmd, Command_Register);
	
	do{
	   cmd_data = rd_cf_io16(Command_Register);
	  }while(cmd_data &  CmdBusy_Bit_Mask);
	
	do{
		evstat_data = rd_cf_io16(EvStat_Register);
	  }while(!(evstat_data & EvStat_Cmd_Bit_Mask));

	cmd_status = rd_cf_io16( Status_Register);
	rc = cmd_status &  Status_Result_Mask;
	wr_cf_io16( EvStat_Cmd_Bit_Mask, EvAck_Register);

	switch(rc)
	{
		case 0x00:
			rc = 0;	//command completed OK
			break;
		case 0x01:
			rc = 1;	//card failure
			break;
		case 0x05:
			rc = 2; //no buffer space
			break;
		case 0x7F:
			rc = 3; //command error
			break;
	}
	return(rc);
}
void create_comframestructure(unsigned int len)
{
	unsigned int i;
    
	for(i=0;i<len;++i)
	 comframe_buffer[i] = 0x00;

	comframe_buffer[12] = 0x04;
    comframe_buffer[13] = 0x00;
	if(ad802_11Header)
	{
	comframe_buffer[14] = 0x08;
	comframe_buffer[15] = 0x01;
	}
	else
	{
	for(i=0;i<6;++i)
	 comframe_buffer[txsourceaddr_offset+i] = macaddrc[i];
	}
	//printf("\r\nTransmit Communications Frame Structure created and initialized ...");
	//for (i=0; i<len; i++, i++)
   //{
	//	printf("\r\n%02X) Read (High Low): %02X %02X", i, co