/*
*	  TOOLS.C
*
****************************************************************************
*																			*
*	  part of:																*
*	  TCP/IP kernel for NCSA Telnet									  		*
*	  by Tim Krauskopf														*
*																			*
*	  National Center for Supercomputing Applications						*
*	  152 Computing Applications Building									*
*	  605 E. Springfield Ave.												*
*	  Champaign, IL  61820													*
*																		 	*
*     This program is in the public domain.                                 *
*                                                                           *
****************************************************************************
*
*  Portions of the driver code that are not specific to a particular protocol
*
*/
#include <stdio.h>
#include <string.h>
#include "protocol.h"
#include "data.h"
#include "externs.h"

extern int ftpdata;						/* current ftp data port */

static char *get_name(int port);		/* returns name of a port */
static char *find_port(int port);


int pingtransq(struct port *prt);   /* CGW - 2/10/93 */
int transp(struct port *prt);       /* CGW - 2/11/93 */



/************************************************************************/
/*  netsleep
*	  sleep, while demuxing packets, so we don't miss anything
*
*/
int CDECL netsleep(int n)
{
  unsigned int u;
  int i,nmux,redir;
	int32 t,gt,start;
  struct port *p, **q;
	uint8 *pc;

	redir=0;
    start=n_clicks();

	if(n)
		t=start+n*TICKSPERSEC;
	else
		t=start;

	do {
    nmux=demux(1);        /* demux all packets */

/*
*  if there were packets in the incoming packet buffer, then more might
*  have arrived while we were processing them.  This gives absolute priority
*  to packets coming in from the network.
*/
		if(nmux)
			continue;
/*
*  Check for any ICMP redirect events.
*/
    if(IREDIR==netgetevent(ICMPCLASS,&i,&i))
			redir=1;
/*
*  Check each port to see if action is necessary.
*  This now sends all Ack packets, due to p->lasttime being set to 0L.
*  Waiting for nmux==0 for sending ACKs makes sure that the network
*  has a much higher priority and reduces the number of unnecessary ACKs.
*/
    gt=n_clicks();
    q=&portlist[0];
    for(u=0; u<NPORTS; u++,q++) {
      p=*q;
      if((p!=NULL) && (p->state>SLISTEN)) {
        if(!p->out.lasttime)
          transq(p);        /* takes care of all ACKs */
        else
          if((p->out.contain>0) || (p->state>SEST)) {
/*
*  if a retransmission timeout occurs, exponential back-off.
*  This number returns toward the correct value by the RTT measurement
*  code in ackcheck.
*
*  fix: 5/12/88, if timer was at MAXRTO, transq didn't get hit - TK
*/
            if((p->out.lasttime+p->rto)<gt) {
              if(p->rto<MAXRTO)
								p->rto<<=1;		/* double it */
#ifdef AUX /* RMG */
              fprintf(stdaux,"retrans ");
#endif

#ifdef OLD_WAY
              transq(p);
#else                   /* CGW - 2/10/93 */
              transp(p);
#endif
            }
          }
          if((p->out.lasttime+POKEINTERVAL<gt) && (p->state==SEST))
            transq(p);
/*
*  check to see if ICMP redirection occurred and needs servicing.
*  If it needs servicing, try to get the new hardware address for the new 
*  gateway.  If getdlayer fails, we assume an ARP was sent, another ICMP
*  redirect will occur, this routine will reactivate, and then the hardware
*  address will be available in the cache.
*  Check all ports to see if they match the redirected address.
*/
          if(redir && comparen(p->tcpout.i.ipdest,nnicmpsave,4)) {
            pc=getdlayer(nnicmpnew);
            if(pc!=NULL)
              movebytes(p->tcpout.d.dest,pc,DADDLEN);
          } /* end if */
      } /* end if */
    } /* end for */
		redir=0;				/* reset flag for next demux */
  } while((t>n_clicks()) && (n_clicks()>=start));  /* allow for wraparound of timer */

	return(nmux);				/* will demux once, even for sleep(0) */
}


/***************************************************************************/
/*  enqueue
*   add something to a TCP queue.  Used by both 'write()' and tcpinterpret
*   WINDOWSIZE is the size limitation of the advertised window.
*/
int enqueue(struct window *wind,char *buffer,int nbytes)
{
	int i;

	i=WINDOWSIZE-wind->contain;
	if(i<=0 || nbytes==0)
		return(0);						/* no room at the inn */
	if(nbytes>i)
		nbytes=i;
	i=wind->where-wind->endlim;		/* room at end */
	i+=WINDOWSIZE;
	if(i<nbytes) {
		movebytes(wind->endlim,buffer,i);
		movebytes(wind->where,(char *)(buffer+i),nbytes-i);
		wind->endlim=wind->where+nbytes-i;
  }
	else {
		movebytes(wind->endlim,buffer,nbytes);		/* fits in one chunk */
		wind->endlim+=nbytes;
  }
	wind->contain+=nbytes;			/* more stuff here */
	return(nbytes);
}

/*************************************************************************/
/* dequeue
*	 used by read, this copies data out of the queue and then
*  deallocates it from the queue.
*  cpqueue and rmqueue are very similar and are to be used by tcpsend
*  to store unacknowledged data.
*
*  returns number of bytes copied from the queue
*/
int dequeue(struct window *wind,char *buffer,int nbytes)
{
	int i;

	if(wind->contain==0)
		return(0);
	if((wind->contain)<(uint)nbytes)
		nbytes=wind->contain;
	i=wind->endbuf-wind->base;
	if(i<=nbytes) {
		movebytes(buffer,wind->base,i);
		movebytes((char *)(buffer+i),wind->where,nbytes-i);
		wind->base=wind->where+nbytes-i;
  }
	else {
		movebytes(buffer,wind->base,nbytes);
		if((wind->contain)==(uint)nbytes) 
			wind->base=wind->endlim=wind->where;
		else
			wind->base+=nbytes;
  }
	wind->contain-=nbytes;
	return(nbytes);
}

/**************************************************************************/
/*  rmqueue
*	 does the queue deallocation that is left out of cpqueue
*
*   rmqueue of WINDOWSIZE or greater bytes will empty the queue
*/
int rmqueue(struct window *wind,int nbytes)
{
	int i;

	if((wind->contain)< (uint)nbytes)
		nbytes=wind->contain;
	i=wind->endbuf-wind->base;
	if(i<=nbytes) 
		wind->base=wind->where+nbytes-i;
	else {
		if((wind->contain)==(uint)nbytes)
			wind->base=wind->endlim=wind->where;
		else
			wind->base+=nbytes;
  }
	wind->contain-=nbytes;
	return(nbytes);
}

/************************************************************************/
/*  transq
*
*   Needed for TCP, not as general as cpqueue, 
*   but is required for efficient transmit of the whole window.
*
*   Transmit the entire queue (window) to the other host without expecting
*   any sort of acknowledgement.
*
*/
int transq(struct port *prt)
{
	uint bites;
	unsigned int i,j,n;
	struct window *wind;
	uint32 saveseq;
	uint8 *endb,*whereb,*baseb;

	if(prt==NULL) {
		nnerror(406);		/* NULL port for trans */
		return(-1);
  }
	wind=&prt->out;
/*
*   find out how many bytes the other side will allow us to send (window)
*/
	bites=wind->size;
	if(wind->contain<bites)
		bites=wind->contain;
/*
*  set up the tcp packet for this, ACK field is same for all packets
*/
	prt->tcpout.t.ack=longswap(prt->in.nxt);
/*
*  any more flags should be set?
*/
	if(wind->push && (bites>0))					/* is push indicator on? */
		prt->tcpout.t.flags|=TPUSH;
	else
		prt->tcpout.t.flags&=~TPUSH;		/* else clear push */
  /* we never set push flag unless we are actually sending data */
	if((bites<=0) || prt->state!=SEST) {	/* if no data to send . . . */
		tcpsend(prt,0);				/* just a retransmission or ACK */
		return(0);
  }
/*
 *  we have data to send, get the correct sequence #'s
 *  To be really real, we should check wraparound sequence # in the loop.
 */
	saveseq=wind->nxt;
	whereb=wind->where;
	endb=wind->endbuf;
	baseb=wind->base;
/*
 *  in a loop, transmit the entire queue of data
 */
	for(i=0; i<bites; i+=prt->sendsize) {
		n=prt->sendsize;
		if(i+n>bites)
			n=bites-i;
		j=endb-baseb;
		if(j<n) {
			movebytes(prt->tcpout.x.data,baseb,j);
			movebytes((char *)(prt->tcpout.x.data+j),whereb,n-j);
			baseb=whereb+n-j;
    }
    else {
      movebytes(prt->tcpout.x.data,baseb,n);
			baseb+=n;
    }
		tcpsend(prt,n);						/* send it */
		wind->nxt+=n;
  } /* end for */
	wind->nxt=saveseq;					/* get back first seq # */
	return(0);
}

/************************************************************************/
/*  transp
*
*   Transmit one packet, instead of the entire queue (window), to the
*   other host without expecting any sort of acknowledgement.
*
*/
int transp(struct port *prt) {
	uint bites;
	unsigned int i,j,n;
	struct window *wind;
	uint32 saveseq;
	uint8 *endb,*whereb,*baseb;

	if(prt==NULL) {
		nnerror(406);		/* NULL port for trans */
		return(-1);
  }
	wind=&prt->out;
/*
*   find out how many bytes the other side will allow us to send (window)
*/
  bites=prt->sendsize;
	if(wind->contain<bites)
		bites=wind->contain;
/*
*  set up the tcp packet for this, ACK field is same for all packets
*/
	prt->tcpout.t.ack=longswap(prt->in.nxt);
/*
*  any more flags should be set?
*/
	if(wind->push && (bites>0))					/* is push indicator on? */
		prt->tcpout.t.flags|=TPUSH;
	else
		prt->tcpout.t.flags&=~TPUSH;		/* else clear push */
  /* we never set push flag unless we are actually sending data */
	if((bites<=0) || prt->state!=SEST) {	/* if no data to send . . . */
		tcpsend(prt,0);				/* just a retransmission or ACK */
		return(0);
    }
/*
 *  we have data to send, get the correct sequence #'s
 *  To be really real, we should check wraparound sequence # in the loop.
 */
	saveseq=wind->nxt;
	whereb=wind->where;
	endb=wind->endbuf;
	baseb=wind->base;
/*
 *  transmit the next packet of data
 */
    n=bites;
    j=endb-baseb;
    if(j<n) {
        movebytes(prt->tcpout.x.data,baseb,j);
        movebytes((char *)(prt->tcpout.x.data+j),whereb,n-j);
        baseb=whereb+n-j;
    } else {
        movebytes(prt->tcpout.x.data,baseb,n);
        baseb+=n;
    }
    tcpsend(prt,n);                     /* send it */
	wind->nxt=saveseq;					/* get back first seq # */
	return(0);
}

/************************************************************************/
/*  netposterr
*   place an error into the event q
*   Takes the error number and puts it into the error structure
*/
void netposterr(int num)
{
	if(netputevent(ERRCLASS,ERR1,num))
		netputuev(ERRCLASS,ERR1,501);			/* only if we lost an event */
}

/***********************************************************************/
/*  netgetevent
*   Retrieves the next event (and clears it) which matches bits in
*   the given mask.  Returns the event number or -1 on no event present.
*   Also returns the exact class and the associated integer in reference
*   parameters.
*
*   The way the queue works:
*	 There is always a dummy record pointed to by nnelast.
*	 When data is put into the queue, it goes into nnelast, then nnelast
*		looks around for another empty one to obtain.
*		It looks at nnefree first, then bumps one from nnefirst if necessary.
*	 When data is retrieved, it is searched from nnefirst to nnelast.
*		Any freed record is appended to nnefree.
*/
int netgetevent(uint8 mask,int *retclass,int *retint)
{
	int i,j=0;

	i=nnefirst;
	while(i!=nnelast) {
		if(mask&nnq[i].eclass) {
			if(i==nnefirst) 
				nnefirst=nnq[nnefirst].next;		/* step nnefirst */
			else 
				nnq[j].next=nnq[i].next;			/* bypass record i */
			nnq[i].next=nnefree;
			nnefree=i;							/* install in free list */
			*retint=nnq[i].idata;
			*retclass=nnq[i].eclass;
			return((int)nnq[i].event);
		  }
		j=i;
		i=nnq[i].next;
	  }
	return(0);
}

/***********************************************************************/
/*  netputevent
*   add an event to the queue.
*   Will probably get the memory for the entry from the free list.
*   Returns 0 if there was room, 1 if an event was lost.
*/
int netputevent(int class,int what,int dat)
{
	int i;

	i=nnelast;
	nnq[i].eclass=(uint8)class;					/* put data in */
	nnq[i].event=(uint8)what;
	nnq[i].idata=dat;
	if(nnefree>=0) {						/* there is a spot in free list */
		nnq[i].next=nnelast=nnefree;
		nnefree=nnq[nnefree].next;		/* remove from free list */
		return(0);
	  }
	else {
		nnq[i].next=nnelast=nnefirst;
		nnefirst=nnq[nnefirst].next;		/* lose oldest event */
		return(1);
	  }
}

/***************************************************************************/
/*  netputuev
*   put a unique event into the queue
*   First searches the queue for like events
*/
int netputuev(int class,int what,int dat)
{
	int i;

	i=nnefirst;
	while(i!=nnelast) {
		if(nnq[i].idata==dat && nnq[i].event==(uint8)what && nnq[i].eclass==(uint8)class)
			return(0);
		i=nnq[i].next;
	  }
	return(netputevent(class,what,dat));
}

/************************************************************************/
/*  neterrstring
*   returns the string associated with a particular error number
*
*   error number is formatted %4d at the beginning of the string
*/
#ifndef NET14
static char *errs[]={
	"   0 Error unknown",
	" 100 Network jammed, probable break in wire",
	" 101 Could not initialize hardware level network driver",
	" 102 ERROR: The conflicting machine is using the same IP number",
	" 103 RARP request failed, an IP number is required",
	" 300 Bad IP checksum",
	" 301 IP packet not for me",
	" 302 IP packet with options received",
	" 303 IP: unknown higher layer protocol",
	" 304 IP: fragmented packet received, frags not supported",
	" 400 TCP: bad checksum",
	" 401 ACK invalid for TCP syn sent",
	" 403 TCP in unknown state",
	" 404 Invalid port for TCPsend",
	" 405 TCP connection reset by other host",
	" 406 Null port specified for ackandtrans",
	" 407 Packet received for invalid port -- reset sent",
	" 500 No internal TCP ports available",
	" 501 Warning: Event queue filled, probably non-fatal",
	" 504 Local host or gateway not responding",
	" 505 Memory allocation error, cannot open port",
	" 506 Not allowed to connect to broadcast address",
	" 507 Reset received: syn sent, host is refusing connection",
	" 600 ICMP:	Echo reply",
	" 603 ICMP:	Destination unreachable",
	" 604 ICMP:	Source Quench",
	" 605 ICMP:	Redirect, another gateway is more efficient",
	" 608 ICMP:	Echo requested (ping requested)",
	" 611 ICMP:	Time Exceeded on Packet",
	" 612 ICMP:	Parameter problem in IP",
	" 613 ICMP:	Timestamp request",
	" 614 ICMP:	Timestamp reply",
	" 615 ICMP:	Information request",
	" 616 ICMP:	Information reply",
	" 699 ICMP: Checksum error",
	" 700 Bad UDP checksum",
	" 800 Domain: Name request to server failed",
	" 801 Domain: Using default domain",
	" 802 Domain: name does not exist",
	" 803 Domain: UDP name server did not resolve the name",
	" 804 Domain: name server failed, unknown reason",
	" 805 Host machine not in configuration file",
	" 806 Missing IP number, requires domain lookup",
	" 900 Session: Cannot find or open configuration file",
	" 901 Session: Cannot allocate memory for processing",
	" 902 Session: Invalid keyword in configuration file",
	" 903 Session: Element too long (>200), maybe missing quote",
	" 904 Session: Probable missing quote marks, a field must be on one line",
	" 905 Session: 'name' field required before other machine entries",
	" 906 Session: Syntax error, invalid IP number",
	" 907 Session: Syntax error, Subnet mask invalid",
	" 908 Session: Syntax error, IP address for this PC is invalid",
	""};
#endif

static char errspace[80];		/* room for user-defined errors */

char *neterrstring(int errno)
{
	int i;
	char s[10];

    if(errno<0)
		return(errspace);
#ifndef NET14
	sprintf(s,"%4d",errno);
	i=0;
	do {
		if(!strncmp(errs[i],s,4))
			return(errs[i]+5);			/* pointer to error message  */
		i++;
      } while(*errs[i] || i>100);       /* until NULL found */
	return(errs[0]+5);					/* error unknown */
#endif
}