/*  
*	 ARP
*	 Hardware level routines, data link layer
*
*****************************************************************************
*																			*
*	  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													*
*																			*
*****************************************************************************
*/

/*
* Includes
*/
#include <stdio.h>
#include "protocol.h"
#include "data.h"
#include "externs.h"

static int rarp(void);
static int cacheupdate(uint8 *,uint8 *);
static int replyarp(uint8 *,uint8 *);

/************************************************************************/
/*
*   Address Resolution Protocol handling.  This can be looked at as
*   Ethernet-dependent, but the data structure can handle any ARP
*   hardware, with minor changes here.
*
*/
static int replyarp(uint8 *thardware,uint8 *tipnum)
{
	uint8 *pc;

	movebytes(arp.tha,thardware,DADDLEN);   /* who this goes to */
	movebytes(arp.tpa,tipnum,4);			/* requester's IP address */
	arp.op=intswap(ARPREP);					/* byte swapped reply opcode */
	movebytes(arp.d.dest,thardware,DADDLEN);	/* hardware place to send to */
    dlayersend((DLAYER *)&arp,sizeof(arp));
/*
*  check for conflicting IP number with your own
*/
	if(comparen(tipnum,nnipnum,4))	{	 /* we are in trouble */
		pc=neterrstring(-1);
		sprintf(pc,"Conflict with Ethernet hardware address: %2x:%2x:%2x:%2x:%2x:%2x",
		thardware[0],thardware[1],thardware[2],thardware[3],thardware[4],thardware[5]);
		netposterr(-1);
		netposterr(102);
		return(-3);
	  }
	return(0);		/* ARP ok */
}

/************************************************************************/
/*  reqarp
*	put out an ARP request packet, doesn't wait for response
*/
int reqarp(uint8 *tipnum)
{
#ifdef PKT_ONLY
#define NO_APPLETALK
#endif
#ifndef NO_APPLETALK
	if(nnkip) {
    if(0<KIParp(tipnum,(AddrBlk *)&arp.tha[0]))
			cacheupdate(tipnum, &arp.tha[0]);
		return(0);
	  }	/* end if */
#endif

	movebytes(arp.tha,broadaddr,DADDLEN); 
	movebytes(arp.tpa,tipnum,4);		  		/* put in IP address we want */
	arp.op=intswap(ARPREQ);						/* request packet */
	movebytes(arp.d.dest,broadaddr,DADDLEN);	/* send to everyone */
	if(dlayersend((DLAYER *)&arp,sizeof(arp)))
		return(1);		  						/* error return */
	return(0);
}

/************************************************************************/
/*  interpret ARP packets
*   Look at incoming ARP packet and make required assessment of usefulness,
*   check to see if we requested this packet, clear all appropriate flags.
*/
int arpinterpret(ARPKT *p)
{
/*
*  check packet's desired IP address translation to see if it wants
*  me to answer.
*/
#ifdef CHECKRARP
fprintf(stderr,"ARP received, arp->op=%u\r\n",p->op);
#endif
    if(p->op==intswap(ARPREQ) && (comparen(p->tpa,nnipnum,4))) {
#ifdef CHECKRARP
fprintf(stderr,"Bogus response!\r\n");
#endif
      cacheupdate(p->spa,p->sha);   /* keep her address for me */
		replyarp(p->sha,p->spa);		/* proper reply */
		return(0);
  }
/*
*  Check for a RARP reply.  If present, call netsetip()
*/
	else
    if(p->op==intswap(RARPR) && (comparen(p->tha,nnmyaddr,DADDLEN))) {
#ifdef CHECKRARP
fprintf(stderr,"RARP response!\r\n");
#endif
			movebytes(nnipnum,p->tpa,4);
			return(0);
    }
/* 
*  Check for a reply that I probably asked for.
*/
    if(comparen(p->tpa,nnipnum,4) && p->op==intswap(ARPREP) && p->hrd==intswap(HTYPE) && p->hln==DADDLEN && p->pln==4) {
#ifdef CHECKRARP
fprintf(stderr,"Reply I asked for\r\n");
#endif
        cacheupdate(p->spa,p->sha);
        return(0);
	  }
#ifdef CHECKRARP
fprintf(stderr,"Dropping out of arpinterpret()\r\n");
#endif
	return(1);
}

/*************************************************************************/
/* rarp
*  Send a rarp request to look up my IP number
*/
static int rarp(void)
{
/*
*  our other fields should already be loaded
*/
#ifdef CHECKRARP
fprintf(stderr,"sending RARP\r\n");
#endif
#ifdef CHECKNULL
check_null_area();
#endif
	movebytes(arp.tha,nnmyaddr,DADDLEN);	/* address to look up (me) */
	movebytes(arp.sha,nnmyaddr,DADDLEN);	/* address to look up (me) */
	arp.op=intswap(RARPQ);					/* request packet */
	movebytes(arp.d.dest,broadaddr,DADDLEN);		/* send to everyone */
	arp.d.type=ERARP;
	if(dlayersend((DLAYER *)&arp,sizeof(arp)))
		return(1);		  				/* error return */
	arp.d.type=EARP;						/* set back for ARP to use */
#ifdef CHECKNULL
check_null_area();
#endif
#ifdef CHECKRARP
fprintf(stderr,"done sending RARP\r\n");
#endif
    return(0);
}

/*************************************************************************/
/* cacheupdate
*  We just received an ARP, or reply to ARP and need to add the information
*  to the cache.
*
*  Reset arptime so that another machine may be ARPed.  This timer keeps
*  ARPs from going out more than one a second unless we receive a reply.
*/
static int32 arptime=0L;

int cacheupdate(uint8 *ipn,uint8 *hrdn)
{
	int i,found;
	int32 timer;

	found=-1;
/*
* linear search to see if we already have this entry
*/
	for(i=0; found<0 && i<CACHELEN; i++) 
		if(comparen(ipn,arpc[i].ip,4))
			found=i;
/*
*  if that IP number is not already here, take the oldest entry.
*  If it is already here, update the info and reset the timer.
*  These were pre-initialized to 0, so if any are blank, they will be
*  taken first because they are faked to be oldest.
*/
	if(found<0) {
		timer=arpc[0].tm;
		found=0;
		for(i=1; i<CACHELEN; i++) 
			if(arpc[i].tm<timer && !arpc[i].gate) {	/* exclude gateways */
				found=i;
				timer=arpc[i].tm;
			  }
	  }
/*
*   do the update to the cache
*/
	movebytes(arpc[found].hrd,hrdn,DADDLEN);
	movebytes(arpc[found].ip,ipn,4);
    arpc[found].tm=n_clicks();
	arptime=0L;					/* reset, allow more arps */
	return(found);
}

/*************************************************************************/
/*  cachelook
*   look up information in the cache
*   returns the cache entry number for the IP number given.
*   Returns -1 on no valid entry, also if the entry present is too old.
*
*   doarp is a flag for non-gateway requests which determines whether an
*   arp will be sent or not.
*/
int cachelook(uint8 *ipn,int gate,int doarp)
{
	int i,haveg;
/*
*  First option, we are not looking for a gateway, but a host on our
*  local network.
*/
	if(!gate) {
		for(i=0; i<CACHELEN; i++)
            if(comparen(ipn,arpc[i].ip,4) && arpc[i].tm+CACHETO>n_clicks())
				return(i);
/*
*  no valid entry, send an ARP
*/
        if(n_clicks()>=arptime && doarp) {  /* check time limit */
			reqarp(ipn);				/* put out a broadcast request */
            arptime=n_clicks()+ARPTO;
		  }
	  }
	else {
/*
*  Second option, we need a gateway.
*  if there is a gateway with a current ARP, use it.
*  if not, arp all of the gateways and return an error.  Next call will
*  probably catch the result of the ARP.
*/
		haveg=0;
		for(i=CACHELEN-1; i>=0; i--)
            if(arpc[i].gate && arpc[i].tm+CACHETO>n_clicks())
				return(i);
        if(n_clicks()>=arptime) {
			for(i=CACHELEN-1; i>=0; i--)
				if(arpc[i].gate) {
					haveg=1;
					reqarp(arpc[i].ip);	/* put out a broadcast request */
				  }
			if(!haveg) 			/* blind luck, try ARPing even for */
				reqarp(ipn);		/* a node not on our net. (proxy ARP)*/
            arptime=n_clicks()+ARPTO;
		  }
	  }
    return(-1);
}

/***************************************************************************/
/*  netdlayer
*	   get data layer address for insertion into outgoing packets.
*   searches based on ip number.  If it finds the address, ok, else . . .
*
*   Checks to see if the address is on the same network.  If it is,
*   then ARPs the machine to get address.  Forces pause between sending
*   arps to guarantee not saturating network.
*
*   If not on the same network, it needs the ether address of a 
*   gateway.  Searches the list of machines for a gateway flag.
*   Returns the first gateway found with an Ethernet address. 
*
*   Returns NULL if not here, or pointer to ether address if here.
*   If we don't have it, this also sends an ARP request so that the
*   next time we are called, the ARP reply may be here by then.
*
*/
uint8 *netdlayer(uint8 *tipnum)
{
	int32 t;
	uint8 *pc;

    t=n_clicks()+nndto*TICKSPERSEC;         /* some seconds time out */
	pc=NULL;
	do {
        if(t<=n_clicks())                   /* timed out */
			return(NULL);
		pc=getdlayer(tipnum);
		netsleep(0);						/* can't have deadlock */
	  } while(pc==NULL);
	return(pc);
}

/***************************************************************************/
/*  netgetrarp
*   Look for a RARP response to arrive
*   wait for nndto seconds before returning failure.
*   If response arrives, return success.
*/
int netgetrarp(void )
{
	int32 t,tr;

#ifdef CHECKRARP
fprintf(stderr,"before RARPing\r\n");
#endif
    t=n_clicks()+nndto*TICKSPERSEC*3;       /* some seconds time out */
	tr=0L;									/* one second retry */
#ifdef CHECKRARP
fprintf(stderr,"Timeout=%ld\r\n",t);
#endif
	do {
        if(tr<=n_clicks()) {                /* need retry? */
            rarp();
            tr=n_clicks()+TICKSPERSEC;
          } /* end if */
        if(t<=n_clicks()) {                 /* timed out */
			netposterr(103);
			return(-1);
          } /* end if */
		netsleep(0);							/* can't have deadlock */
	} while(comparen(nnipnum,"RARP",4));		/* until RARP is served */
	return(0);
}   /* end netgetrarp() */

/***************************************************************************/
/*  getdlayer
*   check for the hardware address one time
*/
uint8 *getdlayer(uint8 *tipnum)
{
	int needgate,i;

	needgate=0;
/*
*  Check to see if we need to go through a gateway.
*  If the machine is on our network, then assume that we can send an ARP
*  to that machine, otherwise, send the ARP to the gateway.
*
*  Uses internet standard subnet mask method, RFC950
*  if subnets are not in use, netmask has been pre-set to the appropriate 
*  network addressing mask.
*/ 
	for(i=3; i>=0; i--)
		if((nnmask[i] & tipnum[i])!=(nnmask[i] & nnipnum[i]))
			needgate=1;
	if(needgate && (0<=(i=cachelook(tipnum,1,1)))) 
		return(arpc[i].hrd);
	if(!needgate && (0<=(i=cachelook(tipnum,0,1))))
		return(arpc[i].hrd);
	return(NULL);
}

/***************************************************************************/
/*  netsetgate
*   Establish an IP number to use as a gateway.
*   They are added in the order that they arrive and there is a limit on
*   the number of gateways equal to CACHELEN/2.
*   ARPs them as they are added so that the Cache will get pre-filled
*   with gateways.
*
*   returns 0 if ok, -1 on error(full)
*/
int netsetgate(uint8 *ipn)
{
	int i;

	for(i=CACHELEN-1 ; i>=CACHELEN/2 ; i--) {
		if(!arpc[i].gate) {
			arpc[i].gate=1;
			movebytes(arpc[i].ip,ipn,4);
			reqarp(ipn);
			return(0);
		  }
	  }	/* end for */
	return(-1);
}