/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

//  Include Files

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <sys/select.h>

#include <unistd.h>

#include <sys/wait.h>

#include <arpa/telnet.h>

//For connect

#include <sys/socket.h>

#include <netinet/in.h>

//For posix_spawn

#include <spawn.h>

//for pipe

#include <fcntl.h>

#include <sys/stat.h>

#include <sys/param.h>

//Symbian headers

#include <e32std.h>

#include <es_sock.h>

#include <f32file.h>

void add_return(char* source, char* dest);

int startConnection();

TDriveNumber getSystemDrive();

int main(int argc, char *argv[], char **envp)

	{

	int net;

	int fds[3];

	int pid;

	int ctl_sock;

	int on = 1;

	int replicate = 0;

	int ch = 1;

	char ayt_response[]={IAC,NOP};

	socklen_t addrlen;

	int port = 23;

	sockaddr_in server_addr;

	sockaddr_in his_addr;

	const char *argstr = "RDP:";

	while ((ch = getopt(argc, argv, argstr)) != -1) {

		switch (ch) {

		case 'D':

			for(int i=1 /*no name*/; i<argc; i++)

				{

				for(unsigned int j=0;j<strlen(argv[i]); j++)

					if(argv[i][j]=='D')

						{

						//Daemon token found, change it to allow replication to new background processes

						argv[i][j]='R';

						}

				}

			posix_spawn(NULL,argv[0],NULL,NULL,argv,envp);

			exit(0);

			break;

		case 'R':

			replicate = 1;

			break;

		case 'P':

			port = atoi(optarg);

			break;

		default:

			printf("unknown flag -%c ignored", optopt);

			scanf("");

			break;

		}

	}

	if(startConnection() != KErrNone)

		{

		exit(1);

		}

	ctl_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if (ctl_sock < 0)

		{

		exit(1);

		}

	if (setsockopt(ctl_sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) < 0)

		{

		exit(1);

		}

	server_addr.sin_family = AF_INET;

	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	server_addr.sin_port = htons(port);

	if (bind(ctl_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)

		{

		exit(1);

		}

	if (listen(ctl_sock, 32) < 0)

		{

		exit(1);

		}

	addrlen = sizeof(his_addr);

	net = accept(ctl_sock, (struct sockaddr *)&his_addr, &addrlen);

	if(net<0)

		{

		exit(1);

		}

	close(ctl_sock);

	//replicate server

	if(replicate)

		posix_spawn(NULL,argv[0],NULL,NULL,argv,envp);

	//launch shell and redirect the commands...

	pid=popen3("zsh.exe", NULL, NULL, fds);

	if(pid>0)

		{

		char read_zsh[256];

		char read_zsh_crlf[512];

		int sock_cnt=0, zsh_cnt=0, ret;

		int max=0;

	    fd_set read_fds;

	    //create fifo pipe

		char pipeName[MAXPATHLEN];

		sprintf(pipeName,"%c:\\telnetd_%d_pipe",getSystemDrive()+'A',getpid());

		if (mkfifo(pipeName, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH) < 0)

			{

			exit(1);

			}

		int pipe = open(pipeName, O_RDONLY | O_NONBLOCK);

	    max =  fds[1] > fds[2] ? fds[1] : fds[2];

		max =  max > net ? max : net;

		max =  max > pipe ? max : pipe;

		char exportVariable[MAXPATHLEN];

		sprintf(exportVariable,"PIPE='%s'\n",pipeName);

		//read first prompt and write PIPE variable

		read(fds[1], read_zsh, 11); //"localhost# "

		write(fds[0], exportVariable, strlen(exportVariable));

		for(;;)

			{

			int status=-1;

			FD_ZERO(&read_fds);

			FD_SET(net, &read_fds);

			FD_SET(fds[1], &read_fds);

			FD_SET(fds[2], &read_fds);

			FD_SET(pipe, &read_fds);

			//is child terminated...

			//Fix for defect to prevent the process from taking too much of the processor

			sleep(1);

			int wait_pid=waitpid(pid, &status, WNOHANG);

			if(pid == wait_pid || wait_pid == -1) //dont wait for the child to terminate

				{

				break;

				}

			//is any of the fds ready for read...

			ret=select(max+1, &read_fds, NULL, NULL, NULL);

			if(ret==-1)

				{

				break;

				}

   		    //is there any data to be written onto socket..

			if(FD_ISSET(fds[1], &read_fds))

				{

				memset(&read_zsh[0], 0, 256);

				zsh_cnt=read(fds[1], read_zsh, 255);

				if(zsh_cnt>0)

					{

					//reading from the socket can have more than one \n

					//so replace all \n with \r\n.

					add_return(read_zsh,read_zsh_crlf);

					write(net, read_zsh_crlf, strlen(read_zsh_crlf));

					}

				}

   		    //is there any data to be written onto socket..

			if (FD_ISSET(fds[2], &read_fds))

				{

				memset(&read_zsh[0], 0, 256);

				zsh_cnt=read(fds[2], read_zsh, 255);

				if(zsh_cnt>0)

					{

					//reading from the socket can have more than one \n

					//so replace all \n with \r\n.

					add_return(read_zsh,read_zsh_crlf);

					write(net, read_zsh_crlf, strlen(read_zsh_crlf));

					}

				}

			//is there any data to be written on to pipe

			if(FD_ISSET(net, &read_fds))

				{

				//char* ptr=0;

				char temp,temp2;

				sock_cnt=0;

				sock_cnt=read(net, &temp, 1);

				if(sock_cnt > 0)

					{

					//echo the command..

					//write(net, &temp, 1);

					switch(temp & 0xFF)

						{

						case '\r':

								sock_cnt=read(net, &temp, 1); //expect \n here...

								//write(net, &temp, 1);

								if(sock_cnt && !(write(fds[0], &temp, 1) > 0))

									printf("1 telnetd: zsh is not waiting for data.\n");

								break;

						case IAC: //telnet command

							{

								read(net, &temp2, 1);

								switch(temp2 & 0xFF)

									{

									case AYT:

										write(net,&ayt_response,2);

										break;

									}

								break;

							}

						default:

							if(!(write(fds[0], &temp, 1) > 0))

								printf("2 telnetd: zsh is not waiting for data.\n");

						}

					}

   		    	}

			if(FD_ISSET(pipe, &read_fds))

				{

				memset(&read_zsh[0], 0, 256);

				zsh_cnt=read(pipe, read_zsh, 255);

				if(zsh_cnt>0)

					{

					write(net, read_zsh, strlen(read_zsh));

					}

				}

			}

		close(net);

		close(fds[0]);

		close(fds[1]);

		close(fds[2]);

		close(pipe);

		//delete pipe file

		unlink(pipeName);

		exit(0);//exit server here...

		}

	else

		{

		char errorMessage[]="\n\rShell (zsh.exe) not launched\n\r";

		write(net, errorMessage, strlen(errorMessage));

		sleep(5);

		exit(-1); //exit here

		}

	}

void add_return(char* source, char* dest)

	{

	int sourceLen = strlen(source);

	int destIndex = 0;

	int sourceIndex = 0;

	for(; sourceIndex<sourceLen; sourceIndex++, destIndex++)

		{

		if(source[sourceIndex]=='\n')

			{

			dest[destIndex]='\r';

			destIndex++;

			}

		dest[destIndex] = source[sourceIndex];

		}

	dest[destIndex] = '\0';

	}

int startConnection()

	{

	int error;

	RSocketServ rSockServer;

	error = rSockServer.Connect();

	if(error == KErrNone)

    {

    RConnection rConnect;

    error = rConnect.Open(rSockServer);

    if(error == KErrNone)

        {

        TRequestStatus status;

        rConnect.Start(status);

        User::WaitForRequest(status);

        }

    rConnect.Close();

    }

	rSockServer.Close();

	return error;

	}

TDriveNumber getSystemDrive()

	{

	_LIT(KFileSrvDll, "efsrv.dll");

	TDriveNumber defaultSysDrive(EDriveC);

	RLibrary pluginLibrary;

	TInt pluginErr = pluginLibrary.Load(KFileSrvDll);

	if (pluginErr == KErrNone)

		{

		typedef TDriveNumber(*fun1)();

		fun1 sysdrive;

	#ifdef __EABI__

		sysdrive = (fun1)pluginLibrary.Lookup(336);

	#else

		sysdrive = (fun1)pluginLibrary.Lookup(304);

	#endif

		if(sysdrive!=NULL)

			{

			defaultSysDrive = sysdrive();

			}

		}

	pluginLibrary.Close();

	return defaultSysDrive;

	}