/*
 Telnet server demo
 File name: telserv.c
 Compile mode: large
 
 Final date: [11/13/2001]
*/

/*
TELSERV1.c: Telnet Server Demo program for 7188E series
          A server listen and wait to handle the coming connections

Compiler: BC++ 3.1, 
          Turbo C++ 1.01(3.01) (free from http://cc.codegear.com/free/cpp)
          
Compile mode: large

Project: TELSERV1.C
         ..\..\..\lib\7188el.lib
         ..\..\..\lib\tcpip32.lib

Details:
    Setup a server, wait for connections.
    While a connection has been established, receive data from clients.
*/

int ES2_DEBUG=0;              /* 0 to hide debug information */

#include<string.h>
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include "..\..\..\lib\7188E.h"
#include "..\..\..\lib\tcpip32.h"

#define BUFSIZE 1024	      /* read/write buffer size */
#define SERVICE 23	      /* define the service port for BBS Server */
#define SOCKETS 32	      /* define the maximum number of sockets */
#define QLEN	(SOCKETS-1)   /* maximum connection queue length */

void ProcessCmd(int socket,unsigned char *cmd);
char *Prompt="7188E>";

int QuitES=0;                 /* flag to run ES (service loop) */
fd_set rfds;                  /* set of socket file descriptors for reading */

typedef struct socket_state {
  int		     active;  /* socket is active */
  int		     init;    /* socket just initiated */
  struct sockaddr_in sin;     /* client address */
} socket_state;
socket_state sst[SOCKETS];    /* sockets state table */

/*************************************************************************
 * killsockets
 * clear, shutdown, and close all sockets
 *************************************************************************/
void killsockets(void)
{ int i;

  FD_ZERO( &rfds );       /* clear FD set */
  if(ES2_DEBUG > 1)  Print("{kill socket");
  for (i = 0; i < SOCKETS; i++) {
    if (sst[i].active) {  /* if socket lives, kill it */
      shutdown( i, 0 );
      closesocket( i );
      if(ES2_DEBUG > 1) Print( " %d,", i );
    }
  }
  if(ES2_DEBUG > 1)  Print( "}\n\r" );
}

unsigned char InData[BUFSIZE];
unsigned char OutData[BUFSIZE];
int InIdx=0;
/*************************************************************************
 * do_echo
 * when client is connected, do echo here
 *************************************************************************/
int do_echo( int skt )
{ int i,cc, err=0;
  char buf[BUFSIZE];

  if (sst[skt].init) {	       /* socket is just initiated */
    sst[skt].init = 0;
    return err;
  }
  if( ES2_DEBUG > 1)  Print( "reading..." );
  err = cc = readsocket( skt, buf, sizeof(buf) );
  if( ES2_DEBUG > 1)  Print( " done\n\r" );
  if (err == 0) {	       /* disconnected */
    if( ES2_DEBUG){
      unsigned char *addr=(unsigned char *)&sst[skt].sin.sin_addr.s_addr;
      Print( "disconnected -> %u.%u.%u.%u:%u on socket %d\n\r",
	     addr[0],addr[1],addr[2],addr[3],
	     ntohs(sst[skt].sin.sin_port), skt );
    }
    shutdown( skt, 0 );
    closesocket( skt );
    FD_CLR( skt, &rfds );
    sst[skt].active = 0;
    return err;
  }
  if (err < 0) {	       /* read error */
    Print( "echo read error %d\n\r", err );
    shutdown( skt, 0 );
    closesocket( skt );
    FD_CLR( skt, &rfds );
    sst[skt].active = 0;
    return err;
  }
  buf[cc] = '\0';
  if( ES2_DEBUG)
    Print( "s%d R%d \"%s\"\n\r", skt,cc, buf);

  err = writesocket( skt, buf, cc );
  if (err < 0) {	       /* write error */
    Print( "echo write error %d\n\r", err );
    shutdown( skt, 0 );
    closesocket( skt );
    FD_CLR( skt, &rfds );
    sst[skt].active = 0;
    return err;
  }
  if( ES2_DEBUG){
     buf[cc] = '\0';
     Print( "s%d S%d \"%s\"\n\r", skt,cc, buf );
  }
  for(i=0;i<cc;i++){
    Print("[%02X]",buf[i]);
    InData[InIdx]=buf[i];
    if(buf[i]=='\r'){
       InData[InIdx]=0;
       InIdx=0;
       ProcessCmd(skt,InData);
    }
    else if(buf[i]!='\n'){ /* ignore '\n' */
	    InIdx++;
    }
  }
  return err;
}

/*************************************************************************
 * main
 *
 * program main routine
 *************************************************************************/

int   RxCounter=0;
int   RxCounterOut=0;
struct ip host_ip =    { {192,168,255,2},{255,255,0,0} };

main( int argc, char *argv[] )
{
  struct sockaddr_in ssin; /* client Internet endpoing address */
  int sin_len;		   /* length of sockaddr_in */
  int s;		   /* master socket for listenning */
  int ss;		   /* slave socket got from accept */
  int type, protocol, err=0;
  int rc;		   /* return code of selectsocket */
  int i;
  struct timeval   seltime;

  memset(&seltime,0,sizeof(seltime)); /* set timeout to 0 */
  SetLocalHostName("I7188EX");
  
  err=NetStart();
  if(err!=NoError)
  {
        Print("Init Ethernet error.\n\r");
		return err;
  }
  Print( "STEP 1: Initially driver...\n\r" );
  /**************************
   * allocate master socket *
   **************************/
  type = SOCK_STREAM;  /* TCP/IP */
  protocol = 0;        /* always 0 */
  err = s = socket( PF_INET, type, protocol );
  Print( "STEP 2: socket...\n\r" );
  if (s < 0) {
    Print( "can't create socket! error %d\n\r", err );
    Nterm();
    return err;
  }
  if( ES2_DEBUG > 1)  Print( "master socket %d\n\r", s );

/*  addressing for master socket */ 
  memset( &sst[s].sin, 0, sizeof(sst[s].sin) ); /* bzero is a unix system call */
  sst[s].sin.sin_family = AF_INET;
  sst[s].sin.sin_addr.s_addr = 0; /* INADDR_ANY is a 32bits zero value */
  sst[s].sin.sin_port = htons( SERVICE );

/* bind the socket */ 
  err = bind( s, (struct sockaddr *)&sst[s].sin, sizeof(sst[s].sin) );
  Print( "STEP 3: bind...\n\r" );
  if (err < 0) {
    Print( "can't bind to port %d, error %d\n\r", SERVICE, err );
    closesocket( s );
    Nterm();
    return err;
  }

/* make listening */
  err = listen( s, QLEN );
  if (type == SOCK_STREAM && err < 0) {
    Print( "can't listen on port %d, error %d\n\r", SERVICE, err );
    closesocket( s );
    Nterm();
    return err;
  }

/* select */ 
  FD_ZERO( &rfds );
  for (i = 0; i < SOCKETS; i++) {
    sst[i].active = 0;
    sst[i].init   = 0;
  }
  sst[s].active = 1;  /* master socket is active */
  sin_len = sizeof( ssin );
  while (!QuitES) {	/* service loop */
    if(Kbhit() && Getch()==27) QuitES=1;
    for (i = 0; i < SOCKETS; i++) {
      if (sst[i].active) {  /* re-join active sockets */
	FD_SET( i, &rfds );
      }
    }
    rc = selectsocket( SOCKETS, &rfds, NULL, NULL, &seltime);
    if (rc < 0) {
      Print( "selectsocket error %d\n\r", rc );
      break;
    }
    if( !rc ){
 /*      Putch('*'); */
       continue;
    }
    if( ES2_DEBUG > 1)    Print( "%d socket(s) ready.\n\r", rc );
    for (i = 0; i < SOCKETS; i++) {  /* scan all possible sockets */
      if (FD_ISSET(i, &rfds)) {
	if (i == s) {  /* master socket */
	  memset( &ssin, 0, sizeof(ssin) );
	  err = ss = accept( s, (struct sockaddr *)&ssin, &sin_len );
	  if (err < 0) {
	    Print( "accept error %d\n\r", err );
	    break;
	  }
	  Print("socket=%d   accept !!!\n\r",i);
	  writesocket(ss,Prompt,strlen(Prompt));
	  FD_SET( ss, &rfds );
	  sst[ss].active = 1;
	  sst[ss].init	 = 1;
	  memcpy( &sst[ss].sin, &ssin, sin_len );
	  if( ES2_DEBUG) {
	     unsigned char *addr=(unsigned char *)&sst[ss].sin.sin_addr.s_addr;
	     Print( "connected    -> %u.%u.%u.%u:%u on socket %d\n\r",
		  addr[0],addr[1],addr[2],addr[3],
		  ntohs(sst[ss].sin.sin_port), ss );
	  }
	}
	else {       /* slave socket */
	  Print("socket=%d  do_echo() !!!\n\r",i);
	  do_echo( i );
	}
      }
    }
  }  /* service loop */
  killsockets();
  Nterm();
  return err;
}


static int SKT;
int OutLength;

void EchoMessage(void)
{int err;
  if(OutLength){
     err = writesocket( SKT,OutData, OutLength );
     if (err < 0) {	       /* write error */
       Print( "echo write error %d\n\r", err );
       shutdown( SKT, 0 );
       closesocket( SKT );
       FD_CLR( SKT, &rfds );
       sst[SKT].active = 0;
     }
  }
  writesocket(SKT,Prompt,strlen(Prompt));
}

void SetMyIp(void)
{ unsigned char ip[5];
  int i;

  if(4==sscanf(InData+6,"%u.%u.%u.%u",ip,ip+1,ip+2,ip+3)){
    OutLength=sprintf(OutData,"Set IP=%u.%u.%u.%u\n\r",ip[0],ip[1],ip[2],ip[3]);
    SetIp(ip);
  }
  else {
    OutLength=sprintf(OutData,"USE: SETIP ip1.ip2.ip3.ip4\r\n");
  }
}

unsigned char Dft_ip[4]={192,168,255,1};
void ResetMyIp(void)
{
  OutLength=sprintf(OutData,"Reset IP to : %u.%u.%u.%u\r\n",Dft_ip[0],Dft_ip[1],Dft_ip[2],Dft_ip[3]);
  SetIp(Dft_ip);
}


void GetMyIp(void)
{ unsigned char ip[4];

  GetIp(ip);
  OutLength=sprintf(OutData,"IP=%u.%u.%u.%u\r\n",ip[0],ip[1],ip[2],ip[3]);
}

void far *AddFarPtrLong(void far * ptr1,unsigned long size)
{
  size +=(long)FP_OFF(ptr1);
  return MK_FP(FP_SEG(ptr1)+(unsigned)(size>>4),(unsigned)(size & 0x0F));
}

unsigned GetLastFileSeg(void) 
{
  unsigned Flag;

  EE_MultiRead(7,254,2,(char *)&Flag); 

  if((Flag & 0xFFF0)==0xAAA0){
     Flag &= 0x0F;
  }
  else Flag=0;
  return 0xF000-(Flag<<12);
}

void Dir(void)
{ unsigned fileno=0;
  int i;
  FILE_DATA far *fdata;
  unsigned long FreeSizeForFile;

  switch(Is7188e()){
    case 256:
      fdata=(FILE_DATA far *)MK_FP(0xC000,0);
      break;
    case 512:
      fdata=(FILE_DATA far *)MK_FP(0x8000,0);
      break;
    default:
      OutLength=sprintf(OutData,"Not run on I8000\r\n");
      return;
  }
  for(;;) {
     if(fdata->mark==0x7188){
	  int i;
	  char fname[13];
	  fname[12]=0;
	  for(i=0;i<12;i++) fname[i]=(*fdata).fname[i];
	  OutLength=sprintf(OutData,"%2d)%-12.12s %02d/%02d/%d %02d:%02d:%02d %6lu[%05lX]%Fp-%Fp\n\r",
		  fileno,
		  fname,
		  fdata->month,fdata->day,fdata->year+1980,
		  fdata->hour,fdata->minute,fdata->sec,
		  fdata->size,fdata->size,fdata->addr,AddFarPtrLong(fdata->addr,fdata->size));
	  writesocket( SKT,OutData, OutLength );
	  Print("%2d)%-12.12s %02d/%02d/%d %02d:%02d:%02d %6lu[%05lX]%Fp-%Fp\n\r",
		  fileno,
		  fname,
		  fdata->month,fdata->day,fdata->year+1980,
		  fdata->hour,fdata->minute,fdata->sec,
		  fdata->size,fdata->size,fdata->addr,AddFarPtrLong(fdata->addr,fdata->size));

       fileno++;
       fdata=(FILE_DATA far *)AddFarPtrLong(fdata,sizeof(FILE_DATA)+fdata->size);
     }
     else {
       break;
     }
  }
  {
    unsigned LastSeg;

    LastSeg=GetLastFileSeg();
    if( LastSeg<=FP_SEG(fdata) ) FreeSizeForFile=0;
    else
      FreeSizeForFile=16L*(LastSeg-FP_SEG(fdata))-sizeof(FILE_DATA)-FP_OFF(fdata);
  }
  OutLength=sprintf(OutData,"Total File number is %u  Free space=%ld bytes\r\n",fileno,FreeSizeForFile);
}

void ProcessCmd(int socket,unsigned char *cmd)
{
  SKT=socket;
  OutLength=0;
  Print("Cmd:%s\n\r",cmd);
  if (!stricmp("quit", cmd) || !stricmp("exit", cmd)) {  /* shutdown echo server */
     QuitES = 1;
  }
  else if(!strnicmp("dir",cmd,5))  Dir();
  else if(!stricmp("getip",cmd))  GetMyIp();
  else if(!stricmp("resetip",cmd))  ResetMyIp();
  else if(!strnicmp("setip",cmd,5))  SetMyIp();

  EchoMessage();
}