#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "opentcp.h"
#include "n3c.h"
#include "netComm.h"
#include "util.h"
#include "mcu_port.h"
#include "jtag.h"
#include "debug.h"
#include "commcode.h"
#include "datasink.h"
#include "ow.h"
#include "daq.h"

#define CMD_DNLD 0x646e6c64  
#define CMD_DELE 0x64656c65
#define CMD_LSFL 0x6c73666c
#define CMD_XPLY 0x78706c79
#define CMD_SPLY 0x73706c79
#define CMD_JPLY 0x6a706c79
#define CMD_EXIT 0x65786974
#define CMD_ABRT 0x61627274
#define	CMD_ERRO 0x6572726f
#define CMD_SCSS 0x73637373
#define CMD_LSDV 0x6c736476
#define CMD_PRNT 0x70726e74
#define CMD_PING 0x70696e67
#define CMD_PONG 0x706f6e67
#define CMD_DSHT 0x64736874
#define CMD_DSST 0x64737374
#define CMD_DSSP 0x64737370
#define CMD_DQRS 0x64717273
#define CMD_DQSU 0x64717375
#define CMD_TEST 0x74657374
#define CMD_JSVX 0x6a737678
#define CMD_JUSR 0x6a757372
#define CMD_JGEV 0x6a676576
#define CMD_OWAC 0x6f776163
#define CMD_OWAD 0x6f776164	
#define CMD_OWAR 0x6f776172
#define CMD_OWTC 0x6f777463
#define CMD_OWTD 0x6f777464
#define CMD_OWTR 0x6f777472
#define CMD_OWPC 0x6f777063
#define CMD_OWPR 0x6f777072
#define CMD_OWPS 0x6f777073
#define CMD_OWPI 0x6f777069
#define CMD_OWPD 0x6f777064
#define CMD_OWPP 0x6f777070
#define CMD_OWPA 0x6f777060
#define CMD_OWPE 0x6f777065
#define CMD_OWP1 0x6f777049
#define CMD_OWP0 0x6f777048
#define CMD_OWSS 0x6f777373
#define CMD_OWSG 0x6f777367

#define CMD_HBIN 0x6862696e
#define CMD_HSTP 0X68737470
#define CMD_HSET 0X68736574
#define CMD_HRUN 0X6872756e

//#define CMD_

#define MAX_PARAM_LEN		50
#define MAX_PARAMS			10
#define MAX_LABEL_LEN		11
#define MAX_STORED_BYTES	5*1024*1024
#define MAX_FILES			3
#define MAX_SENDBUF			1440									//max mss

struct{
	char    label[MAX_LABEL_LEN+1];
	int     size;
	char    *address;
}table[MAX_FILES];

struct node{
	struct node *next;
	char *data;
	//int length;
};

typedef struct node nodeType;

UINT8	netComm_enabled = 0;
INT8	mSocket=-1;


int		receivedBytes=0;
int		toReceiveBytes=0;
int		storedBytes=0;
int		isConActive=0;
char	*file=0;
char	label[MAX_LABEL_LEN + 1];
char	tmpBuf[MAX_SENDBUF];
char	sendBuf[MAX_SENDBUF + TCP_APP_OFFSET + 1];
char	*toSend=0;
int		toSendBytes=0;
int 	sentBytes=0;
int		lastSentBytes=0;

int hbd_init(void);
int hbd_run(int);
int hbd_stop(void);
int hbd_set(int,int);

nodeType *buffHead=NULL;
nodeType *buffTail=NULL;
char *buffToFreeStr=NULL;

// External
extern int datasink_active; //instantiated in datasink.c
extern int gUserRun;

INT8 netComm_init (void){
	INT8 soch = tcp_getsocket(TCP_TYPE_SERVER, TCP_TOS_NORMAL, TCP_DEF_TOUT, netComm_listener);
	mSocket = -1;

	if(soch < 0){
		DBG_PRINTL("netComm Server uncapable of getting socket\n");
		RESET_SYSTEM();
		return(-1);
	}
	
	mSocket=soch;
	soch = tcp_listen(mSocket, 1337);
	if(soch < 0){
		DBG_PRINTL("netComm Server uncapable of setting socket to listening mode\n");
		RESET_SYSTEM();
		return(-1);
	}
	
	storedBytes=0;
	
	file=NULL;
	receivedBytes = -1;
	toReceiveBytes = -1;
	
	sendBuf[MAX_SENDBUF + TCP_APP_OFFSET]='\0';
	toSendBytes=0;
	toSend=sendBuf+TCP_APP_OFFSET;
	sentBytes=0;
	lastSentBytes=0;

	isConActive=0;
	netComm_enabled  = 1;

	return(1);
}

void netComm_run (void){
	if(netComm_enabled == 0) return;
	if(tcp_getstate(mSocket) < TCP_STATE_LISTENING){
		DBG_PRINTL("Updating socket status to listen.\n");
		printf("Updating socket status to listen.\n");	
		tcp_listen(mSocket, 1337);
	}
	if(isConActive!=1) return;
	if(netComm_send()==0){
		DBG_PRINTL("send failed!\n");
		netComm_disconn();
	}
}

void netComm_fillBuffer(){
	char *outStr;
	DBG_PRINTL("Filling Buffer.\n");
	if(toSendBytes!=0) return; 										//buffer is not empty
	if(netComm_isBuffEmpty()) return;								//queue is empty
	outStr=netComm_buffPop();
	if(outStr==NULL) return;										//return is null. nothing to do
	toSendBytes=strlen(outStr);
	if(toSendBytes>MAX_SENDBUF){
		printl("SENDBUF IS TOO SHORT MESSAGE TRUNCATED; REWRITE netComm_fillBuffer\n");
	}
	DBG_PRINTL("BUFFER FILLED.\n");
	strncpy(toSend, outStr, MAX_SENDBUF);
}

/**
 *	returns:
 *		-1 when all data sent or there is no data to send
 *		0 when cant send any data
 *		1 when there is more data to send/ waiting for ack.
 *	THIS FUNCTION IS DANGEROUS CAN CAUSE RACE CONDITIONS; DONT CALL DIRECTLY
 **/
int netComm_send(void){
	char *str;
	if(lastSentBytes!=0){
		DBG_PRINTL("Last block not sent\n");
		return(-1);													//last block has not been sent
	}
	if(toSendBytes==0){
		if(netComm_isBuffEmpty()){
			return(-1);												//nothing to send
		}else{														//lets fetch next item from queue
			netComm_fillBuffer();
		}
	}
	if(sentBytes>=toSendBytes){										//transfer complete
		sentBytes=0;
		toSendBytes=0;
		toSend=sendBuf+TCP_APP_OFFSET;
		if(!netComm_isBuffEmpty()){									//try to fill up buffer from queue
			netComm_fillBuffer();
			if(toSendBytes<=0) return(-1);							//nothing in queue either
		}
		return(-1);
	}
	DBG_PRINTL("preparing send\n");
	lastSentBytes=tcp_send(mSocket, toSend+sentBytes, (UINT8)(toSendBytes-sentBytes), (UINT16)(MAX_SENDBUF-sentBytes));
	if(lastSentBytes<0){											//cant send data
		return(0);
	}
	DBG_PRINTL("data sent\n");
	return(1);
}

int netComm_netPrint(char *message){
	int len=0;
	len = strlen(message);
	if(!len) return(1);
	if(netComm_enabled==0) return(0);
	if(isConActive==0) return(0);									//no one to send data to
	if(*(message+len-1)=='\n'){
		len=snprintf(tmpBuf, MAX_SENDBUF, "prnt %s", message);
	}else{
		len=snprintf(tmpBuf, MAX_SENDBUF, "prnt %s\n", message);
	}
	if(len<0){
		return(0);
	}
	if(len>MAX_SENDBUF){
		printl("buffer too small or netprint too long");
	}
	netComm_buffPush(tmpBuf);
	return(1);
}

void netComm_eventReturn(int completion_code){
	if(completion_code<0){
		sprintf(tmpBuf, "erro %d\n", -completion_code);
		netComm_buffPush(tmpBuf);
		if(completion_code<=-1 && completion_code>=-5){
			printl("Significant error, disconnecting!\n");
			netComm_disconn();
		}
	}else if(completion_code>0){
		sprintf(tmpBuf, "scss %d\n", completion_code);
		netComm_buffPush(tmpBuf);
	}
}

UINT32 netComm_listener (INT8 cbhandle, UINT8 event, UINT32 par1, UINT32 par2){
	int i;
	if(netComm_enabled == 0)	return(-1);
	if(cbhandle < 0) return(-1);

	switch( event ){
		case TCP_EVENT_CONREQ:
			DBG_PRINTL("conn requested\n");
			if(isConActive!=0){
				printl("Connection is already active.\n");
				return(-1);
			}
			return(1);

		case TCP_EVENT_ABORT:
			DBG_PRINTL("conn aborted\n");
			netComm_disconn();
			return(1);

		case TCP_EVENT_CONNECTED:
			DBG_PRINTL("connected\n");
			isConActive=1;
			toSendBytes=0;
			return(1);

		case TCP_EVENT_CLOSE:
			DBG_PRINTL("connection closed\n");
			netComm_disconn();
			return(1);

		case TCP_EVENT_ACK:
			DBG_PRINTL("acked\n");
			sentBytes+=(int)lastSentBytes;
			lastSentBytes=0;	
			return(1);

		case TCP_EVENT_DATA:
			DBG_PRINTF("got data; process value: %d; ackno: %d\n", i, (int)par2-16777216);
			if(isConActive!=1){
				printl("Dumping packet.. ignoring traffic 'till reconnect");
				eth_stub_skip_buf(&fec_nif, (int)par1);
				return(-1);
			}
			i=netComm_processData((int)par1);
			netComm_eventReturn(i);	
			return(1);

		case TCP_EVENT_REGENERATE:
			DBG_PRINTL("regenarating packet");
			lastSentBytes=tcp_send(mSocket, toSend+sentBytes, (UINT16)(toSendBytes-sentBytes), (UINT16)(MAX_SENDBUF-sentBytes));
			return(1);
		default:
			return(-1);
	}

}

int netComm_processData(int len){
	long cmd=0;
	static char params[MAX_PARAM_LEN];
	static char *param[MAX_PARAMS];
	char *ptr,*ptrc,*ptrn;
	char stxt[80];
	int i=0, ii=0, nn=0, paramCount=0;
	unsigned int uitmp1, uitmp2, uitmp3, uitmp4, uitmp5;
	for(ii=0;ii<MAX_PARAMS;ii++) param[ii]=NULL;					//initialize parameter pointers
	DBG_PRINTL("processData called\n");	
			
	if(toReceiveBytes<=0){											//Its a command
		if(len<5){
			printf("too small to be a coommand; len: %d\n", len);
			return(ERRO_PROT);
		}
		cmd =   RECEIVE_NETWORK_B();
		cmd <<= 8;
		cmd |=  RECEIVE_NETWORK_B();
		cmd <<= 8;
		cmd |=  RECEIVE_NETWORK_B();
		cmd <<= 8;
		cmd |=  RECEIVE_NETWORK_B();
		
		if(RECEIVE_NETWORK_B()!=' '){								//does not follow protocol.
			printf("Violated protocol!\n got: %x \n", cmd);
			return(ERRO_PROT);
		}
		len-=5;

		printf("got: %x ", cmd);
		//Parse the parameters.
		for(i=0; i<MAX_PARAM_LEN && paramCount<MAX_PARAMS && i<len; i++){
			params[i]=RECEIVE_NETWORK_B();
			//printb(params[i]);
			if(params[i]=='\n'){
				params[i]='\0';
				break;
			}
			if(i==0){
				param[paramCount]=params;
				paramCount++;
			}else if (params[i]==' '){
				params[i]='\0';
				param[paramCount]=params+i+1;
				paramCount++;
			}
		}
		printl("\n");
		len-=i+1;
		printl("command ok\r\n");
		printl("args: ");printl(param[0]);
		printl(",");printl(param[1]);
		printl(",");printl(param[2]);
		printl(",");printl(param[3]);
		printl("\n"); 
		switch(cmd){
			case(CMD_DNLD):
				DBG_PRINTL("cmd: Download\n");
				if(paramCount!=2) return(ERRO_PROT);				//must have 2 parameters
				strcpy(label, param[0]);
				toReceiveBytes=(int)strtol(param[1], &ptr, 10);
				if(*ptr!='\0' || ptr==param[1]){					//second parameter must be integer
					toReceiveBytes=-1;	
					printl("Size is not int\n");
					return(ERRO_PROT);
				}
				if(!netComm_canAddFile(param[0])){					//too many files
					toReceiveBytes=-1;
					printl("Too many files\n");
					return (ERRO_2MNY);
				}
				if(storedBytes+toReceiveBytes>MAX_STORED_BYTES){	//file is too large
					toReceiveBytes=-1;
					printl("File too large\n");
					return(ERRO_STOR);
				}
				file=malloc(toReceiveBytes);
				if(file==NULL){										//Cannot allocate memory
					toReceiveBytes=-1;
					printl("Cannot allocate memory\n");
					return(ERRO_STOR);
				}
				DBG_PRINTF("expecting: %d bytes, received %d bytes\n", toReceiveBytes, receivedBytes);
				storedBytes+=toReceiveBytes;
				receivedBytes=len;
				eth_stub_read_buf(&fec_nif, file, len);
				if(receivedBytes==toReceiveBytes){					//if whole file fits in one packet save it and clean stuff up
					i=netComm_addFile(label, len, file);
					toReceiveBytes=-1;
					receivedBytes=-1;
					file=NULL;
					DBG_PRINTF("download finished. Added file with status %d\n", i);
					return(i);
				}else if(receivedBytes>toReceiveBytes){				//got more data than expecting, dumping
					DBG_PRINTF("toReceiveBytes: %d\n receivedBytes: %d\n len: %d\n", toReceiveBytes, receivedBytes, len);
					free(file);
					storedBytes-=toReceiveBytes;
					toReceiveBytes=-1;
					receivedBytes=-1;
					file=NULL;
					return(ERRO_FSZM);
				}
				DBG_PRINTL("Starting to save file\n");
				return(IGNR);
			case(CMD_DELE):
				if(paramCount!=1) return(ERRO_PROT);				//must have 1 parameter
				if(netComm_delFile(param[0])){
					return(SCSS_FDEL);
				}
				return(ERRO_NLBL);
			case(CMD_XPLY):
				if(paramCount!=2) return(ERRO_PROT);				//must have 2 parameters
				i=netComm_getIndex(param[0]);
				if(i<0){
					return(ERRO_NLBL);
				}
				return(jtag_xplay(table[i].address, table[i].size, param[1]));
			case(CMD_SPLY):
				if(paramCount!=2) return(ERRO_PROT);				//must have 2 parameters
				i=netComm_getIndex(param[0]);
				if(i<0){
					return(ERRO_NLBL);
				}
				return(jtag_splay(table[i].address, table[i].size, param[1]));
			case(CMD_JPLY):
				if(paramCount!=2) return(ERRO_PROT);				//must have 2 parameters
				i=netComm_getIndex(param[0]);
				if(i<0){
					return(ERRO_NLBL);
				}
				return(jtag_jplay(table[i].address, table[i].size, param[1]));
			case(CMD_LSFL):
				ii=sprintf(tmpBuf, "lsfl ");
				for(i=0; i<MAX_FILES; i++){
					if(table[i].size>0){
						ii+=sprintf(tmpBuf+ii, "%s(%i) ", 
						table[i].label,table[i].size);		
					}
				}
				if(toSendBytes==i){
					toSendBytes+=sprintf(tmpBuf+ii-1, "\n");
				}else{
					toSendBytes+=sprintf(tmpBuf+ii, "\n");
				}
				netComm_buffPush(tmpBuf);
				return(IGNR);	
			case(CMD_PING):
				DBG_PRINTL("COMMAND: ping\n");
				sprintf(tmpBuf, "pong \n");
				netComm_buffPush(tmpBuf);
				return(IGNR);
			case(CMD_PONG):
				DBG_PRINTL("pong\n");
				return(IGNR);
			case(CMD_LSDV):
				return jtag_autoconfig(param[0]);
			case(CMD_JUSR):
				return jtag_jusr(param[0],param[1]);
			case(CMD_JSVX):
				i=netComm_getIndex(param[0]);
				if(i<0) return(ERRO_NLBL);
				nn = table[i].size;
				
				// remove everything comments and illegal symbols
				ptr = table[i].address;
				ptrn=ptr+nn;
				for(ii=0,ptrc=ptr; ptrc<ptrn; ptrc++){
					if(ii) {if(*ptrc == 0xa) ii=0; continue;}
					if(*ptrc == '#') {ii=1; continue;}
					if(*ptrc!='0' && *ptrc!='1')continue;
					*ptr++ = *ptrc;
				}
				for(ptrc=ptr;ptrc<ptrn;) *ptrc++ = 0;
				// print out input	
				nn = ptr - table[i].address;
				sprintf(stxt,"loading %x(%x)\n",table[i].address,nn);
				printl(stxt);
				ptrc = table[i].address;
				ptrn = ptrc+nn;
				for(ptrc=table[i].address; ptrc<ptrn; ptrc+=ii)
				{
					ii = ptrn-ptrc; if(ii>64) ii = 64;
					memcpy(stxt,ptrc,ii);stxt[ii]=0;printl(stxt);printl("\n");
				}
				// allocate and initialize with '.' a shiftout buffer 
				ptr = malloc(nn);
				memset(ptr,'.',nn);

				// load stream
				jtag_load_svx(table[i].address, nn, ptr);
				sprintf(stxt,"loaded %x(%x)\n",ptr,nn);printl(stxt);
				//print out result
				for(ptrc=ptr,ptrn=ptr+nn; ptrc<ptrn; ptrc+=ii)
				{
					ii = ptrn-ptrc; if(ii>64) ii = 64;
					memcpy(stxt,ptrc,ii);stxt[ii]=0;printl(stxt);printl("\n");
				}
				free(ptr);
				return 0;
			case(CMD_JGEV):
				return jtag_jgev(param[0],param[1]);
			case(CMD_DSHT):
				DBG_PRINTL("COMMAND: dsht\n");
				if(paramCount!=2) return(ERRO_PROT);				//must have 2 parameters
				if(!datasink_initialized) return(ERRO_DSNI);
				DBG_PRINTF("datasink_initialized: %i\n", datasink_initialized);

				i=sscanf(param[0], "%x", &uitmp1);					//read in ip
				if(i!=1 || i==EOF){
					DBG_PRINTL("ERRO: cannot read ip\n");
					return(ERRO_PROT);
				}
																	//check ip to make sure its not localhost and such
				if(uitmp1==0 || uitmp1>=0xffffffff || (uitmp1>=0x7f000000 && uitmp1<=80000000))
					return (ERRO_DSHE);

				i=sscanf(param[1], "%u", &uitmp2);					//Read in port
				if(i!=1 || i==EOF){
					DBG_PRINTL("ERRO: cannot read port\n");
					return(ERRO_PROT);
				}
				if(uitmp2>=1024 && uitmp2<65535){					//check port range
					datasink_remip=(UINT32)uitmp1;
					datasink_remport=(UINT16)uitmp2;
					return(SCSS_DSHT);
				}else{
					DBG_PRINTL("ERRO: port out of valid range\n");
					return(ERRO_DSPE);
				}

			case(CMD_DSST):											//start data sinking
				//i=netComm_getIndex(param[0]);
				//if(i) i=param(0);
				if(!datasink_initialized) return(ERRO_DSNI);
				//if(uitmp1==0 || uitmp1>=0xffffffff || (uitmp1>=0x7f000000 && uitmp1<=80000000)) return (ERRO_DSHE);
				//if(datasink_remport<1024) return(ERRO_DSPE); //|| datasink_remport>65535) return(ERRO_DSPE);
				if(datasink_active) return(ERRO_DSST);
				datasink_active=1;
				daq_send_start_run(param[0]);
				return(SCSS_DSST);
			case(CMD_DSSP):											//stop data sinking
				if(!datasink_active) return(ERRO_DSSP);
				daq_send_stop_run();
				datasink_active=0;
				return(SCSS_DSSP);
			case(CMD_DQSU):
				daq_suspend();
				return(IGNR);
			case(CMD_DQRS):
				daq_resume(param[0]);
				return(IGNR);
			case(CMD_TEST):											//functions vary
				if(paramCount!=1) return(ERRO_PROT);				//must have 2 parameters
				i=netComm_getIndex(param[0]);
				if(i<0){
					return(ERRO_NLBL);
				}
				//return((table[i].address, table[i].size, param[1]));
				i=datasink_sendData(table[i].address, table[i].size);
				DBG_PRINTF("Datasink returned: %i",i);
				return(IGNR);
			case(CMD_EXIT):
			case(CMD_ABRT):
				printl("Exit to dBUG is scheduled.\n");
				printl("To return back - use 'go' dBUG command.\n");
				netComm_netPrint("The target is going offline! Only serial connection will be active. To return back use 'go' command in dBUG."); 
				gUserRun |= RUN_DBUG;
				return(IGNR);
			case(CMD_OWAC):
				DBG_PRINTF("paramCount: %i",paramCount);
				//if(paramCount!=4||paramCount!=5){
				//	return(ERRO_PROT);
				//}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				sscanf(param[2], "%u", &uitmp3);
				sscanf(param[3], "%u", &uitmp4);
				if(paramCount==5){
					sscanf(param[4], "%x", &uitmp5);
				}else{
					uitmp5=0;
				}
				switch(OWD_ADCConfChan((uint8)uitmp1, (uint8)uitmp2, uitmp3, uitmp4, uitmp5)){
					case -1:
						return(ERRO_OWPAR);
					case 0:
						return(ERRO_OWCMD);
					case 1:
						return(SCSS_OWCMD);
					default:
						return(ERRO_UNKNW);
				}
			case(CMD_OWAD):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				if(OWD_ADCConv((uint8)uitmp1, (uint8)uitmp2)){
					return(SCSS_OWCMD);
				}else{
					return(ERRO_OWCMD);
				}
			case(CMD_OWAR):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				if(OWD_ADCReadAll((uint8)uitmp1, uitmp2, &uitmp1, &uitmp2, &uitmp3, &uitmp4)==1){
					sprintf(tmpBuf, "owap %u %u %u %u\n", uitmp1, uitmp2, uitmp3, uitmp4);
					netComm_buffPush(tmpBuf);
					return(IGNR);
				}else{
					return(ERRO_OWCMD);
				}
			case(CMD_OWPC):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[0], "%u", &uitmp2);
				switch(OWD_POTConf(uitmp1, uitmp2, 1)){
					case -1:
						return(ERRO_OWPAR);
					case 0:
						return(ERRO_OWCMD);
					case 1:
						return(SCSS_OWCMD);
				}
			case(CMD_OWPR):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				i=OWD_POTget(uitmp1, uitmp2);
				if(i<0){
					return(ERRO_OWCMD);
				}else{
					sprintf(tmpBuf, "owpp %i\n", i);
					netComm_buffPush(tmpBuf);
					return(IGNR);
				}
			case(CMD_OWPS):
				if(paramCount!=3){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				sscanf(param[2], "%u", &uitmp3);
				if(uitmp3<0||uitmp3>255){
					return(ERRO_CMDERR);
				}
				switch(OWD_POTset(uitmp1, uitmp2, uitmp3)){
					case -1:
						return(ERRO_OWPAR);
					case 0:
						return(ERRO_OWCMD);
					case 1:
						return(SCSS_OWCMD);
					default:
						return(ERRO_OWCMD);
				}
			case(CMD_OWPI):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				i=OWD_POTincr(uitmp1, uitmp2);
				if(i<0){
					return(ERRO_OWCMD);
				}else{
					sprintf(tmpBuf, "owpi %i\n", i);
					netComm_buffPush(tmpBuf);
					return(IGNR);
				}
			case(CMD_OWPD):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				i=OWD_POTdecr(uitmp1, uitmp2);
				if(i<=0){
					return(ERRO_OWCMD);
				}else{
					sprintf(tmpBuf, "owpd %i\n", i);
					netComm_buffPush(tmpBuf);
					return(IGNR);
				}
			case(CMD_OWPP):
				OWD_POTClimbPurge();
				return(SCSS_OWCMD);
			case(CMD_OWPA):
				DBG_PRINTF("paramCount: %i",paramCount);
				//if(paramCount!=4){
				//	return(ERRO_PROT);
				//}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				sscanf(param[2], "%u", &uitmp3);
				sscanf(param[3], "%u", &uitmp4);
				i=OWD_POTClimbAdd(uitmp1, uitmp2, uitmp3, uitmp4);
				sprintf(tmpBuf, "owpa %i\n", i);
				netComm_buffPush(tmpBuf);
				return(IGNR);
			case(CMD_OWPE):
				i=OWD_POTClimbInit();
				sprintf(tmpBuf, "owpc %i\n", i);
				netComm_buffPush(tmpBuf);
				return(IGNR);
			case(CMD_OWP1):
				OWD_POTClimbStart();
				return(SCSS_OWCMD);
			case(CMD_OWP0):
				OWD_POTClimbStop();
				return(SCSS_OWCMD);
			case(CMD_OWTC):
				if(paramCount<2 || paramCount>3){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				if(paramCount==3){
					sscanf(param[2], "%u", &uitmp3);
					if(uitmp3>4){
						return(ERRO_CMDERR);
					}
				}else{
					uitmp3=4;
				}
				switch(OWD_THMconf(uitmp1, uitmp2, uitmp3)){
					case -1:
						return(ERRO_OWPAR);
					case 0:
						return(ERRO_OWCMD);
					case 1:
						return(SCSS_OWCMD);
				}
			case(CMD_OWTD):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[0], "%u", &uitmp2);
				switch(OWD_THMconv(uitmp1, uitmp2)){
					case -1:
						return(ERRO_OWPAR);
					case 0:
						return(ERRO_OWCMD);
					case 1:
						return(SCSS_OWCMD);
				}
			case(CMD_OWTR):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				i=OWD_THMget(uitmp1, uitmp2);
				if(i<0){
					return(ERRO_OWCMD);
				}else{
					sprintf(tmpBuf, "owtr %i\n", i);
					netComm_buffPush(tmpBuf);
					return(IGNR);
				}
			case(CMD_OWSS):
				if(paramCount!=4){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				sscanf(param[1], "%u", &uitmp2);
				sscanf(param[2], "%u", &uitmp3);
				sscanf(param[3], "%u", &uitmp4);
				if(uitmp3>1 || uitmp4>1){
					return(ERRO_CMDERR);
				} 
				i=OWD_SWCHset(uitmp1, uitmp2, uitmp3, uitmp4);
				if(i>0){
					return(SCSS_OWCMD);
				}else{
					return(ERRO_OWCMD);
				}
			case(CMD_OWSG):
				if(paramCount!=2){
					return(ERRO_PROT);
				}
				sscanf(param[0], "%u", &uitmp1);
				if(uitmp1<0||uitmp1>3){
					return(ERRO_CMDERR);
				}
				i=OWD_THMget(uitmp1, uitmp2);
				if(i<0){
					return(ERRO_OWCMD);
				}else{
					sprintf(tmpBuf, "owsg %i\n", i);
					netComm_buffPush(tmpBuf);
					return(IGNR);
				}
                        case(CMD_HBIN):
                                i=hbd_init();
                                return(i);
                        case(CMD_HSET):
                                i=hbd_set(10,10);
                                return(i);
                        case(CMD_HRUN):
                                i=hbd_run(10);
                                return(i);
                        case(CMD_HSTP):
                                i=hbd_stop();
                                return(i);
                                                    					//unimplemented command
			default:												//unknown command
				return(ERRO_PROT);
		}
	}else if(file!=NULL){											//Dumping data to "file"
		DBG_PRINTL("file packet\n");
		if(len+receivedBytes<toReceiveBytes){
			eth_stub_read_buf(&fec_nif, file+receivedBytes, len);
			receivedBytes+=len;
			DBG_PRINTL("stored file segment\n");
			return(IGNR);											//Uneventfull (packet handeled)
		}else if(len+receivedBytes==toReceiveBytes){
			eth_stub_read_buf(&fec_nif, file+receivedBytes, len);
			i=netComm_addFile(label, len+receivedBytes, file);
			toReceiveBytes=-1;
			receivedBytes=-1;
			file=NULL;
			DBG_PRINTL("Finished downloading file\n");
			return(i);
		}else{														//got more data than expecting. Dumping
			DBG_PRINTF("toReceiveBytes: %d\n receivedBytes: %d\n len: %d\n", toReceiveBytes, receivedBytes, len);
			free(file);
			storedBytes-=toReceiveBytes;
			toReceiveBytes=-1;
			receivedBytes=-1;
			file=NULL;
			DBG_PRINTL("ERROR, removing file\n");
			return(ERRO_FSZM);
		}
	}
}

int netComm_disconn (void){
	isConActive=0;
	while(netComm_send()==1);										//send remaining data (flush send buffer)
	DBG_PRINTF("Bytes Received: %d; Bytes Sent: %d\n", receivedBytes, sentBytes);
	sentBytes=0;
	lastSentBytes=0;
	receivedBytes=0;
	toSendBytes=0;
	tcp_abort(mSocket);
}

int netComm_addFile(char *label, int size, char *address){
	int i, empty;
	if(address==NULL || size==-1){
		return(ERRO_STOR);
	}
	for(i=0, empty=-1; i<MAX_FILES; i++){
		if(table[i].size<=0 && table[i].address==NULL && empty==-1){
			empty=i;
		}else if(strcmp(table[i].label, label)==0){
			break;
		}
	}
	if(i!=MAX_FILES){                    							//collision, replacing old
		free(table[i].address);
		storedBytes-=table[i].size;
		strcpy(table[i].label, label);
		table[i].size=size;
		table[i].address=address;
		return(SCSS_FREP);
	}else if(empty>=0){  			               					//adding new
		strcpy(table[empty].label, label);
		table[empty].size=size;
		table[empty].address=address;
		return(SCSS_FSTR);
	}
	return (ERRO_2MNY);                        						//cannot add more files
}

int netComm_canAddFile(char *label){
	int i;
	for(i=0; i<MAX_FILES; i++){
		if(table[i].address==NULL || strcmp(table[i].label, label)==0){
			return 1;
		}
	}
	return 0;
}


int netComm_getIndex(char *label){
	int i;
	for(i=0; i<MAX_FILES; i++){
		if(strcmp(table[i].label, label)==0 && table[i].size>=0 && table[i].address!=NULL){
			return(i);
		}
	}
	return (ERRO_NLBL);
}

int netComm_delFile(char *label){
    int i;
    i=netComm_getIndex(label);
    if(i>0){
        free(table[i].address);
		storedBytes-=table[i].size;
        table[i].address=NULL;
        table[i].size=-1;
        return(1);
    }
    return(i);
}

int netComm_buffPush(char *str){
	nodeType *element;
	char *data;
	int length=strlen(str);
	DBG_PRINTL("pushing to buffer\n");
	if(str==NULL){
		DBG_PRINTL("refuse to push NULL char pointers\n");
		return(0);
	}
	element=malloc(sizeof(struct node));
	if(element==NULL){
		printl("cannot allocate memory for node\n");
		return(0);
	}
	data=malloc(length);
	if(data==NULL){
		printl("cannot allocate memory for string\n");
		return(0);
	}
	strcpy(data, str);
	element->next=NULL;
	element->data=data;
	//element->length=length;
	if(buffTail==NULL){
		buffHead=element;
		buffTail=element;
	}else{
		buffTail->next=element;
		buffTail=element;
	}
	DBG_PRINTL("pushed\n");
	return 1;
}

/**
 * Takes the top element of queue and returns pointer to it. The data is freed
 * the next time this function is called. And should not be freed by the user.
 **/
char* netComm_buffPop(){
	char *str;
	DBG_PRINTL("buffer popped\n");
	if(buffToFreeStr!=NULL){
		free(buffToFreeStr);
		buffToFreeStr=NULL;
	}
	if(buffHead==NULL){
		DBG_PRINTL("queue is empty\n");
		return(NULL);
	}
	nodeType *next;
	buffToFreeStr=buffHead->data;
	str=buffHead->data;
	next=buffHead->next;
	free(buffHead);
	buffHead=next;
	if(buffHead==NULL){
		buffTail=NULL;
	}
	return str;
}

int inline netComm_isBuffEmpty(){
	return buffHead==NULL;
}