/*
    Nserver For Linux

    Copyright (C) 1999-2001 Sean Billings 

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/* nserver.c for Nokia Communicators */

/* comments or suggestions: nserver@syrinx.globalnet.co.uk */

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#ifdef BSD
#include <termios.h>
#include <unistd.h>
#else
#include <termio.h>
#endif
#include <sys/stat.h>
#ifdef SUN
#include <sys/dir.h>
#else
#include <dirent.h>
#endif
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include "nserver.h"
#include "crc.h"
#include "charmap.h"

#define VERSION "1.0.0"

int porthandle;		/*Handle to the serial port*/
unsigned int speed=DEFAULT_SPEED;
char port[30]=DEFAULT_PORT;
unsigned char echoback=0;
unsigned char acknak=0;
unsigned char last_RBACK=0;	/*flag to indicate what RB ACK should go next*/
unsigned char last_HDR=1;	/*flag to indicate what the last command header we used was*/
unsigned cmdready=0;		/*flag to indicate if set that on a cmd1/2 to show the prompt*/
unsigned char msgShift=0;	/*Shift indicator used by processMSG*/
unsigned char noLFCR=0;		/*set to non zero to stop sendMessage prefixing a LF and CR*/
unsigned char NAKflag=0;	/*indicates that the next message should append a NAK*/
unsigned char showconnect=1;	/*indicates that 'connect' should be shown*/
unsigned char guimode=0;	/*indicates that nserver is running under a GUI*/
char curdir[2048];		/*store NOKIA's version of the current directory*/
char realcwd[2049];		/*store the real cwd on startup (used as C:\NSERVER)*/
unsigned char olddir[2049];	/*used by filesize to backup the current dir*/

unsigned int debug=0;		/*set to 1 for simple debugging and >1 to enable full debug output*/

void noop(){	/*just for FreeBSD???*/
}

int openport(char *port, unsigned int speed){

	int tty, i;

	#ifdef BSD
	struct termios attr;
	#else
	struct termio attr;
	#endif
	unsigned int speedy;

	switch(speed){
	case 9600:
		speedy = B9600;
		break;
	case 19200:
		speedy = B19200;
		break;
	default:
		fputs("9600 or 19200 Please\n", stderr);
		exit(1);
	}

	if ((tty=open(port, O_RDWR|O_NONBLOCK)) == -1){
		fputs("failed to open port.\n", stderr);
		exit(1);
	}

	#ifdef BSD
	ioctl(tty, TIOCGETA, &attr);
	#else
	ioctl(tty, TCGETA, &attr);
	#endif

	attr.c_iflag = IGNBRK;
	attr.c_oflag = 0;
	attr.c_lflag = 0;
	#ifdef SGI	/* I have no idea if this works */
		attr.c_cflag = speedy|CS8|HUPCL|CREAD|CNEW_RTSCTS;
	#else
		#ifdef BSD
		attr.c_cflag=CS8|HUPCL|CREAD|CRTSCTS;
		cfsetispeed(&attr, speedy);
		cfsetospeed(&attr, speedy);
		#else
		attr.c_cflag=speedy|CS8|HUPCL|CREAD|CRTSCTS;
		#endif
	#endif
	#ifndef BSD
	attr.c_line = 0;
	#endif

	#ifdef BSD
	for (i=0; i<NCCS; i++)
		attr.c_cc[i] = _POSIX_VDISABLE;
	#else
	for (i=0; i<NCC; i++)
		attr.c_cc[i] = CNUL;
	#endif

	attr.c_cc[VTIME] = 0;
	attr.c_cc[VMIN] = 1;

	#ifdef BSD
	ioctl(tty, TIOCSETA, &attr);
	#else
	ioctl(tty, TCSETA, &attr);
	#endif
	fcntl(tty, F_SETFL, 0);		/*Make port locking*/

	return(tty);
}

void sendByte(unsigned char byte){
	write(porthandle, &byte,1);
	if(debug>1)
		printf("sendByte %x\n",byte);
}

void sendMessage(char *buf,unsigned int bufsize){	/*sends text message buf in encapsulated form*/
	unsigned short chksum=0x0000;
	unsigned int a;
	unsigned char sendbuf[BUF_SIZE];		/*transmission buffer*/

	if(bufsize==0 && echoback==0 && acknak==0)
		return;		/*exit if nothing to send*/

	/*Set the header*/
	sendbuf[0]=NOKIA_CMD;
	if(last_HDR==1){
		sendbuf[1]=NOKIA_HDR1;
		last_HDR=0;
	}else{
		sendbuf[1]=NOKIA_HDR2;
		last_HDR=1;
	}

	/*load the message into the buffer*/
	if(!(echoback==0 && bufsize==0) && noLFCR==0){ 
		/*prefix LF and CR*/
		strcpy(&sendbuf[2],"\x0A\x0D");
		for(a=0;a<bufsize;a++)
			sendbuf[a+4]=buf[a];
		bufsize+=4;
	}else{
		/*verbatim*/
		for(a=0;a<bufsize;a++)
			sendbuf[a+2]=buf[a];
		bufsize+=2;
	}
	/*if ack/nak is on then append ack to the message*/
	if(acknak==1)
		if(NAKflag==0)
			for(a=0;a<strlen(NOKIA_ACK);a++)
				sendbuf[bufsize++]=NOKIA_ACK[a];
		else{
			for(a=0;a<strlen(NOKIA_NAK);a++)
				sendbuf[bufsize++]=NOKIA_NAK[a];
			NAKflag=0;
		}
	/*send the message*/
	for(a=0;a<bufsize;a++){
		if(sendbuf[a]==NOKIA_CMD && a>0)
			sendByte(NOKIA_CMD);	/*used to esc a CMD char in the data*/
		sendByte(sendbuf[a]);
	}

	/*calc and send the CRC*/
	sendByte(NOKIA_CMD);
	sendByte(NOKIA_CHK);
	chksum=nserverCRC(sendbuf,bufsize);
	if((chksum & 0x00FF)==NOKIA_CMD)
		sendByte(NOKIA_CMD);	/*esc the CMD char*/
	sendByte(chksum & 0x00FF);		/*LSB*/
	if(((chksum & 0xFF00)>>8)==NOKIA_CMD)
		sendByte(NOKIA_CMD);	/*esc the CMD char*/
	sendByte((chksum & 0xFF00)>>8);		/*MSB*/
}

void sendCode(unsigned char *buf, unsigned int bufsize){
	/*sends verbatim characters to the Nokia*/
	unsigned int a;
	for(a=0;a<bufsize;a++)
		sendByte(buf[a]);
}

void send_RBACK(void){
	if(last_RBACK==1){
		sendCode(NOKIA_CMD1,4);
		last_RBACK=0;
	}else{
		sendCode(NOKIA_CMD2,4);
		last_RBACK=1;
	}
}

unsigned int getMessage(unsigned char *buf){	/*read message from Nokia returns size of buffer*/
	unsigned char tmpbyte;
	unsigned int bufl=0;		/*buffer length*/
	unsigned int gotchk=0;		/*flag to indicate that we got the chksum*/
	int portErr=0;
	unsigned int chksum;
	unsigned char ESCflag=0;	/*flag used to detect 0x9595 Escaping*/
	unsigned char IgnoreCMD=0;	/*used by the Escaped CMD checks*/
	unsigned char noIgnore=0;	/*used by the above*/

	unsigned char eom[10]={'\0'};		/*end of message string*/

	fd_set rfds;		/*used by select*/
	struct timeval tv;	/*used by select*/
	int retval;		/*return from select*/

	unsigned int a;

	/*uses the simple logic that all messages from the Nokia
	  are terminated with the checksum message or are CMD1
	  or CMD2*/
	/*Well, OK, it is not so simple now, I have added in a
	  timeout, if nothing is received in 1.5s*/

	do{
		/*wait for input*/
		FD_ZERO(&rfds);
		FD_SET(porthandle,&rfds);
		tv.tv_sec=1;
		tv.tv_usec=500000;
		retval=select(porthandle+1, &rfds, NULL, NULL, &tv);
		if(retval)
			portErr=read(porthandle,&tmpbyte,1);
		else
			return(bufl);
		if(portErr==0){
			/*handle eof by closing*/
			close(porthandle);
			/*and then re-opening*/
			porthandle=openport(port,speed);
		}
		if(portErr<0)
			printf("Port error %d\n",portErr);
		if(portErr==1){
			/*new code to check for end of message*/
			if(tmpbyte==NOKIA_CMD)
				if(ESCflag==0){
					for(a=0;a<10;a++)
						eom[a]='\0';
					eom[0]=tmpbyte;
				}
				else
					eom[strlen(eom)]=tmpbyte;
			else if(strlen(eom)>0)
				eom[strlen(eom)]=tmpbyte;
			if(strlen(eom)>4)
				for(a=0;a<10;a++)
					eom[a]='\0';

			/*check for 0x9595 data*/
			if(tmpbyte==NOKIA_CMD)
				if(ESCflag!=0){
					ESCflag=0;		/*previous char was 0x95 so ignore this one*/
					IgnoreCMD=1;
				}else{
					buf[bufl++]=tmpbyte;	/*add the received char to the buffer*/
					ESCflag=1;		/*set flag to indicate last char was 0x95*/
					IgnoreCMD=0;		/*and reset Escaped CMD flag*/
				}
			else{
				buf[bufl++]=tmpbyte;		/*add the received char to the buffer*/
				ESCflag=0;			/*clear flag*/
			}
			if(IgnoreCMD!=0 && noIgnore!=0)
				IgnoreCMD=0;
			if(IgnoreCMD==0){		/*only do checks if last CMD wasn't escaped*/
				if(bufl>2)	/*10/09/99 special check to prevent the ignore flag being set*/
					if(buf[bufl-2]==NOKIA_CMD && buf[bufl-1]==NOKIA_CHK)
						noIgnore=1;
				if(bufl==4)
					if(strncmp(buf,NOKIA_CMD1,4)==0 || strncmp(buf,NOKIA_CMD2,4)==0)
						gotchk=1;
				if(bufl>4){
					tmpbyte=NOKIA_CMD;
					if(buf[bufl-4]==tmpbyte){
						tmpbyte=NOKIA_CHK;
						if(buf[bufl-3]==tmpbyte){
							gotchk=1;
							/*validate the chksum*/
							if(buf[0]==NOKIA_CMD && (buf[1]==NOKIA_HDR1 || buf[1]==NOKIA_HDR2)){	/*but only if it starts correctly*/
								chksum=buf[bufl-1] *0x100;
								chksum+=buf[bufl-2];
								if(chksum!=nserverCRC(&buf[0],bufl-4)){
									if(debug){
										printf("msg failed CRC\n");
										for(a=0;a<bufl;a++)
											printf(" %x",buf[a]);
										printf("\n");
									}
									bufl=0;
								}
							}
						}
					}
				}
			}
			if(bufl>=strlen(NOKIA_EXIT))
				if(strncmp(&buf[bufl-3],NOKIA_EXIT,strlen(NOKIA_EXIT))==0)
					gotchk=1;
		}
	}while(gotchk==0);
	return(bufl);
}

unsigned int stripMessage(unsigned char *buf,unsigned int bufsize){
	/*removes the encapsulation*/
	/*re-written 16/10/99*/

	unsigned int a,b,c,d,e;
	unsigned int newbufsize=0;
	unsigned int wastecount=0;
	unsigned char newbuf[BUF_SIZE];

	unsigned int HDRs[100];
	unsigned int CHKs[100];
	unsigned int nextHDR=0;
	unsigned int nextCHK=0;

	if(debug>1){
		printf("stripMessage:");
		for(a=0;a<bufsize;a++)
			printf(" %x",buf[a]);
		printf("\n");
	}

	/*first up build arrays of HDRs and CHKs*/
	if(bufsize>3){
		for(a=0;a<bufsize-3;a++){
			if(buf[a]==NOKIA_CMD){
				if(buf[a+1]==NOKIA_HDR1 || buf[a+1]==NOKIA_HDR2)
					HDRs[nextHDR++]=a;
				if(buf[a+1]==NOKIA_CHK)
					CHKs[nextCHK++]=a;
			}
		}
	}
	if(nextCHK>0 && nextHDR>0){
		for(e=0;e<1;e++){
			/*remove any false HDRs or CHKs*/
			b=0;
			for(a=0;a<nextHDR-1;a++){	/*remove HDRs that are 'spare' within HDR-CHK encapsulation*/
				if(b<nextCHK-1 && a>0)
					b++;
				for(c=a+1;c<nextHDR;c++){
					if(HDRs[c]<CHKs[b]){
						for(d=c;d<nextHDR-1;d++)
							HDRs[d]=HDRs[d+1];
						nextHDR--;
						e=0;		/*keep going round*/
						a=0;		/*go back to the start again*/
						b=0;
					}
				}
			}
			for(a=0;a<nextHDR;a++){		/*remove any HDRs that are part of CHKs CHKSUM component*/
				for(b=0;b<nextCHK;b++){
					if(HDRs[a]==CHKs[b]+2 || HDRs[a]==CHKs[b]+2){
						for(c=a;c<nextHDR-1;c++)
							HDRs[c]=HDRs[c+1];
						nextHDR--;
						e=0;		/*keep going round*/
						a=0;		/*back to the start*/
						break;
					}
				}
			}
			b=nextHDR-1;
			for(a=nextCHK-1;a>0;a--){	/*remove any 'spare' CHKs within HDR-CHK encapsulation*/
				if(b>0 && a<nextCHK-1)
					b--;
				if(CHKs[a]>HDRs[b] && a>0){	/*safety check*/
					if(CHKs[a-1]>HDRs[b]){
						for(c=a-1;c<nextCHK-1;c++)
							CHKs[c]=CHKs[c+1];
						nextCHK--;
						e=0;		/*keep going round*/
						a=nextCHK;	/*back to start*/
						b=nextHDR-1;
					}
				}
			}
		}
	}
	if(nextHDR!=nextCHK){
		/*contingency code for too complex packets or non complete packets*/
		if(nextHDR==1 && nextCHK==0)
			if(HDRs[0]!=0)
				nextHDR=0;	/*only allowed to have it at start*/
		if(nextHDR>0 && nextCHK>0){
			nextHDR=1;
			CHKs[0]=CHKs[nextCHK];
			nextCHK=1;
		}
	}

	if(debug>1){
		printf("Headers: ");
		for(a=0;a<nextHDR;a++)
			printf(" %d",HDRs[a]);
		printf("\nChecks: ");
		for(a=0;a<nextCHK;a++)
			printf(" %d",CHKs[a]);
		printf("\n");
	}

	/*now strip the encapsulation out*/
	for(a=0;a<bufsize;a++){
		if(wastecount==0){
			if(buf[a]==NOKIA_CMD){
				/*see if it is on the HDR hitlist*/
				for(b=0;b<nextHDR;b++){
					if(a==HDRs[b]){
						wastecount=2;
						if(buf[a+1]==NOKIA_HDR1)	/*indicate which RB ACK message should be sent*/
							last_RBACK=1;
						else
							last_RBACK=0;
						break;
					}
				}
				/*now see if it is on the CHK hitlist*/
				for(b=0;b<nextCHK;b++){
					if(a==CHKs[b]){
						wastecount=4;
						break;
					}
				}
			}
		}else
			wastecount--;
		if(wastecount==0)			/*if character is not to be wasted*/
			newbuf[newbufsize++]=buf[a];	/*copy this char to the new buffer*/
	}
	if(newbufsize<bufsize){		/*if any chars were stripped then copy back*/
		for(a=0;a<newbufsize;a++)
			buf[a]=newbuf[a];
		return(newbufsize);	/*and update the buffer size*/
	}
	return(bufsize);		/*no changes so return full buffer size*/
}

int cmdCompare(char *buf,unsigned int start,unsigned int bufsize,char *cmd, unsigned int cmdsize){
	/*returns non zero if the command cmd is present starting from start*/
	unsigned int a;

	if(start+cmdsize>bufsize)
		return(0);		/*not enough chars left*/
	for(a=0;a<cmdsize;a++)
		if(buf[start+a]!=cmd[a])
			return(0);	/*no match*/
	/*A match*/
	return(-1);
}

int waitforACK(void){
	/*wait for RB ACK (CMD1/2)*/
	unsigned char buf[BUF_SIZE];
	unsigned int bufsize=0;
	fd_set rfds;		/*used by select*/
	struct timeval tv;	/*used by select*/
	int retval;		/*return from select*/

	if(debug)
		printf("waitforACK %d\n",last_HDR+1);
	/*wait for input*/
	FD_ZERO(&rfds);
	FD_SET(porthandle,&rfds);
	tv.tv_sec=1;
	tv.tv_usec=500000;
	retval=select(porthandle+1, &rfds, NULL, NULL, &tv);
	if(retval){
		if((bufsize=getMessage(buf))!=0){
			stripMessage(buf,bufsize);
			if(debug){
				if(cmdCompare(buf,0,bufsize,NOKIA_CMD1,4)!=0)
					printf("got NOKIA_CMD1\n");
				else if(cmdCompare(buf,0,bufsize,NOKIA_CMD2,4)!=0)
					printf("got NOKIA_CMD2\n");
			}
			if(cmdCompare(buf,0,bufsize,NOKIA_CMD1,4)!=0 || cmdCompare(buf,0,bufsize,NOKIA_CMD2,4)!=0){
				if(last_HDR==0 && cmdCompare(buf,0,bufsize,NOKIA_CMD1,4)!=0)
					return(-1);
				if(last_HDR==1 && cmdCompare(buf,0,bufsize,NOKIA_CMD2,4)!=0)
					return(-1);
				return(0);	/*wrong ACK*/
			}else
				return(0);
		}
	}
	if(debug)
		printf("timeout\n");
	return(0);
}

int sendMessage_ACK(char *buf,unsigned int bufsize){	/*same as sendMessage except waits for ACK*/
	unsigned char retry=5;
	unsigned char old_last_RBACK;
	unsigned char old_last_HDR;
	do{
		old_last_RBACK=last_RBACK;
		old_last_HDR=last_HDR;
		sendMessage(buf,bufsize);
		if(!waitforACK())
			retry--;
		else
			return(-1);
		if(debug)
			printf("sendMessage_ACK - retries left: %d\n",retry);
		last_RBACK=old_last_RBACK;
		last_HDR=old_last_HDR;
	}while(retry>0);
	return(0);
}

void showunknown(unsigned char *msg,unsigned int size,char *dbg){
	unsigned int a;
	if(debug==0)
		return;
	printf("%s:",dbg);
	for(a=0;a<size;a++)
		printf(" %x",msg[a]);
	printf("\n");
}

void updatecwd(void){
	/*work out the DOS compatible cwd from the unix cwd*/
	char tmp[2049];
	unsigned int a;

	getcwd(tmp,2048);
	if(strncmp(tmp,realcwd,strlen(realcwd)-1)==0){
		strcpy(&curdir[10],&tmp[strlen(realcwd)]);
		for(a=0;a<strlen(curdir);a++)
			if(curdir[a]=='/')
				curdir[a]='\\';
	}
}

void show_prompt(void){
	/*echo display prompt*/
	char tmp[2049];
	if(echoback==1){
		strcpy(tmp,curdir);
		/* SCB - modified so that if you use the safe D drive it looks
		   like it is the root dir to the communicator */
		if(strncmp(curdir,"C:\\NSERVER\\D",12)==0){
			strcpy(tmp,"D:\\");
			if(strlen(curdir)>13)
				strcpy(&tmp[3],&curdir[13]);
		}
		
		strcpy(&tmp[strlen(tmp)],">;");
		sendMessage(tmp,strlen(tmp));
		if(debug)
			printf("%s>\n",curdir);
	}
	else
		sendMessage("",0);
}

void do_cmd1(void){
	if(debug)
		printf("NOKIA_CMD1\n");
	if(cmdready==1)
		show_prompt();
	cmdready=0;
	last_HDR=0;
}

void do_cmd2(void){
	if(debug)
		printf("NOKIA_CMD2\n");
	if(cmdready==1)
		show_prompt();
	cmdready=0;
	last_HDR=1;
}

void do_ebon(void){
	if(debug)
		printf("Echoback = on\n");
	send_RBACK();
	cmdready=1;
	sendMessage("Echoback = on",13);
	echoback=1;
}

void do_eboff(void){
	if(debug)
		printf("Echoback = off\n");
	send_RBACK();
	cmdready=1;
	echoback=0;
}

void do_akon(void){
	if(debug)
		printf("ACK/NAK = on\n");
	send_RBACK();
	cmdready=1;
	if(echoback==1)
		sendMessage("ACK/NAK = on",12);
	else{
		acknak=1;
		sendMessage("",0);
	}
	acknak=1;
}

void do_akoff(void){
	if(debug)
		printf("ACK/NAK = off\n");
	acknak=0;
	send_RBACK();
	cmdready=1;
	if(echoback==1)
		sendMessage("ACK/NAK = off",13);
}

void fixfile(char *file){
	/*fixes the filespec from DOS to unix
	  file must be a null teminated string*/
	
	unsigned int a;

	/*first up remove C:\NSERVER\*/
	if(cmdCompare(file,0,strlen(file),"C:\\NSERVER\\",11)!=0)
		strcpy(&file[0],&file[11]);
	if(cmdCompare(file,0,strlen(file),"C:\\NSERVER",10)!=0)
		file[0]='\0';

	/* below mod by Panu Matilainen so you no longer need a C directory
	   underneath the nserver one. -note from SCB you can now however set
	   your communicator to use D:\ if you do want a 'safe dir'. */
	if(cmdCompare(file,0,strlen(file),"C:\\",3)!=0)
		file[0]='\0';
		
	/*now check for drive root access*/
	if(cmdCompare(file,0,strlen(file),"C:",2)!=0)
		strcpy(&file[1],&file[2]);	/*get rid of ':'*/
	if(cmdCompare(file,0,strlen(file),"D:",2)!=0)
		strcpy(&file[1],&file[2]);	/*get rid of ':'*/
	/*now convert any backslashes to forwardslashes*/
	for(a=0;a<strlen(file);a++)
		if(file[a]=='\\')
			file[a]='/';
}

int fixcase(char *file) {
/* original fixcase supplied by Panu Matilainen
   fixed by SCB so that it works within sub directories */
/* ifdef added by Ciaran Anscomb for SUN */

        DIR *dp;
	#ifdef SUN
		struct direct *dirp;
	#else
        	struct dirent *dirp;
	#endif
	char filename[256];
	char searchdir[BUF_SIZE];
	unsigned int a;
	filename[255]='\0';	/* safety precaution */
	
	/* if file is accessable then no need to continue -panu */
	if (access(file, F_OK | R_OK) == 0) {
		return 0;
	}
	
	sprintf(searchdir,"./%s",file);
	for(a=strlen(searchdir)-1;a>0;a--){
		if(searchdir[a]=='/'){
			searchdir[a]='\0';	/* found end of path */
			strncpy(filename,&searchdir[a+1],255);
			break;
		}
	}
	if(strcmp(searchdir,".")!=0)
		strcpy(searchdir,&searchdir[2]);
		
	if(debug)
		printf("fixcase: (%s) [%s] [%s]\n",file,searchdir,filename);
		
        if ((dp=opendir(searchdir)) == NULL) {
        	if(debug)
	                printf("error opening dir: %s\n",searchdir);
                return -1;
        }
        while ((dirp=readdir(dp)) != NULL) {
                if(debug)
                	printf("fixcase dir entry: %s\n",dirp->d_name);
                	
                if (strcasecmp(filename, dirp->d_name) == 0) {
                        if (debug)
				printf("%s matches %s\n", filename, dirp->d_name);
			/*rebuild filespec*/
			if(strcmp(searchdir,".")==0)
				strcpy(file,dirp->d_name);
			else
	                        sprintf(file,"%s/%s",searchdir,dirp->d_name);
	                closedir(dp);
                        return 0;
                }

        }
        closedir(dp);
        return 0;
}


void do_CD(unsigned char *msg,unsigned int size){
	char newdir[BUF_SIZE];
	unsigned int a;
	unsigned int newdirst=0;
	int cderr=0;

	geos2unix(msg);		/*convert to unix charset*/

	/*if .. and already at startup directory prevent going back further*/
	if(size<4 && msg[0]=='.' && msg[1]=='.'){
		getcwd(newdir,1024);
		if(strcmp(realcwd,newdir)==0){
			if(olddir[0]!='\0' && strcmp(olddir,realcwd)!=0){
				chdir(olddir);
				updatecwd();
				olddir[0]='\0';	/*finished with the backup dir*/
			}else
				size=1;		/*sets CD request to . */
			if(debug)
				printf("CD: attempt to go back too far\n");
		}
	}

	/*check to see if path is relative*/
	if(size>1 && msg[1]==':')
		strcpy(newdir,realcwd);
	else
		getcwd(newdir,1024);
	strcpy(&newdir[strlen(newdir)],"/");
	newdirst=strlen(newdir);
	for(a=0;a<size && msg[a]!='!';a++)
		newdir[newdirst+a]=msg[a];
	newdir[newdirst+a]='\0';		/*null terminate*/
	if(debug)
		printf("CD %s\n",&newdir[newdirst]);
	if(strcmp(&newdir[newdirst],".")!=0){	/*stay in the current directory*/
		fixfile(&newdir[newdirst]);
		if(newdir[strlen(newdir)-1]=='/')
			newdir[strlen(newdir)-1]='\0';
		cderr=chdir(newdir);
		/*if the directory doesn't exist try and create it*/
		if(cderr==-1){
			mkdir(newdir,0x1ff);
			cderr=chdir(newdir);
		}
		if(debug)
			printf("chdir %s %d\n",newdir,cderr);
		if(cderr==0)
			updatecwd();
	}else{
		/*reset back to the current dir in case an AUTO CD occured*/

	}
	send_RBACK();
	show_prompt();
}

void do_RE(unsigned char *msg){
	if(msg[0]!='*' && debug==0){
		geos2unix(msg);		/*convert to unix charset*/
		if(guimode)
			printf("%s\n",msg);
		else
			printf("NOKIA: %s\n",msg);
	}
	send_RBACK();
	show_prompt();
}

void do_EXIT(void){
	showconnect=1;
	if(debug){
		printf("Nokia Exit\n");
		exit(0);
	}
	send_RBACK();
}

void do_LM(unsigned char *msg,unsigned int size){
	/*List More - outputs a dos style long DIR listing*/
#ifdef SUN
	struct direct **namelist;	/*structure to hold the directory entries*/
#else
	struct dirent **namelist;	/*structure to hold the directory entries*/
#endif
	struct stat stats;		/*stats structure for getting modification times and sizes*/
	struct tm modtime;		/*Modification time structure so it can be split up*/
	int n;				/*counter for the number of items in the namelist*/
	unsigned int a,b,c;
	signed int hr;			/*used to hold the modified hour*/
	unsigned char ampm;		/*will hold 'a' for am or 'p' for pm*/
	unsigned int umode;		/*stores the mode flags of the file*/
	unsigned char fname[13];	/*store the current filename we are working on*/
	unsigned char fspec[13];	/*store an expanded wildcard search pattern*/
	unsigned char opbuf[BUF_SIZE];	/*output buffer*/
	unsigned char attribs[7];	/*buffer for dos style attribs*/
	unsigned char dirlines=0;	/*counter for the number of lines held in the buffer*/
	unsigned int modyear;		/*used to hold modification year*/

	send_RBACK();
	if(debug)
		printf("LM: ");
	/*read filespec from msg into fspec*/
	b=0;	/*offset for fspec*/
	for(a=0;a<12;a++)
		fspec[a]=' ';	/*pad fspec with spaces*/
	fspec[12]=0;		/*and null terminate*/
	fspec[0]='*';
	fspec[8]='.';
	fspec[9]='*';
	for(a=0;a<size && msg[a]!='!';a++){
		if(debug)
			printf("%c",msg[a]);
		if(msg[a]=='.')
			b=8-a;		/*calc the offset to ensure the dot is at fspec[8]*/
		if(msg[a]>='a' && msg[a]<='z')
			fspec[a+b]=msg[a]-32;	/*Ucase it*/
		else
			fspec[a+b]=msg[a];
	}
	if(debug)
		printf("\n");
	/*now expand * into multiple ?*/
	for(a=0;a<12;a++)
		if(fspec[a]=='*')
			if(a<8)
				for(;a<8;a++)
					fspec[a]='?';
			else if(a>8)
				for(;a<13;a++)
					fspec[a]='?';

	n=scandir(".",&namelist,0,alphasort);
	if(n<0){
		perror("scandir");
		return;
	}
	acknak=0;	/*this will be switched back on later*/
	sprintf(opbuf,"Directory of %s",curdir);
	for(a=0;a<n;a++){
		for(b=0;b<12;b++)
			fname[b]=' ';	/*pad with spaces*/
		fname[13]=0;		/*and terminate*/
		c=0;
		for(b=0;b<strlen(namelist[a]->d_name);b++){	/*expand fname for easy comparison*/
			if(namelist[a]->d_name[b]=='.')
				c=8-b;	/*calc offset*/
			if(namelist[a]->d_name[b]>='a' && namelist[a]->d_name[b]<='z')
				fname[b+c]=namelist[a]->d_name[b]-32;	/*Ucase it*/
			else
				fname[b+c]=namelist[a]->d_name[b];
		}

		/*support for files with no extensions:*/
		if(fname[8]!='.')
			fname[8]='.';

		c=0;	/*offset used to match the file extension*/
		for(b=0;b<12;b++){
			if(fname[b]=='.')
				c=8-b;	/*calc the offset*/
			if(fspec[b+c]!='?'){	/*if not a wildcard*/
				if(fspec[b+c]!=fname[b])
					break;		/*abort as it doesn't match*/
			}
			if(b==11){
				/*a match*/
				strncpy(fname,namelist[a]->d_name,12);	/*re copy the filename as we butchered it earlier*/
				fname[12]=0;
				stat(fname,&stats);	/*get useful file info*/
				modtime=*localtime(&stats.st_mtime);	/*modification time structure*/
				hr=modtime.tm_hour-1;	/*some 24 to 12 hour conversion*/
				if(hr>12){
					hr=hr-12;
					ampm='p';
				}else{
					ampm='a';
					if(hr==-1)
						hr=12;
				}
				umode=stats.st_mode;
				strcpy(attribs,"a-----");
				if(umode & 0x4000)		/*if it is a directory*/
					attribs[1]='d';
				/*sprintf split up to prevent core dump on FreeBSD*/
				unix2geos(fname);	/*convert to geos charset*/

				/*Y2K fix to prevent year 100*/
				modyear=modtime.tm_year;
				if(modyear>99)
					modyear=modyear-100;

				sprintf(&opbuf[strlen(opbuf)],"\012\015%-12s  %8ld %02d-%02d-%02d %2d:%02d%c ",fname,
				 stats.st_size,modtime.tm_mon+1,modtime.tm_mday,modyear,hr,modtime.tm_min,ampm);
				sprintf(&opbuf[strlen(opbuf)],"%s *NON_GEOS*",attribs);

				dirlines++;
				if(dirlines>=7){	/*send seven lines at a time*/
					if(debug)
						printf("%s",opbuf);
					sendMessage(opbuf,strlen(opbuf));
					opbuf[0]='\0';	/*trash the output buffer*/
					dirlines=0;	/*reset the counter*/
					noLFCR=1;	/*prevent any more of these being prefixed*/
				}
			}
		}
	}
	if(strlen(opbuf)>0 && dirlines>0){	/*if there are any lines left in the buffer send 'em*/
		if(debug)
			printf("%s\n",opbuf);
		sendMessage(opbuf,strlen(opbuf));
	}
	/*reset the flags we messed up etc*/
	acknak=1;
	cmdready=1;
	noLFCR=0;
}

void do_RK(void){
	if(debug)
		printf("RK\n");
	send_RBACK();
	/*I am not sure of this is what RK is for*/
	last_RBACK=0;
	last_HDR=1;
}

void do_FZ(void){
	if(debug)
		printf("FZ\n");
	send_RBACK();
	msgShift='Z';	/*notify processMSG that the next command is for file size*/
}

void do_FileSize(char *msg){
	struct stat stats;
	unsigned char size[4];		/*size is stored in 4 bytes LSB first*/
	unsigned long fsize;

	send_RBACK();
	geos2unix(msg);		/*convert geos to unix charset*/
	fixfile(msg);
	fixcase(msg);
	
	if(stat(msg,&stats)==-1){	/*if file not found*/
		/*the NOKIA assumes we are in the root dir
		  even though it may have changed dir*/
		getcwd(olddir,2048);	/*backup the cwd*/
		if(debug)
			printf("AUTO CD from %s\n",olddir);
		chdir(realcwd);
		updatecwd();
		if(stat(msg,&stats)==-1){
			fsize=0;
			if(debug)
				printf("Restoring directory to: %s\n",olddir);
			chdir(olddir);	/*restore the cwd*/
			updatecwd();
		}
		else
			fsize=stats.st_size;
	}else
		fsize=stats.st_size;
	if(debug)
		printf("FILE:%s FZ=%ld\n",msg,fsize);
	if(fsize==0){
		noLFCR=1;
		if(last_HDR==0)
			sendCode(NOKIA_NF1,8);
		else
			sendCode(NOKIA_NF2,8);
		noLFCR=0;
	}else{
		size[0]=fsize & 0xff;
		size[1]=(fsize & 0xff00)/0x100;
		size[2]=(fsize & 0xff0000)/0x10000;
		size[3]=(fsize & 0xff000000)/0x1000000;
		noLFCR=1;
		sendMessage_ACK(size,4);
		noLFCR=0;
	}
}

void pccommget(char *msg){
	/*send file msg to the Nokia*/
	struct stat stats;
	unsigned char buf[BUF_SIZE];
	unsigned long fsize;
	int fh;
	unsigned int a;
	unsigned int bytes=0;
	unsigned char retry=0;	/*retry flag*/

	send_RBACK();
	geos2unix(msg);		/*convert to unix charset*/
	fixfile(msg);
	fixcase(msg);

	/*open the file*/
	if((fh=open(msg,O_RDONLY))==-1){
		printf("Failed to open: %s\n",msg);
		return;		/*exit out if file cannot be opened*/
	}
	stat(msg,&stats);
	fsize=stats.st_size;

	if(debug)
		printf("sending file %s size:%ld\n",msg,fsize);
	if(guimode)
		printf("Sending file %s :\n",msg);

	noLFCR=1;

	if(debug)
		printf("sending NOKIA_SYNC\n");
	if(!sendMessage_ACK(NOKIA_SYNC,1)){		/*start code*/
		close(fh);
		return;
	}

	/*send the filename+size excluding path*/
	strcpy(buf,msg);	/*copy the full filespec first in case it has no path*/
	unix2geos(buf);		/*convert back to geos charset*/
	for(a=strlen(msg)-1;a>0;a--)
		if(msg[a]=='\\'){
			a++;
			strcpy(buf,&msg[a]);
			break;
		}
	/*now the size*/
	a=strlen(buf);
	buf[++a]=fsize & 0xff;
	buf[++a]=(fsize & 0xff00)/0x100;
	buf[++a]=(fsize & 0xff0000)/0x10000;
	buf[++a]=(fsize & 0xff000000)/0x1000000;
	if(debug)
		printf("sending filename and size\n");
	if(!sendMessage_ACK(buf,a+1)){
		close(fh);
		return;
	}

	usleep(500);	/*just wait a tick*/

	/*now send the file*/
	if(debug)
		printf("Now sending the file\n");
	a=1;
	do{
		if(retry==0)
			bytes=read(fh,buf,PKT_SIZE);
		else{
			retry=0;
		}
		if(bytes>0){
			a++;
			if(sendMessage_ACK(buf,bytes))
				fsize-=bytes;
			else{
				retry=1;
				a--;
			}
		}
		if(guimode==0){
			if(a>2)
				printf("\x0d%ld bytes left for %s...   ",fsize,msg);
		}
	}while(fsize>0);
	if(a>2 && guimode==0)
		printf("\n");
	if(debug)
		printf("eof\n");
	if(!sendMessage_ACK("\x00",1)){
		close(fh);
		return;
	}
	if(debug)
		printf("sent 0x02\n");
	sendMessage_ACK("\x02",1);
	noLFCR=0;

	/*finish*/
	close(fh);
	if(guimode){
		printf("*[up]*\n");
		printf("Sending file %s : Transfer successful.\n",msg);
	}
}

void do_XF01(){
	/*initiate system to commsend*/
	if(debug)
		printf("XF 0x01\n");
	send_RBACK();
	msgShift='X';
}

void pccommsend(unsigned char *msg){
	/*Receive file from the Nokia*/
	unsigned char buf[BUF_SIZE];
	unsigned long fsize;
	unsigned int a;
	unsigned int bufsize;
	int fh;
	unsigned int bytes;

	a=strlen(msg)+1;
	fsize=msg[a++];
	fsize+=msg[a++] * 0x100;
	fsize+=msg[a++] * 0x10000;
	fsize+=msg[a] * 0x1000000;

	geos2unix(msg);		/*convert geos to unix charset*/

	if(debug)
		printf("Receiving file: %s size:%ld\n",msg,fsize);
	if(guimode)
		printf("Receiving file %s :\n",msg);
	/*open file for output*/
	if((fh=open(msg,O_WRONLY | O_CREAT | O_TRUNC,S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH))==-1){
		printf("failed to create: %s\n",msg);
		return;
	}
	send_RBACK();
	while(fsize>0){
		if((bufsize=getMessage(buf))!=0)
			if(buf[0]!=NOKIA_CMD)
				bufsize=0;
			else{
				/*don't use stripMessage as it can trash the file if it contains a 0x95*/
				bufsize-=6;
				for(a=0;a<bufsize;a++)
					buf[a]=buf[a+2];
			}
		if(debug)
			printf("pkt: %d\n",bufsize);
		if(bufsize>0){
			bytes=write(fh,buf,bufsize);
			if(bytes<bufsize && debug)
				printf("failed to write %d bytes\n",bufsize);
			if(bufsize>fsize){
				if(debug)
					printf("error too many bytes received %d/%ld\n",bufsize,fsize);
				fsize=0;
			}else
				fsize-=bufsize;
			if(guimode==0){
				printf("\x0d%ld left for file %s...    ",fsize,msg);
				if(fsize==0)
					printf("\n");
			}
			send_RBACK();
		}
	}

	/*wait for next message (which should be 0x80)*/
	do{
		bufsize=getMessage(buf);
		if(bufsize>0)
			bufsize=stripMessage(buf,bufsize);
		if(bufsize==1 && buf[0]==0x80){
			send_RBACK();
			break;
		}else{
			if(debug){
				printf("Failed to get 0x80 message\n");
				for(a=0;a<bufsize;a++)
					printf(" %x",buf[a]);
				printf("\n");
			}
			break;
		}
	}while(1==1);
	close(fh);
	if(guimode){
		printf("*[up]*\n");
		printf("Receiving file %s : Transfer successful.\n",msg);
	}
}

void do_RB(void){
	if((showconnect!=0 || debug) && guimode==0)
		printf("NOKIA: connect\n");
	showconnect=0;
	noLFCR=0;
}

void do_freespace(char *msg,unsigned int size){
	unsigned char tmpBuf[1025];
	unsigned char drvletter;
	drvletter=curdir[0];
	if(msg[0]!='!')
		drvletter=msg[0];
	sprintf(tmpBuf,"%c: Free space: %d",drvletter,30000000);	/*pretend we have 30MB free*/
	if(debug)
		printf("%s\n",tmpBuf);
	send_RBACK();
	sendMessage(tmpBuf,strlen(tmpBuf));
	cmdready=1;
}

void do_esc(unsigned char *msg,unsigned int size){
	if(cmdCompare(msg,0,size,"RB",2)!=0)
		do_RB();
	else if(cmdCompare(msg,0,size,"RK",2)!=0)
		do_RK();
	else if(cmdCompare(msg,0,size,"EX",2)!=0)
		do_EXIT();
	else if(cmdCompare(msg,0,size,"EBon!",5)!=0)
		do_ebon();
	else if(cmdCompare(msg,0,size,"EBoff!",6)!=0)
		do_eboff();
	else if(cmdCompare(msg,0,size,"AKon!",5)!=0)
		do_akon();
	else if(cmdCompare(msg,0,size,"AKoff!",6)!=0)
		do_akoff();
	else if(cmdCompare(msg,0,size,"CD",2)!=0)
		do_CD(&msg[2],size-2);
	else if(cmdCompare(msg,0,size,"RE",2)!=0)
		do_RE(&msg[2]);
	else if(cmdCompare(msg,0,size,"LM",2)!=0)
		do_LM(&msg[2],size-2);
	else if(cmdCompare(msg,0,size,"FZ",2)!=0)
		do_FZ();
	else if(cmdCompare(msg,0,size,"XF\x04",3)!=0)
		pccommget(&msg[3]);
	else if(cmdCompare(msg,0,size,"XF\x01",3)!=0)
		do_XF01();
	else if(cmdCompare(msg,0,size,"FS",2)!=0)
		do_freespace(&msg[2],size-2);
	else
		showunknown(msg,size,"ESC");
}

void do_LF(void){
	send_RBACK();
}

void processMSG(unsigned char *msg,unsigned int size){
	/*determines which function to process the MSG*/
	if(msgShift==0){
		if(cmdCompare(msg,0,size,NOKIA_CMD1,4)!=0)
			do_cmd1();
		else if(cmdCompare(msg,0,size,NOKIA_CMD2,4)!=0)
			do_cmd2();
		else if(msg[0]==0x1b)
			do_esc(&msg[1],size-1);		/*strip off esc prefix*/
		else if(msg[0]==0x0a && size==1)
			do_LF();
		else
			showunknown(msg,size,"processMSG");
	}else{
		switch(msgShift){
			case 'Z':
				do_FileSize(msg);
				break;
			case 'X':	/*this section is not required any more but here just in case entropy strikes*/
				pccommsend(msg);
				break;
		}
		msgShift=0;
	}
}

void parseMessage(unsigned char *buf,unsigned int bufsize){
	/*the main message processing routine rev.2*/
	unsigned int a,b;
	char msg_buf[BUF_SIZE];		/*storage space for the message*/
	unsigned int msg_st;		/*starting point of the message*/
	unsigned int msg_en;		/*end point of the message*/

	msg_st=0;
	msg_en=0;
	b=0;

	/*moved here from processMSG because files size can contain 0x1b or 0x95*/
	if(msgShift=='X'){
		pccommsend(buf);
		msgShift=0;
		return;
	}

	if(buf[0]==NOKIA_CMD || buf[0]==0x1b)	/*ignore first char if it is one of these*/
		b=1;
	for(a=b;a<bufsize;a++){		/*start past the first char*/
		if(buf[a]==NOKIA_CMD || buf[a]==0x1b || a==bufsize-1){
			/*whole command found*/
			/*so copy it to msg_buf*/
			if(a==bufsize-1)
				msg_en=a;
			for(b=msg_st;b<=msg_en;b++)
				msg_buf[b-msg_st]=buf[b];
			processMSG(msg_buf,msg_en-msg_st+1);
			msg_st=a;
		}else
			msg_en=a;
	}
}

void nserverloop(void){		/*loop round waiting for the Nokia*/
	unsigned char buf[BUF_SIZE];		/*command buffer*/
	unsigned int bufsize=0;			/*command buffer size*/
	unsigned int a;

	if(guimode){
		printf("Version %s\n",VERSION);
		printf("Server session started on %s at %d baud.\n",port,speed);
		printf("Startup directory is %s\n",realcwd);
		printf("\n");
	}else
		printf("Nserver %s\n\n",VERSION);
	do{
		if((bufsize=getMessage(buf))!=0){
			/*message received*/
			bufsize=stripMessage(buf,bufsize);	/*remove encapsulation*/
			if(debug>1){
				printf("in-msg:");			/*debug code*/
				for(a=0;a<bufsize;a++)
					printf(" %x",buf[a]);
				printf("\n");
			}
			parseMessage(buf,bufsize);		/*process the message*/
		}
	}while(1==1);
}

int main(int argc, char *argv[]){
	unsigned int a;

	/*init*/
	strcpy(curdir,"C:\\NSERVER");	/*pretend that the startup dir is C:\NSERVER*/
	getcwd(realcwd,2048);		/*get the real cwd*/
	setbuf(stdout,NULL);
	init_charmap();			/*init character map converter*/
	olddir[0]='\0';

	/*command line support*/
	for(a=1;a<argc;a++){
		if(strlen(argv[a])>2){
			if(strcmp("--debug",argv[a])==0 || strcmp("-d1",argv[a])==0)
				debug=1;
			if(strcmp("-d2",argv[a])==0)
				debug=2;
			if(strcmp("-gui",argv[a])==0)
				guimode=1;
			if(strcmp("-port",argv[a])==0)
				if(a+1<argc)
					strcpy(port,argv[++a]);
			if(strcmp("-speed",argv[a])==0 || strcmp("-baud",argv[a])==0)
				if(a+1<argc)
					sscanf(argv[++a],"%d",&speed);
		}
	}
	if(guimode && debug)
		debug=0;	/*can't have debug mode when under GUI*/
	/*open the serial port*/
	porthandle=openport(port,speed);
	
	nserverloop();

	/*close down the serial port*/
	close(porthandle);
	return(0);
}