// Telnet server demo2
// File name: TelServ2.c
// Compile mode: large

/*
TELSERV2.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: TELSERV2.C
         ..\..\..\lib\7188el.lib
         ..\..\..\lib\tcpip32.lib

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

#define ES2_DEBUG 0  /* unmark to show debug information */

#include <string.h>
#include "..\..\..\lib\7188e.h"
#include "..\..\..\lib\tcpip32.h"

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

int es;                    /* 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 " );
	#endif /* ES2_DEBUG */
	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 );
			#endif /* ES2_DEBUG */
		}
	}
	#if ES2_DEBUG > 1
	Print( "done\n\r" );
	#endif /* ES2_DEBUG */
}

/*************************************************************************
 * do_echo
 * when client is connected, do echo here
 *************************************************************************/
int do_echo( int skt )
{
	int 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..." );
  #endif /* ES2_DEBUG */
  err = cc = readsocket( skt, buf, sizeof(buf) );
  #if ES2_DEBUG > 1
  Print( " done\n\r" );
  #endif /* ES2_DEBUG */

  if (err == 0) {	       /* disconnected */
    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';
  #ifdef ES2_DEBUG > 1
  //Print( "%d characters \"%s\" read via socket %d\n\r", cc, buf, skt );
  #endif /* ES2_DEBUG */

  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;
  }
  #ifdef ES2_DEBUG > 1
  buf[cc] = '\0';
 // Print( "%d characters \"%s\" sent via socket %d\n\r", cc, buf, skt );
  #endif /* ES2_DEBUG */

  if (!strcmp("down", buf)) {  /* shutdown echo server */
    es = 0;
  }

  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;

	unsigned long far *IntVectMain=(unsigned long far *)0x00000000L;

	struct timeval   seltime;

	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 );
	#endif /* ES2_DEBUG */

	/********************************
	 * 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 );
	Print( "main 4\n\r" );
	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 );
	es = 1;
	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 (es) {	               /* service loop */
		for (i = 0; i < SOCKETS; i++) {
			if (sst[i].active) {     /* re-join active sockets */
				FD_SET( i, &rfds );
			}
		}

		Print( "main 5\n\r" );
		rc = selectsocket( SOCKETS, &rfds, NULL, NULL, NULL );
		if (rc < 0) {
			Print( "selectsocket error %d\n\r", rc );
			break;
		}
		if( !rc )
			 continue;

		#if ES2_DEBUG > 1
		Print( "%d socket(s) ready.\n\r", rc );
		#endif /* ES2_DEBUG */

		Print( "main 6\n\r" );
		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,"Hello Welcome",13);

					FD_SET( ss, &rfds );
					sst[ss].active = 1;
					sst[ss].init	 = 1;
					memcpy( &sst[ss].sin, &ssin, sin_len );

				}
				else {       /* slave socket */
					//Print("socket=%d  do_echo() !!!\n\r",i);
					do_echo( i );
				}
			}
		}
	}  /* service loop */
	killsockets();
	Nterm();
	return err;
}