/*
*	PROTINIT.C
*
*	Packet template initialization routines
*
****************************************************************************
*                                                                          *
*      part of:                                                            *
*      TCP/UDP/ICMP/IP Network 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.                               *
*                                                                          *
****************************************************************************
*   'protinit' initializes packets to make them ready for transmission.
*   For many purposes, pre-initialized packets are created for use by the
*   protocol routines, especially to save time creating packets for
*   transmit.
*
*	Important note :  Assumes that the hardware has been initialized and has
* set all the useful addresses such as the hardware addresses.
*
*   As this is a convenient place for it, this file contains many of the
*   data declarations for packets which are mostly static (pre-allocated).
*	Revision history:
****************************************************************************
*
*	10/87  Initial source release, Tim Krauskopf
*	5/88	clean up for 2.3 release, JKM	
*
*/

/*
 *	Includes
 */

#include <stdio.h>
#include <stdlib.h>
#if defined(MSC)
#ifdef __TURBOC__
#include <alloc.h>
#else
#include <malloc.h>
#endif
#endif
#include "protocol.h"
#include "data.h"
#include "externs.h"
#include "defines.h"

static void setupwindow(struct window *,unsigned int );

/************************************************************************/
/*
 *	protinit () 
 *
 *	Calls all the other packet initialization keep this order as some packet
 * inits require lower layers already be initialized.
 *
*/
void protinit(void)
{
	etherinit();									/* dlayer packets */
	arpinit();  									/* ARP packets */
  ipinit();                     /* ip packets */
	tcpinit();										/* tcp packets */
	udpinit();										/* udp packets */
}

/*************************************************************************/
/*
 *	neteventinit ()
 *
 *	Setup all the pointers for the event queue -- makes a circular list which
 * is required for error messages. ( called from Snetinit () )
 *
*/

void neteventinit (void)
{
	int i;

	for(i=0; i<NEVENTS; i++)
		nnq[i].next=i+1;
	nnq[NEVENTS-1].next=-1;
	nnefirst=0;
	nnelast=0;
	nnefree=1;
}

/*
 *	etherinit ()
 *
 *	Setup the ethernet headers ( dlayer ) -- this needs to be done first as it
 * is copied for the other headers 
 *
 */
void etherinit(void)
{
	movebytes(broadaddr,bseed,DADDLEN);
	movebytes(blankd.dest,broadaddr,DADDLEN);	/* some are broadcast */
	movebytes(blankd.me,nnmyaddr,DADDLEN);		/* always from me */
	blankd.type=EIP;				/* mostly IP packets */
}

/*************************************************************************/
/*
 *	arpinit ()
 *	Setup an arp packet -- also sets up an arp cache
*
*/
void arpinit(void)
{
	int i;

	movebytes(&arp.d,&blankd,sizeof(DLAYER));
	arp.d.type=EARP;				/* 0x0806 is ARP type */
	arp.hrd=intswap(HTYPE);			/*  Ether=1 */
	arp.pro=intswap(ARPPRO);			/* IP protocol=0x0800 */
	arp.hln=DADDLEN;					/* Ethernet hardware length */
	arp.pln=4;						/* IP length=4 */
	movebytes(arp.sha,nnmyaddr,DADDLEN);	/* sender's hardware addr */
	movebytes(arp.tha,broadaddr,DADDLEN);	/* target hardware addr */
	movebytes(arp.spa,nnipnum,4);		/* sender's IP addr */
/*
*  initialize the ARP cache to 0 time, none are gateways to start
*/
	for(i=0; i<CACHELEN; i++) {
		arpc[i].tm=0L;
		arpc[i].gate=0;
	  }
}

/*************************************************************************/
/*
 *	ipinit ()
 *
 *	initialize on packet to use for internet transmission -- most packets will
 * be tcp/udp, so they will be initialized at a different layer, but some
 * require a generic ip packet.
 *
 *	Also takes a guess at setting a netmask if it hasn't happened by now.
 *
*/
void ipinit(void)
{
	movebytes(&blankip.d,&blankd,sizeof(DLAYER));
	blankip.i.versionandhdrlen=0x45;		/* smallest header, version 4 */
	blankip.i.service=0;					/* normal service */
	blankip.i.tlen=576;						/* no data yet, maximum size */
	blankip.i.ident=0;
	blankip.i.frags=0;						/* not a fragment of a packet */
	blankip.i.ttl=100;						/* 100 seconds should be enough */
  blankip.i.protocol=PROTUDP;   /* default to UDP */
	blankip.i.check=0;						/* disable checksums for now */
	movebytes(blankip.i.ipsource,nnipnum,4);	/* my return address */
	movebytes(blankip.i.ipdest,broadip,4);		/* to ? */

/*
*  create a mask which can determine whether a machine is on the same wire
*  or not.  RFC950
*  Only set the mask if not previously set.
*  This mask may be replaced by a higher level request to set the subnet mask.
*/
	if(comparen(nnmask,"\0\0\0\0",4)) {			/* now blank */
		if(!(nnipnum[0]&0x80))					/* class A */
			netsetmask(nnamask);
		else 
			if((nnipnum[0]&0xC0)==0x80)		/* class B */
				netsetmask(nnbmask);
			else 
				if((nnipnum[0]&0xC0)==0xC0)		/* class C */
					netsetmask(nncmask);
	  }
}

/**************************************************************************/
/*
 *	udpinit ()
 *
 *  Setup udplist[0] for receive of udp packets
 *
 *  Now supports multiple UDP ports...  EEJ   6/26/92
 *
 *  Keep in mind that back in the good ole days, telnet only had supported
 *  listening to one UDP port, and only had one global structure to read the
 *  the damn thing in.  Now, there is an array of udp ports.  But in order
 *  to keep some semblence of compatibility between versions of code,
 *  udplist[0] is technically the same as ulist, the global variable from long ago.
 *
 */

void udpinit(void)
{
    int         i;

    for(i=0;i<NPORTS;i++)
        udplist[i]=NULL;

    newudp();

    /**
     ** The code below is commented out, because these initilization
     ** functions are performed by the newudp() call above.  Keep in mind
     ** that the DNR assumes we got the first structure in the UDP list
     **
     **/


#ifdef NOT
    udplist[DNRINDEX] = (struct uport *) malloc(sizeof(struct uport));
    udplist[DNRINDEX]->stale=1;
    udplist[DNRINDEX]->length=0;

    movebytes(&udplist[DNRINDEX]->udpout,&blankip,sizeof(DLAYER)+sizeof(IPLAYER));
    udplist[DNRINDEX]->udpout.i.protocol=PROTUDP;                 UDP type
    udplist[DNRINDEX]->tcps.z=0;
    udplist[DNRINDEX]->tcps.proto=PROTUDP;
    movebytes(udplist[DNRINDEX]->tcps.source,nnipnum,4);
#endif

}

/**************************************************************************/
/*
 *	tcpinit ()
 *
 *	setup for makeport ()
 *
*/
void tcpinit(void)
{
	int i;

    for(i=0; i<NPORTS; i++)
		portlist[i]=NULL;			/* no ports open yet */
}

/**************************************************************************/
/*
 *	makeport ()
 *
 *   This is the intialization for TCP based communication.  When a port
 *   needs to be created, this routine is called to do as much pre-initialization
 *   as possible to save overhead during operation.
 *
 *   This structure is created upon open of a port, either listening or
 *   wanting to send.
 *
 *   A TCP port, in this implementation, includes all of the state data for the
 *   port connection, a complete packet for the TCP transmission, and two
 *   queues, one each for sending and receiving.  The data associated with
 *   the queues is in struct window.
*/
int makeport(void)
{
	int i,j,retval;

	struct port *p,*q;
/*
*  Check to see if any other connection is done with its port buffer space.
*  Indicated by the connection state of SCLOSED
*/
	p=NULL;
	i=0;
    do {    /* search for a pre-initialized port to re-use */
		q=portlist[i];
        if(q!=NULL && (q->state==SCLOSED || (q->state==STWAIT && q->out.lasttime+WAITTIME<n_clicks())))
			p=q;
		retval=i++;					/* port # to return */
    } while(p==NULL && i<NPORTS);
#ifdef DEBUG
#ifdef TELBIN
    if(p)
        tprintf(console->vs,"Recycled old port.\r\n");
    else
        tprintf(console->vs,"Allocated new port.\r\n");
#endif
#endif /* DEBUG */
/*  
* None available pre-allocated, get a new one, about 8.5 K with a 4K windowsize
*/
	if(p==NULL) {
		if((p=(struct port *)malloc(sizeof(struct port)))==NULL) {
#ifdef TELBIN
            tprintf(console->vs,"memory allocation error.\r\n");
#endif
			nnerror(500);
			return(-1);				/* out of room for ports */
		  }	/* end if */
        for(i=0; portlist[i]!=NULL; i++) {
			if(i>=NPORTS) {
				nnerror(500);
				return(-1);				/* out of room for ports */
              } /* end if */
          } /* end for */
		portlist[i]=p;
		retval=i;
      } /* end if */
	if(p==NULL) {
		nnerror(505);
		return(-1);
	  }
    movebytes(&p->tcpout,&blankip,sizeof(DLAYER)+sizeof(IPLAYER));  /* static initialization */
	p->tcpout.i.tlen=0;
    p->tcpout.t.urgent=0;               /* no urgent data */
	p->tcpout.t.hlen=20<<2;				/* header length << 2 */
	p->tcps.z=0;
	p->tcps.proto=PROTTCP;
	movebytes(p->tcps.source,nnipnum,4);
	setupwindow(&p->in,WINDOWSIZE);		/* queuing parameters */
	setupwindow(&p->out,WINDOWSIZE);
    do {    /* search for an un-used port */
        i=(int)n_clicks();
        i|=2048;            /* make sure it is at least this large */
		i&=0x3fff;			/* at least this small */
#ifdef OLD_WAY
		for(j=0; j<NPORTS && (uint)i!=portlist[j]->in.port; j++);
#else
        for(j=0; j<NPORTS; j++)     /* don't check NULL ports */
            if(portlist[j]!=NULL && i==portlist[j]->in.port)
                break;
#endif
	  } while(j<NPORTS);
	if(nnfromport) {			/* allow the from port to be forced */
		i=nnfromport;
		nnfromport=0;			/* reset it so the next one will be random */
	  }
	p->in.port=i;
	p->tcpout.t.source=intswap(i);
	p->tcpout.t.seq=longswap(p->out.nxt);
	p->state=SCLOSED;
	p->credit=nncredit;
	p->sendsize=TSENDSIZE;
	p->rto=MINRTO;
	return(retval);
}

/*
 *	setupwindow ( w, wsize )
 *
 *	Configure information about a window *w*
 *
 */

static void setupwindow(struct window *w,unsigned int wsize)
{
	w->endbuf=w->where+wsize;
	w->base=w->endlim=w->where;
	w->contain=0;						/* nothing here yet */
    w->lasttime=n_clicks();
	w->size=wsize;
	w->push=0;
/*
*  base this on time of day clock, for uniqueness
*/
	w->ack=w->nxt=((w->lasttime<<12)&0x0fffffff);
}