/* File IPXRIP.C : IPX Routing Information Protocol functions
*/
/*
Copyright (C) 1992 Indian Institute of Technology, Bombay
Written by V. Srinivas and Vishwas Joglekar,
Dept of Computer Science and Engineering.
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 1, 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.
*/
#include "yapcbr.h"
#include "ipxwatch.h"
#include "ipxrip.h"
#include "diag.h"
extern struct rip_table *rip_lookup[];
extern struct rxstruct *rxptr;
extern struct my_route my_route_info;
extern struct ipxpktdv Ipxpktdv;
extern struct network_info *net_lookup(BYTE *net_id,int append_flag);
extern WORD getword(BYTE *);
void nlist();
int rip_hash_lookup(int hashret,RIP_INFO *route_info,BYTE *router_id );
void disp_route_info(ROUT_TABLE *rip_ptr);
void proc_rip_pkt(RIP_PKT *rip_pkt,unsigned char *disp,int bcast);
int check_more(int *row);
void *ibuf_alloc(int type);
ROUT_TABLE *find_route(BYTE *net_id);
/* search for the network/route information in the hashed list */
int rip_hash_lookup(int hashret,RIP_INFO *route_info,BYTE *router_id )
{
ROUT_TABLE *new_addr,*tmp,*hash_ptr;
WORD new_tick,old_tick;
int alt_route;
alt_route = FALSE;
hash_ptr = rip_lookup[hashret];
tmp=hash_ptr;
if((route_info->no_of_hops & 0x0f00) > 0x0f00 ) return(NOTFOUND);
#ifdef DBG1
cprintf("Searching Hash table, bucket %d\n",hashret);
#endif
while(hash_ptr != 0){
/* add the network information into the network information table */
/* is the route already known ? */
if(memcmp(hash_ptr->route_info.net_id,route_info->net_id,NET_ID_LEN) == 0){
/* check whether it is a new/faster route or the same */
new_tick = getword((BYTE *)&route_info->no_of_ticks);
if( new_tick > hash_ptr->route_info.no_of_ticks)
return(FOUND); /* new route is a slower route, discard */
if( new_tick < hash_ptr->route_info.no_of_ticks){
/* the new route is a faster route, delete the old route info */
hash_ptr->route_info.no_of_ticks = new_tick;
hash_ptr->route_info.no_of_hops = getword((BYTE *)&route_info->no_of_hops);
hash_ptr->dev = rxptr->dev; /* save the NIC no */
hash_ptr->age_timer = FLUSH_TIME; /* 60 secs timer */
memcpy(hash_ptr->router_id,router_id,ETHER_ADDR_LEN);
hash_ptr->alternate_route = 0;
return(FOUND);
}
else{ /* Is it is an alternate route with the same number of ticks ? */
if(memcmp(hash_ptr->router_id,router_id,ETHER_ADDR_LEN) == 0){
/* same route, reset the timer */
hash_ptr->age_timer = FLUSH_TIME; /* 60 secs timer */
return(FOUND);
}
else{
alt_route = TRUE;
break;
}
}
}
tmp = hash_ptr;
hash_ptr = hash_ptr->next;
} /* while */
/* address not in table, add */
new_addr = (struct rip_table *)ibuf_alloc(NOVLRIP);
if(new_addr == 0) {
printf("Malloc failed \n");
return(0);
}
memcpy(new_addr->route_info.net_id,route_info->net_id,NET_ID_LEN);
new_addr->route_info.no_of_ticks = getword((BYTE *)&route_info->no_of_ticks);
new_addr->route_info.no_of_hops = getword((BYTE *) &route_info->no_of_hops);
new_addr->dev = rxptr->dev; /* save the NIC no */
memcpy(new_addr->router_id,router_id,ETHER_ADDR_LEN);
new_addr->alternate_route = 0;
new_addr->next = 0;
new_addr->age_timer = FLUSH_TIME; /* 60 sec timer */
new_addr->net_status = 0;
if(alt_route == TRUE){ /* it is an alternate route */
hash_ptr->alternate_route = new_addr;
return(NOTFOUND);
}
if(tmp == 0) /* is this bucket empty ? */
rip_lookup[hashret] = new_addr;
else /* the bucket is not empty */
tmp->next = new_addr;
net_lookup(route_info->net_id,TRUE); /* update the network information table */
return(NOTFOUND);
}
/* list all the networks & the correspond routers by looking at the
route information table
*/
void nlist()
{
int i,temp,count=0;
ROUT_TABLE *rip_ptr;
make_win(8,5,74,22,1,"ROUTING INFORMATION");
disp_mesg("ESC Close Window");
make_win(9,6,73,21,1,"Network Router Address Hops Ticks Net Status Age Timer");
gotoxy(1,1);
_setcursortype(_NOCURSOR);
for(i=0;i< MAX_PRIME;i++){
rip_ptr = rip_lookup[i];
while(rip_ptr!= 0){
disp_route_info(rip_ptr);
if(check_more(&count) == ESC) return;
if(rip_ptr->alternate_route != 0){
disp_route_info(rip_ptr->alternate_route);
if(check_more(&count) == ESC) return;
}
rip_ptr = rip_ptr->next;
}/* while */
} /* for */
while(read_key()!= ESC);
}
/* Display routing table info */
void disp_route_info(ROUT_TABLE *rip_ptr)
{
unsigned char buff[50];
buff[0] = '\0';
prnt_hex(rip_ptr->route_info.net_id,buff,4);
cprintf(" %s ",buff);
/* cprintf("%2d ",rip_ptr->dev); */
buff[0] = '\0';
prnt_hex(rip_ptr->router_id,buff,6);
cputs(buff);
cprintf(" %.2u ",rip_ptr->route_info.no_of_hops);
cprintf(" %.2u ",rip_ptr->route_info.no_of_ticks);
cprintf(" %.2u ",rip_ptr->net_status);
cprintf(" %.4u \r\n",rip_ptr->age_timer);
}
/* Determine the type of RIP packet */
void proc_rip_pkt(RIP_PKT *rip_pkt,unsigned char *disp,int bcast)
{
WORD resp_type,len;
struct network_info *my_net;
extern struct network_info *current_net;
int i,no_of_routes,hashret;
resp_type = getword(rip_pkt->type); /* get rip pkt type */
switch(resp_type){
case ROUTE_REQUEST: /* route request pkt */
sprintf(disp,"Route Request -> ");
prnt_hex(rip_pkt->route_info[0].net_id,disp+strlen(disp),4);
break;
case ROUTE_RESP:
/* respose to a route request or a periodic broadcast */
if(bcast == TRUE){
/* It is a broadcast packet from a router, update
the router information table */
len = getword(rip_pkt->header.length); /* get length of IPX packet */
no_of_routes = (len-sizeof(IPX_HEADER) - sizeof(WORD))/sizeof(RIP_INFO);
if(no_of_routes >MAX_ROUTES) return; /* invalid rip packet */
sprintf(disp,"Route Info ");
/* get my network address by looking at the ipx header */
my_net = net_lookup(rip_pkt->header.source_node.net_id,TRUE);
if(current_net == 0){
current_net = my_net;
memcpy(my_route_info.route_info.net_id,my_net->net_id,4);
memcpy(Ipxpktdv.net_id,my_net->net_id,4);
}
hashret = hash_addr(my_net->net_id,4);
rip_hash_lookup(hashret,&my_route_info.route_info,my_route_info.router_id);
for(i=0;i<no_of_routes;i++){
hashret = hash_addr(rip_pkt->route_info[i].net_id,4);
rip_hash_lookup(hashret,&rip_pkt->route_info[i],rip_pkt->header.source_node.node_id);
}
}
else sprintf(disp,"Route Response ");
prnt_hex(rip_pkt->route_info[0].net_id,disp+strlen(disp),4);
sprintf(disp+strlen(disp),"%2.2d/%2.2d",getword((BYTE *) &rip_pkt->route_info[0].no_of_hops),
getword((BYTE *) &rip_pkt->route_info[0].no_of_ticks));
break;
default: break;
}
}
int check_more(int *pos)
{
int k =0;
fflush(stdin);
(*pos)++;
if(*pos == 13){
*pos=1;
gotoxy(5,20);
highvideo();
cprintf("More");
lowvideo();
k = getch();
}
else if(kbhit()!= 0)k= getch();
return(k);
}
/* determines the route to a given network and returns a pointer to the
routing information table, containing the router id and other information */
ROUT_TABLE *find_route(BYTE *net_id)
{
int hash_indx;
ROUT_TABLE *oldptr;
hash_indx = hash_addr(net_id,4);
for(oldptr = rip_lookup[hash_indx];oldptr != 0; oldptr = oldptr->next){
/* is the route already known ? */
if(memcmp(oldptr->route_info.net_id,net_id,NET_ID_LEN) == 0)
return(oldptr);
}
return(0);
}
