336 lines
10 KiB
C
336 lines
10 KiB
C
/* nwroute.c 20-Dec-95 */
|
|
/* (C)opyright (C) 1993,1995 Martin Stover, Marburg, Germany
|
|
*
|
|
* 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 2 of the License, 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 "net.h"
|
|
#include "nwserv.h"
|
|
|
|
#define MAX_NW_ROUTES 50 /* max. 1 complete RIP packet should be enough */
|
|
|
|
typedef struct {
|
|
uint32 net; /* destnet */
|
|
uint16 hops; /* hops to net */
|
|
uint16 ticks; /* ticks to net, ether 1/hop, isdn 7/hop */
|
|
|
|
uint32 rnet; /* net of forw. router */
|
|
uint8 rnode[IPX_NODE_SIZE]; /* node of forw. router */
|
|
} NW_ROUTES;
|
|
|
|
static int anz_routes=0;
|
|
static NW_ROUTES *nw_routes[MAX_NW_ROUTES];
|
|
|
|
static void insert_delete_net(uint32 destnet,
|
|
uint32 rnet, /* routernet */
|
|
uint8 *rnode, /* routernode */
|
|
uint16 hops,
|
|
uint16 ticks,
|
|
int do_delete) /* delete == 1 */
|
|
{
|
|
int k=-1;
|
|
int freeslot=-1;
|
|
NW_ROUTES *nr=NULL;
|
|
|
|
XDPRINTF((3,"%s net:0x%X, over 0x%X, 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
(do_delete) ? "DEL" : "INS", destnet, rnet,
|
|
(int)rnode[0], (int)rnode[1], (int)rnode[2],
|
|
(int)rnode[3], (int)rnode[4], (int)rnode[5]));
|
|
|
|
if (!destnet || destnet == internal_net) return;
|
|
|
|
while (++k < anz_net_devices) {
|
|
NW_NET_DEVICE *nd=net_devices[k];
|
|
if (nd->net == destnet && (do_delete || (nd->ticks <= ticks))) return;
|
|
}
|
|
|
|
k=-1;
|
|
while (++k < anz_routes && nw_routes[k]->net != destnet) {
|
|
XDPRINTF((3,"NET 0x%X is routed\n", nw_routes[k]->net));
|
|
if (freeslot < 0 && !nw_routes[k]->net) freeslot=k;
|
|
}
|
|
|
|
if (k == anz_routes) { /* no route slot found */
|
|
if (do_delete) return; /* nothing to delete */
|
|
if (freeslot < 0) {
|
|
if (anz_routes == MAX_NW_ROUTES) return;
|
|
nw_routes[k] = (NW_ROUTES*)xmalloc(sizeof(NW_ROUTES));
|
|
anz_routes++;
|
|
} else k=freeslot;
|
|
nr=nw_routes[k];
|
|
memset(nr, 0, sizeof(NW_ROUTES));
|
|
nr->net = destnet;
|
|
nr->ticks = 0xffff;
|
|
nr->hops = 0xffff;
|
|
} else if (do_delete) {
|
|
nr=nw_routes[k];
|
|
if (nr->rnet == rnet &&
|
|
IPXCMPNODE(nr->rnode, rnode) ) {
|
|
/* only delete the routes, which we have inserted */
|
|
XDPRINTF((2,"ROUTE DEL NET=0x%X over Router NET 0x%X\n",
|
|
nr->net, rnet));
|
|
ipx_route_del(nr->net);
|
|
nr->net = 0L;
|
|
} else {
|
|
XDPRINTF((3,"ROUTE NOT deleted NET=0x%X, RNET=0X%X\n",
|
|
nr->net, rnet));
|
|
}
|
|
return;
|
|
} else nr=nw_routes[k];
|
|
if (ticks <= nr->ticks) {
|
|
if (ticks > nr->ticks) return;
|
|
if (ticks == nr->ticks && hops > nr->hops) return;
|
|
nr->hops = hops;
|
|
nr->ticks = ticks;
|
|
nr->rnet = rnet;
|
|
memcpy(nr->rnode, rnode, IPX_NODE_SIZE);
|
|
XDPRINTF((2,"ADD ROUTE NET=0x%X, over 0x%X, 0x%02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
nr->net, nr->rnet,
|
|
(int)nr->rnode[0], (int)nr->rnode[1], (int)nr->rnode[2],
|
|
(int)nr->rnode[3], (int)nr->rnode[4], (int)nr->rnode[5]));
|
|
ipx_route_add(nr->net, nr->rnet, nr->rnode);
|
|
}
|
|
}
|
|
|
|
static uint32 rnet=0L;
|
|
static int rentries=0;
|
|
static int rmode; /* 0=normal, 1=shutdown, 10=request */
|
|
static uint8 rip_buff[402]; /* operation + max. 50 RIPS */
|
|
|
|
static void init_rip_buff(uint32 net, int mode)
|
|
{
|
|
rnet=net;
|
|
rentries=0;
|
|
rmode=mode;
|
|
U16_TO_BE16((mode > 9) ? 1 : 2, rip_buff); /* rip request or response */
|
|
}
|
|
|
|
static void ins_rip_buff(uint32 net, uint16 hops, uint16 ticks)
|
|
{
|
|
if ( net && rentries < 50 &&
|
|
(net != rnet || (!rentries && net == internal_net))) {
|
|
uint8 *p=rip_buff+2+(rentries*8);
|
|
U32_TO_BE32(net, p);
|
|
U16_TO_BE16(hops, p+4);
|
|
U16_TO_BE16(ticks, p+6);
|
|
rentries++;
|
|
}
|
|
}
|
|
|
|
static void build_rip_buff(uint32 destnet)
|
|
{
|
|
int is_wild = (destnet==MAX_U32);
|
|
int is_response = (rmode < 10);
|
|
int k;
|
|
|
|
if (!destnet) return;
|
|
if (is_wild) rentries=0;
|
|
|
|
if (is_response) {
|
|
if (is_wild || internal_net == destnet) {
|
|
ins_rip_buff(internal_net, (rmode==1) ? 16 : 1,
|
|
(rnet==internal_net) ? 1 : 2);
|
|
}
|
|
k=-1;
|
|
while (++k < anz_net_devices) {
|
|
NW_NET_DEVICE *nd=net_devices[k];
|
|
if (is_wild || nd->net == destnet)
|
|
ins_rip_buff(nd->net, (rmode==1) ? 16 : 1, nd->ticks+1);
|
|
}
|
|
}
|
|
k=-1;
|
|
while (++k < anz_routes) {
|
|
NW_ROUTES *nr=nw_routes[k];
|
|
if ((is_wild || nr->net == destnet) && rmode==1 || nr->hops < 2)
|
|
ins_rip_buff(nr->net, (rmode==1) ? 16 : nr->hops, nr->ticks);
|
|
}
|
|
}
|
|
|
|
static void send_rip_buff(ipxAddr_t *from_addr)
|
|
{
|
|
if (rentries > 0) {
|
|
int datasize=(rentries*8)+2;
|
|
ipxAddr_t to_addr;
|
|
if (from_addr) memcpy(&to_addr, from_addr, sizeof(ipxAddr_t));
|
|
else {
|
|
memset(&to_addr, 0, sizeof(ipxAddr_t));
|
|
U32_TO_BE32(rnet, to_addr.net);
|
|
memset(to_addr.node, 0xFF, IPX_NODE_SIZE);
|
|
U16_TO_BE16(SOCK_RIP, to_addr.sock);
|
|
}
|
|
|
|
if (nw_debug) {
|
|
uint8 *p = rip_buff;
|
|
int operation = GET_BE16(p);
|
|
XDPRINTF((2,"Send Rip %s entries=%d\n",
|
|
(operation==1) ? "Request" : "Response", rentries));
|
|
p+=2;
|
|
while (rentries--) {
|
|
uint32 net = GET_BE32(p);
|
|
uint16 hops = GET_BE16(p+4);
|
|
uint16 ticks = GET_BE16(p+6);
|
|
XDPRINTF((2,"hops=%3d, ticks %3d, network:%02x.%02x.%02x.%02x\n",
|
|
(int)hops, (int)ticks, (int)*(p), (int)*(p+1), (int)*(p+2), (int)*(p+3)));
|
|
p+=8;
|
|
}
|
|
}
|
|
|
|
send_ipx_data(sockfd[RIP_SLOT], 1,
|
|
datasize,
|
|
(char *)rip_buff,
|
|
&to_addr, "SEND RIP");
|
|
rentries=0;
|
|
}
|
|
}
|
|
|
|
void send_rip_broadcast(int mode)
|
|
/* mode=0, standard broadcast */
|
|
/* mode=1, first trie */
|
|
/* mode=2, shutdown */
|
|
{
|
|
int k=-1;
|
|
while (++k < anz_net_devices) {
|
|
NW_NET_DEVICE *nd=net_devices[k];
|
|
if (nd->ticks < 7) { /* isdn devices should not get RIP broadcasts everytime */
|
|
init_rip_buff(nd->net, (mode == 2) ? 1 : 0);
|
|
build_rip_buff(MAX_U32);
|
|
send_rip_buff(NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void rip_for_net(uint32 net)
|
|
{
|
|
int k=-1;
|
|
while (++k < anz_net_devices) {
|
|
NW_NET_DEVICE *nd=net_devices[k];
|
|
if (nd->ticks < 7) { /* isdn devices should not get RIP broadcasts everytime */
|
|
init_rip_buff(nd->net, 10);
|
|
ins_rip_buff(net, MAX_U16, MAX_U16);
|
|
send_rip_buff(NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void handle_rip(int fd, int ipx_pack_typ,
|
|
int data_len, IPX_DATA *ipxdata,
|
|
ipxAddr_t *from_addr)
|
|
{
|
|
int operation = GET_BE16(ipxdata->rip.operation);
|
|
int entries = (data_len-2) / 8;
|
|
uint8 *p = ((uint8*)ipxdata)+2;
|
|
int is_response = operation==2;
|
|
|
|
XDPRINTF((2,"Got Rip %s entries=%d from: %s\n",
|
|
(!is_response) ? "Request" : "Response", entries,
|
|
visable_ipx_adr(from_addr)));
|
|
|
|
if (!is_response) {
|
|
if (operation != 1) {
|
|
XDPRINTF((1,"UNKNOWN RIP operation %d\n", operation));
|
|
return;
|
|
}
|
|
init_rip_buff(GET_BE32(from_addr->net), 0);
|
|
}
|
|
|
|
while (entries--) {
|
|
uint32 net = GET_BE32(p);
|
|
uint16 hops = GET_BE16(p+4);
|
|
uint16 ticks = GET_BE16(p+6);
|
|
XDPRINTF((2,"hops=%3d, ticks %3d, network:%02x.%02x.%02x.%02x\n",
|
|
(int)hops, (int)ticks, (int)*(p), (int)*(p+1), (int)*(p+2), (int)*(p+3)));
|
|
|
|
if (is_response) {
|
|
insert_delete_net(net, GET_BE32(from_addr->net),
|
|
from_addr->node, hops+1, ticks+1, (hops > 15) ? 1 : 0);
|
|
} else { /* rip request */
|
|
build_rip_buff(net);
|
|
if (net == MAX_U32) break;
|
|
}
|
|
p+=8;
|
|
}
|
|
if (!is_response) /* rip request */
|
|
send_rip_buff(from_addr);
|
|
}
|
|
|
|
/* <========================= SAP ============================> */
|
|
void send_sap_broadcast(int mode)
|
|
/* mode=0, standard broadcast */
|
|
/* mode=1, first trie */
|
|
/* mode=2, shutdown */
|
|
{
|
|
int k=-1;
|
|
while (++k < anz_net_devices) {
|
|
NW_NET_DEVICE *nd=net_devices[k];
|
|
if (nd->ticks < 7 || mode) { /* isdn devices should not get SAP broadcasts everytime */
|
|
IPX_DATA ipx_data;
|
|
ipxAddr_t wild;
|
|
memset(&wild, 0, sizeof(ipxAddr_t));
|
|
|
|
U32_TO_BE32(nd->net, wild.net);
|
|
memset(wild.node, 0xFF, IPX_NODE_SIZE);
|
|
U16_TO_BE16(SOCK_SAP, wild.sock);
|
|
|
|
memset(&ipx_data, 0, sizeof(ipx_data.sip));
|
|
strcpy(ipx_data.sip.server_name, my_nwname);
|
|
memcpy(&ipx_data.sip.server_adr, &my_server_adr, sizeof(ipxAddr_t));
|
|
U16_TO_BE16(SOCK_NCP, ipx_data.sip.server_adr.sock);
|
|
/* use NCP SOCKET */
|
|
|
|
U16_TO_BE16(2, ipx_data.sip.response_type); /* General */
|
|
U16_TO_BE16(4, ipx_data.sip.server_type); /* Fileserver */
|
|
|
|
if (mode == 2) {
|
|
U16_TO_BE16(16, ipx_data.sip.intermediate_networks);
|
|
} else {
|
|
U16_TO_BE16(1, ipx_data.sip.intermediate_networks);
|
|
/* I hope 1 is ok here */
|
|
}
|
|
send_ipx_data(sockfd[MY_BROADCAST_SLOT], 0,
|
|
sizeof(ipx_data.sip),
|
|
(char *)&(ipx_data.sip),
|
|
&wild, "SIP Broadcast");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void query_sap_on_net(uint32 net)
|
|
/* searches for the next server on this network */
|
|
{
|
|
SQP sqp;
|
|
ipxAddr_t wild;
|
|
memset(&wild, 0, sizeof(ipxAddr_t));
|
|
memset(wild.node, 0xFF, IPX_NODE_SIZE);
|
|
U32_TO_BE32(net, wild.net);
|
|
U16_TO_BE16(SOCK_SAP, wild.sock);
|
|
U16_TO_BE16(3, sqp.query_type);
|
|
U16_TO_BE16(4, sqp.server_type);
|
|
send_ipx_data(sockfd[SAP_SLOT], 17, sizeof(SQP),
|
|
(char*)&sqp, &wild, "SERVER Query");
|
|
}
|
|
|
|
void get_servers(void)
|
|
{
|
|
int k=-1;
|
|
while (++k < anz_net_devices) {
|
|
NW_NET_DEVICE *nd=net_devices[k];
|
|
if (nd->ticks < 7) query_sap_on_net(nd->net); /* only fast routes */
|
|
}
|
|
if (!anz_net_devices) query_sap_on_net(internal_net);
|
|
}
|
|
|
|
|