1998-07-10 03:39:04 +08:00
/*
* Rest in pieces - RIP protocol
*
1999-05-11 17:53:45 +08:00
* Copyright ( c ) 1998 , 1999 Pavel Machek < pavel @ ucw . cz >
1998-07-10 03:39:04 +08:00
*
* Can be freely distributed and used under the terms of the GNU GPL .
1999-10-11 22:19:29 +08:00
*
1999-10-12 21:04:50 +08:00
FIXME : IpV6 support : packet size
FIXME : IpV6 support : use right address for broadcasts
FIXME : IpV6 support : receive " route using " blocks
1999-11-10 19:52:36 +08:00
FIXME : Do we send " triggered updates " correctly ?
FIXME : When route ' s metric changes to 16 , start garbage collection immediately ? Do _not_ restart on new updates with metric = = 16.
FIXME : When route ' s 60 seconds old and we get same metric , use that !
FIXME : Triggered updates . When triggered update was sent , don ' t send new one for something between 1 and 5 seconds ( and send one after that ) .
We are not going to honour requests for sending part of
routing table . That would need to turn split horizont off ,
etc .
1998-07-10 03:39:04 +08:00
*/
# define LOCAL_DEBUG
# include <string.h>
# include <stdlib.h>
# include "nest/bird.h"
# include "nest/iface.h"
# include "nest/protocol.h"
# include "nest/route.h"
# include "lib/socket.h"
# include "lib/resource.h"
# include "lib/lists.h"
# include "lib/timer.h"
# include "rip.h"
1999-02-15 21:34:43 +08:00
# define P ((struct rip_proto *) p)
# define P_CF ((struct rip_proto_config *)p->cf)
# define E ((struct rip_entry *) e)
1999-06-01 04:30:16 +08:00
static struct rip_interface * new_iface ( struct proto * p , struct iface * new , unsigned long flags , struct iface_patt * patt ) ;
1998-07-10 03:39:04 +08:00
static void
rip_reply ( struct proto * p )
{
1998-07-30 15:43:45 +08:00
#if 0
1998-07-10 03:39:04 +08:00
P - > listen - > tbuf = " ACK! " ;
sk_send_to ( P - > listen , 5 , P - > listen - > faddr , P - > listen - > fport ) ;
1998-07-30 15:43:45 +08:00
# endif
1998-07-10 03:39:04 +08:00
}
1999-03-17 18:20:23 +08:00
# define P_NAME p->name
1999-02-09 06:50:32 +08:00
1998-07-29 05:44:11 +08:00
/*
* Output processing
*/
static void
rip_tx_err ( sock * s , int err )
{
struct rip_connection * c = s - > data ;
struct proto * p = c - > proto ;
1998-12-20 22:29:06 +08:00
log ( L_ERR " Unexpected error at rip transmit: %m " ) ;
1998-07-29 05:44:11 +08:00
}
static void
rip_tx ( sock * s )
{
1998-10-26 23:35:19 +08:00
struct rip_interface * rif = s - > data ;
struct rip_connection * c = rif - > busy ;
1998-07-29 05:44:11 +08:00
struct proto * p = c - > proto ;
struct rip_packet * packet = ( void * ) s - > tbuf ;
1998-12-23 03:41:04 +08:00
int i ;
1998-07-29 05:44:11 +08:00
1999-10-02 18:44:48 +08:00
DBG ( " Sending to %I \n " , s - > daddr ) ;
1998-12-23 03:41:04 +08:00
do {
1998-07-29 05:44:11 +08:00
1998-12-23 03:41:04 +08:00
if ( c - > done ) {
DBG ( " Looks like I'm " ) ;
c - > rif - > busy = NULL ;
rem_node ( NODE c ) ;
mb_free ( c ) ;
DBG ( " done \n " ) ;
return ;
1998-10-08 03:33:50 +08:00
}
1998-07-29 05:44:11 +08:00
1998-12-23 03:41:04 +08:00
DBG ( " Preparing packet to send: " ) ;
packet - > heading . command = RIPCMD_RESPONSE ;
packet - > heading . version = RIP_V2 ;
packet - > heading . unused = 0 ;
1999-05-11 17:53:45 +08:00
i = ! ! P_CF - > authtype ;
1998-12-23 03:41:04 +08:00
FIB_ITERATE_START ( & P - > rtable , & c - > iter , z ) {
struct rip_entry * e = ( struct rip_entry * ) z ;
DBG ( " . " ) ;
packet - > block [ i ] . family = htons ( 2 ) ; /* AF_INET */
1999-06-01 03:16:22 +08:00
packet - > block [ i ] . tag = htons ( e - > tag ) ;
1998-12-23 03:41:04 +08:00
packet - > block [ i ] . network = e - > n . prefix ;
1999-10-11 22:19:29 +08:00
# ifndef IPV6
1998-12-23 03:41:04 +08:00
packet - > block [ i ] . netmask = ipa_mkmask ( e - > n . pxlen ) ;
1999-10-11 22:19:29 +08:00
ipa_hton ( packet - > block [ i ] . netmask ) ;
1999-11-04 22:26:18 +08:00
packet - > block [ i ] . nexthop = IPA_NONE ;
{
1999-11-17 19:16:15 +08:00
/*
* FIXME : This DOESN ' T work . The s - > daddr will be typically
* a broadcast or multicast address which will be of course
* rejected by the neighbor cache . I ' ve # ifdef ' d out the whole
* test to avoid dereferencing NULL pointer . - - mj
*/
#if 0
1999-11-04 22:26:18 +08:00
neighbor * n1 , * n2 ;
1999-11-04 22:39:51 +08:00
n1 = neigh_find ( p , & s - > daddr , 0 ) ; /* FIXME, mj: this is neccessary for responses, still it is too complicated for common case */
1999-11-04 22:26:18 +08:00
n2 = neigh_find ( p , & e - > nexthop , 0 ) ;
if ( n1 - > iface = = n2 - > iface )
packet - > block [ i ] . nexthop = e - > nexthop ;
else
1999-11-17 19:16:15 +08:00
# endif
1999-11-04 22:26:18 +08:00
packet - > block [ i ] . nexthop = IPA_NONE ;
}
1999-10-11 22:19:29 +08:00
ipa_hton ( packet - > block [ i ] . nexthop ) ;
# else
packet - > block [ i ] . pxlen = e - > n . pxlen ;
# endif
1999-06-01 03:16:22 +08:00
packet - > block [ i ] . metric = htonl ( e - > metric ) ;
1998-12-23 03:41:04 +08:00
if ( ipa_equal ( e - > whotoldme , s - > daddr ) ) {
DBG ( " (split horizont) " ) ;
1999-02-15 21:34:43 +08:00
packet - > block [ i ] . metric = P_CF - > infinity ;
1998-12-23 03:41:04 +08:00
}
ipa_hton ( packet - > block [ i ] . network ) ;
1999-08-18 21:19:33 +08:00
if ( i + + = = ( ( P_CF - > authtype = = AT_MD5 ) ? PACKET_MD5_MAX : PACKET_MAX ) ) {
1998-12-23 03:41:04 +08:00
FIB_ITERATE_PUT ( & c - > iter , z ) ;
goto break_loop ;
}
1999-02-14 03:14:16 +08:00
} FIB_ITERATE_END ( z ) ;
1998-12-23 03:41:04 +08:00
c - > done = 1 ;
break_loop :
1999-05-11 17:53:45 +08:00
if ( P_CF - > authtype )
1999-06-01 04:30:16 +08:00
rip_outgoing_authentication ( p , ( void * ) & packet - > block [ 0 ] , packet , i ) ;
1999-05-11 17:53:45 +08:00
1998-12-23 03:41:04 +08:00
DBG ( " , sending %d blocks, " , i ) ;
if ( ipa_nonzero ( c - > daddr ) )
i = sk_send_to ( s , sizeof ( struct rip_packet_heading ) + i * sizeof ( struct rip_block ) , c - > daddr , c - > dport ) ;
else
i = sk_send ( s , sizeof ( struct rip_packet_heading ) + i * sizeof ( struct rip_block ) ) ;
1998-07-29 05:44:11 +08:00
1998-12-10 04:08:57 +08:00
DBG ( " it wants more \n " ) ;
1998-07-29 05:44:11 +08:00
1998-12-23 03:41:04 +08:00
} while ( i > 0 ) ;
if ( i < 0 ) rip_tx_err ( s , i ) ;
1998-12-10 04:08:57 +08:00
DBG ( " blocked \n " ) ;
1998-07-29 05:44:11 +08:00
}
static void
1998-10-26 23:35:19 +08:00
rip_sendto ( struct proto * p , ip_addr daddr , int dport , struct rip_interface * rif )
1998-07-29 05:44:11 +08:00
{
1998-10-26 23:35:19 +08:00
struct iface * iface = rif - > iface ;
1998-07-29 05:44:11 +08:00
struct rip_connection * c = mb_alloc ( p - > pool , sizeof ( struct rip_connection ) ) ;
static int num = 0 ;
1998-10-26 23:35:19 +08:00
if ( rif - > busy ) {
1998-12-20 22:29:06 +08:00
log ( L_WARN " Interface %s is much too slow, dropping request " , iface - > name ) ;
1998-10-26 23:35:19 +08:00
return ;
}
rif - > busy = c ;
1998-10-21 00:45:53 +08:00
1998-07-29 05:44:11 +08:00
c - > addr = daddr ;
c - > proto = p ;
c - > num = num + + ;
1998-10-26 23:35:19 +08:00
c - > rif = rif ;
1998-07-29 05:44:11 +08:00
1998-10-26 23:35:19 +08:00
c - > dport = dport ;
c - > daddr = daddr ;
if ( c - > rif - > sock - > data ! = rif )
1998-12-20 22:29:06 +08:00
bug ( " not enough send magic " ) ;
1998-10-26 23:35:19 +08:00
#if 0
1998-07-29 05:44:11 +08:00
if ( sk_open ( c - > send ) < 0 ) {
1998-12-20 22:29:06 +08:00
log ( L_ERR " Could not open socket for data send to %I:%d on %s " , daddr , dport , rif - > iface - > name ) ;
1998-07-29 05:44:11 +08:00
return ;
}
1998-10-26 23:35:19 +08:00
# endif
1998-07-29 05:44:11 +08:00
1998-12-23 03:41:04 +08:00
c - > done = 0 ;
fit_init ( & c - > iter , & P - > rtable ) ;
1998-07-29 05:44:11 +08:00
add_head ( & P - > connections , NODE c ) ;
1998-10-26 23:35:19 +08:00
debug ( " Sending my routing table to %I:%d on %s \n " , daddr , dport , rif - > iface - > name ) ;
1998-07-29 05:44:11 +08:00
1998-10-26 23:35:19 +08:00
rip_tx ( c - > rif - > sock ) ;
1998-07-29 05:44:11 +08:00
}
1999-03-17 18:20:23 +08:00
static struct rip_interface *
1998-12-04 19:45:51 +08:00
find_interface ( struct proto * p , struct iface * what )
{
struct rip_interface * i ;
1998-12-10 04:08:57 +08:00
1998-12-04 19:45:51 +08:00
WALK_LIST ( i , P - > interfaces )
if ( i - > iface = = what )
return i ;
return NULL ;
}
1998-07-29 05:44:11 +08:00
/*
* Input processing
*/
1998-10-13 22:32:18 +08:00
/* Let main routing table know about our new entry */
static void
advertise_entry ( struct proto * p , struct rip_block * b , ip_addr whotoldme )
{
rta * a , A ;
rte * r ;
net * n ;
1998-10-21 00:12:43 +08:00
neighbor * neighbor ;
1999-03-17 18:20:23 +08:00
struct rip_interface * rif ;
1999-10-11 22:19:29 +08:00
int pxlen ;
1998-10-17 18:25:22 +08:00
1998-10-13 22:32:18 +08:00
bzero ( & A , sizeof ( A ) ) ;
A . proto = p ;
A . source = RTS_RIP ;
A . scope = SCOPE_UNIVERSE ;
A . cast = RTC_UNICAST ;
A . dest = RTD_ROUTER ;
A . flags = 0 ;
1999-10-11 22:19:29 +08:00
# ifndef IPV6
1998-10-13 22:32:18 +08:00
A . gw = ipa_nonzero ( b - > nexthop ) ? b - > nexthop : whotoldme ;
1999-10-11 22:19:29 +08:00
pxlen = ipa_mklen ( b - > netmask ) ;
# else
A . gw = whotoldme ; /* FIXME: next hop is in other packet for v6 */
pxlen = b - > pxlen ;
# endif
1998-10-13 22:32:18 +08:00
A . from = whotoldme ;
1999-03-17 18:20:23 +08:00
1999-11-04 22:39:51 +08:00
/* No need to look if destination looks valid - ie not net 0 or 127 -- core will do for us. */
1999-03-17 18:20:23 +08:00
1998-10-21 00:12:43 +08:00
neighbor = neigh_find ( p , & A . gw , 0 ) ;
if ( ! neighbor ) {
1999-10-11 22:19:29 +08:00
log ( L_ERR " %I asked me to route %I/%d using not-neighbor %I. " , A . from , b - > network , pxlen , A . gw ) ;
1998-10-21 00:12:43 +08:00
return ;
}
A . iface = neighbor - > iface ;
1999-03-17 18:20:23 +08:00
if ( ! ( rif = neighbor - > data ) ) {
rif = neighbor - > data = find_interface ( p , A . iface ) ;
1998-12-10 04:08:57 +08:00
}
1999-03-17 18:20:23 +08:00
if ( ! rif ) {
bug ( " Route packet using unknown interface? No. " ) ;
return ;
}
1998-10-13 22:32:18 +08:00
/* set to: interface of nexthop */
a = rta_lookup ( & A ) ;
1999-10-11 22:19:29 +08:00
if ( pxlen = = - 1 ) {
log ( L_ERR " %I gave me invalid pxlen/netmask for %I. " , A . from , b - > network ) ;
1999-03-17 18:20:23 +08:00
return ;
}
1999-10-11 22:19:29 +08:00
n = net_get ( p - > table , b - > network , pxlen ) ;
1998-10-13 22:32:18 +08:00
r = rte_get_temp ( a ) ;
1999-06-01 03:43:08 +08:00
r - > u . rip . metric = ntohl ( b - > metric ) + rif - > patt - > metric ;
1999-02-15 21:34:43 +08:00
if ( r - > u . rip . metric > P_CF - > infinity ) r - > u . rip . metric = P_CF - > infinity ;
1998-10-13 22:32:18 +08:00
r - > u . rip . tag = ntohl ( b - > tag ) ;
1998-10-21 00:12:43 +08:00
r - > net = n ;
1998-10-13 22:32:18 +08:00
r - > pflags = 0 ; /* Here go my flags */
1999-05-18 04:16:53 +08:00
rte_update ( p - > table , n , p , r ) ;
1998-12-10 04:08:57 +08:00
DBG ( " done \n " ) ;
1998-10-13 22:32:18 +08:00
}
1998-07-10 03:39:04 +08:00
static void
process_block ( struct proto * p , struct rip_block * block , ip_addr whotoldme )
{
int metric = ntohl ( block - > metric ) ;
1998-07-29 05:44:11 +08:00
ip_addr network = block - > network ;
1998-07-10 03:39:04 +08:00
CHK_MAGIC ;
1999-02-15 21:34:43 +08:00
if ( ( ! metric ) | | ( metric > P_CF - > infinity ) ) {
1998-12-20 22:29:06 +08:00
log ( L_WARN " Got metric %d from %I " , metric , whotoldme ) ;
1998-07-10 03:39:04 +08:00
return ;
}
1999-10-11 22:19:29 +08:00
debug ( " block: %I tells me: %I/??? available, metric %d... " , whotoldme , network , metric ) ;
1998-07-10 03:39:04 +08:00
1998-10-13 22:32:18 +08:00
advertise_entry ( p , block , whotoldme ) ;
1998-07-10 03:39:04 +08:00
}
1999-02-09 06:50:32 +08:00
# define BAD( x ) { log( L_WARN "RIP / %s: " x, P_NAME ); return 1; }
1998-07-29 05:44:11 +08:00
static int
1998-07-10 03:39:04 +08:00
rip_process_packet ( struct proto * p , struct rip_packet * packet , int num , ip_addr whotoldme , int port )
{
int i ;
1999-11-04 22:26:18 +08:00
int native_class = 0 , authenticated = 0 ;
1998-07-10 03:39:04 +08:00
switch ( packet - > heading . version ) {
1998-12-10 04:08:57 +08:00
case RIP_V1 : DBG ( " Rip1: " ) ; break ;
case RIP_V2 : DBG ( " Rip2: " ) ; break ;
1998-07-10 03:39:04 +08:00
default : BAD ( " Unknown version " ) ;
}
switch ( packet - > heading . command ) {
1998-12-10 04:08:57 +08:00
case RIPCMD_REQUEST : DBG ( " Asked to send my routing table \n " ) ;
1999-08-18 21:19:33 +08:00
if ( P_CF - > honour = = HO_NEVER ) {
log ( L_WARN " They asked me to send routing table, but I was told not to do it \n " ) ;
return 0 ;
}
if ( ( P_CF - > honour = = HO_NEIGHBOUR ) & & ( ! neigh_find ( p , & whotoldme , 0 ) ) ) {
log ( L_WARN " They asked me to send routing table, but he is not my neighbour \n " ) ;
return 0 ;
}
rip_sendto ( p , whotoldme , port , HEAD ( P - > interfaces ) ) ; /* no broadcast */
1998-07-29 05:44:11 +08:00
break ;
1998-12-10 04:08:57 +08:00
case RIPCMD_RESPONSE : DBG ( " *** Rtable from %I \n " , whotoldme ) ;
1999-02-15 21:34:43 +08:00
if ( port ! = P_CF - > port ) {
1998-12-20 22:29:06 +08:00
log ( L_ERR " %I send me routing info from port %d " , whotoldme , port ) ;
1998-10-21 00:45:53 +08:00
#if 0
1998-07-29 05:44:11 +08:00
return 0 ;
1998-10-21 00:45:53 +08:00
# else
1998-12-20 22:29:06 +08:00
log ( L_ERR " ...ignoring " ) ;
1998-10-21 00:45:53 +08:00
# endif
1998-07-10 03:39:04 +08:00
}
if ( ! neigh_find ( p , & whotoldme , 0 ) ) {
1998-12-20 22:29:06 +08:00
log ( L_ERR " %I send me routing info but he is not my neighbour " , whotoldme ) ;
1999-10-02 18:44:48 +08:00
#if 0
1998-07-29 05:44:11 +08:00
return 0 ;
1999-10-02 18:44:48 +08:00
# else
log ( L_ERR " ...ignoring " ) ;
# endif
1998-07-10 03:39:04 +08:00
}
for ( i = 0 ; i < num ; i + + ) {
struct rip_block * block = & packet - > block [ i ] ;
if ( block - > family = = 0xffff )
if ( ! i ) {
1999-06-01 04:30:16 +08:00
if ( rip_incoming_authentication ( p , ( void * ) block , packet , num ) )
1998-12-20 22:29:06 +08:00
BAD ( " Authentication failed " ) ;
1999-11-04 22:26:18 +08:00
authenticated = 1 ;
1999-10-02 18:44:48 +08:00
}
1999-11-04 22:26:18 +08:00
if ( ( ! authenticated ) & & ( P_CF - > authtype ! = AT_NONE ) )
BAD ( " Packet is not authenticated and it should be " ) ;
1998-07-29 05:44:11 +08:00
ipa_ntoh ( block - > network ) ;
1999-10-11 22:19:29 +08:00
# ifndef IPV6
1998-07-29 05:44:11 +08:00
ipa_ntoh ( block - > netmask ) ;
ipa_ntoh ( block - > nexthop ) ;
1999-10-12 15:46:08 +08:00
if ( packet - > heading . version = = RIP_V1 )
block - > netmask = ipa_class_mask ( block - > network ) ;
1999-10-11 22:19:29 +08:00
# endif
1998-07-10 03:39:04 +08:00
process_block ( p , block , whotoldme ) ;
}
break ;
1998-10-08 03:33:50 +08:00
case RIPCMD_TRACEON :
1998-12-20 22:29:06 +08:00
case RIPCMD_TRACEOFF : BAD ( " I was asked for traceon/traceoff " ) ;
case 5 : BAD ( " Some Sun extension around here " ) ;
1998-07-10 03:39:04 +08:00
default : BAD ( " Unknown command " ) ;
}
rip_reply ( p ) ;
1998-07-29 05:44:11 +08:00
return 0 ;
1998-07-10 03:39:04 +08:00
}
1998-07-29 05:44:11 +08:00
static int
1998-07-10 03:39:04 +08:00
rip_rx ( sock * s , int size )
{
1998-10-26 23:35:19 +08:00
struct rip_interface * i = s - > data ;
struct proto * p = i - > proto ;
1998-07-10 03:39:04 +08:00
int num ;
CHK_MAGIC ;
1998-12-10 04:08:57 +08:00
DBG ( " RIP: message came: %d bytes \n " , size ) ;
1998-07-10 03:39:04 +08:00
size - = sizeof ( struct rip_packet_heading ) ;
if ( size < 0 ) BAD ( " Too small packet " ) ;
if ( size % sizeof ( struct rip_block ) ) BAD ( " Odd sized packet " ) ;
num = size / sizeof ( struct rip_block ) ;
if ( num > 25 ) BAD ( " Too many blocks " ) ;
rip_process_packet ( p , ( struct rip_packet * ) s - > rbuf , num , s - > faddr , s - > fport ) ;
1998-07-29 05:44:11 +08:00
return 1 ;
1998-07-10 03:39:04 +08:00
}
1998-07-29 05:44:11 +08:00
/*
* Interface to rest of bird
*/
1998-07-10 03:39:04 +08:00
static void
rip_dump_entry ( struct rip_entry * e )
{
1998-10-08 03:33:50 +08:00
debug ( " %I told me %d/%d ago: to %I/%d go via %I, metric %d " ,
1998-12-23 03:41:04 +08:00
e - > whotoldme , e - > updated - now , e - > changed - now , e - > n . prefix , e - > n . pxlen , e - > nexthop , e - > metric ) ;
1998-10-08 03:33:50 +08:00
if ( e - > flags & RIP_F_EXTERNAL ) debug ( " [external] " ) ;
debug ( " \n " ) ;
1998-07-10 03:39:04 +08:00
}
static void
rip_timer ( timer * t )
{
struct proto * p = t - > data ;
struct rip_entry * e , * et ;
CHK_MAGIC ;
1998-12-10 04:08:57 +08:00
DBG ( " RIP: tick tock \n " ) ;
1998-10-21 00:12:43 +08:00
WALK_LIST_DELSAFE ( e , et , P - > garbage ) {
rte * rte ;
rte = SKIP_BACK ( struct rte , u . rip . garbage , e ) ;
1998-12-10 04:08:57 +08:00
DBG ( " Garbage: " ) ; rte_dump ( rte ) ;
1998-10-21 00:12:43 +08:00
1999-11-10 19:52:36 +08:00
if ( now - rte - > lastmod > P_CF - > timeout_time ) {
1998-10-21 00:12:43 +08:00
debug ( " RIP: entry is too old: " ) ; rte_dump ( rte ) ;
1999-11-10 19:52:36 +08:00
e - > metric = P_CF - > infinity ;
}
if ( now - rte - > lastmod > P_CF - > garbage_time ) {
debug ( " RIP: entry is much too old: " ) ; rte_dump ( rte ) ;
1999-05-18 04:16:53 +08:00
rte_discard ( p - > table , rte ) ;
1998-10-21 00:12:43 +08:00
}
1998-07-10 03:39:04 +08:00
}
1998-07-29 05:44:11 +08:00
1999-11-10 19:52:36 +08:00
/* FIXME: we need to do triggered updates */
1998-12-10 04:08:57 +08:00
DBG ( " RIP: Broadcasting routing tables \n " ) ;
1998-10-21 00:12:43 +08:00
{
1998-12-23 03:41:04 +08:00
struct rip_interface * rif ;
1998-10-26 23:35:19 +08:00
1998-12-23 03:41:04 +08:00
WALK_LIST ( rif , P - > interfaces ) {
struct iface * iface = rif - > iface ;
1998-07-29 05:44:11 +08:00
1998-12-23 03:41:04 +08:00
if ( ! iface ) continue ;
1999-05-11 17:53:45 +08:00
if ( rif - > patt - > mode & IM_QUIET ) continue ;
1998-10-21 00:12:43 +08:00
if ( ! ( iface - > flags & IF_UP ) ) continue ;
1998-12-23 03:41:04 +08:00
rip_sendto ( p , IPA_NONE , 0 , rif ) ;
1998-10-21 00:12:43 +08:00
}
}
1998-10-08 03:33:50 +08:00
1998-12-10 04:08:57 +08:00
DBG ( " RIP: tick tock done \n " ) ;
1998-07-10 03:39:04 +08:00
}
1999-02-09 06:50:32 +08:00
static int
1998-07-10 03:39:04 +08:00
rip_start ( struct proto * p )
{
1998-12-23 03:41:04 +08:00
struct rip_interface * rif ;
1998-12-10 04:08:57 +08:00
DBG ( " RIP: starting instance... \n " ) ;
1998-07-10 03:39:04 +08:00
P - > magic = RIP_MAGIC ;
1998-12-23 03:41:04 +08:00
fib_init ( & P - > rtable , p - > pool , sizeof ( struct rip_entry ) , 0 , NULL ) ;
1998-07-10 03:39:04 +08:00
init_list ( & P - > connections ) ;
1998-10-21 00:12:43 +08:00
init_list ( & P - > garbage ) ;
1998-10-26 23:35:19 +08:00
init_list ( & P - > interfaces ) ;
1998-07-10 03:39:04 +08:00
P - > timer = tm_new ( p - > pool ) ;
P - > timer - > data = p ;
P - > timer - > randomize = 5 ;
1999-02-15 21:34:43 +08:00
P - > timer - > recurrent = P_CF - > period ;
1998-07-10 03:39:04 +08:00
P - > timer - > hook = rip_timer ;
1998-07-29 05:44:11 +08:00
tm_start ( P - > timer , 5 ) ;
1999-05-11 17:53:45 +08:00
rif = new_iface ( p , NULL , 0 , NULL ) ; /* Initialize dummy interface */
1998-12-23 03:41:04 +08:00
add_head ( & P - > interfaces , NODE rif ) ;
1998-10-15 23:12:24 +08:00
CHK_MAGIC ;
1998-07-10 03:39:04 +08:00
1999-03-17 21:05:25 +08:00
rip_init_instance ( p ) ;
1998-12-10 04:08:57 +08:00
DBG ( " RIP: ...done \n " ) ;
1999-02-09 06:50:32 +08:00
return PS_UP ;
1998-07-10 03:39:04 +08:00
}
1999-02-09 06:50:32 +08:00
static struct proto *
rip_init ( struct proto_config * cfg )
1998-07-10 03:39:04 +08:00
{
1999-03-02 05:18:01 +08:00
struct proto * p = proto_new ( cfg , sizeof ( struct rip_proto ) ) ;
1999-02-09 06:50:32 +08:00
return p ;
1998-07-10 03:39:04 +08:00
}
static void
rip_dump ( struct proto * p )
{
int i ;
node * w , * e ;
1998-10-26 23:35:19 +08:00
struct rip_interface * rif ;
1998-07-10 03:39:04 +08:00
i = 0 ;
1999-03-02 05:18:01 +08:00
CHK_MAGIC ;
1998-07-10 03:39:04 +08:00
WALK_LIST ( w , P - > connections ) {
1998-07-29 05:44:11 +08:00
struct rip_connection * n = ( void * ) w ;
debug ( " RIP: connection #%d: %I \n " , n - > num , n - > addr ) ;
1998-07-10 03:39:04 +08:00
}
i = 0 ;
1998-12-23 03:41:04 +08:00
FIB_WALK ( & P - > rtable , e ) {
1998-07-10 03:39:04 +08:00
debug ( " RIP: entry #%d: " , i + + ) ;
rip_dump_entry ( E ) ;
1998-12-23 03:41:04 +08:00
} FIB_WALK_END ;
1998-10-26 23:35:19 +08:00
i = 0 ;
WALK_LIST ( rif , P - > interfaces ) {
1998-12-09 23:22:40 +08:00
debug ( " RIP: interface #%d: %s, %I, busy = %x \n " , i + + , rif - > iface ? rif - > iface - > name : " (dummy) " , rif - > sock - > daddr , rif - > busy ) ;
1998-10-26 23:35:19 +08:00
}
}
static int
rip_want_this_if ( struct rip_interface * iface )
{
return 1 ;
}
static void
kill_iface ( struct proto * p , struct rip_interface * i )
{
1998-12-10 04:08:57 +08:00
DBG ( " RIP: Interface %s disappeared \n " , i - > iface - > name ) ;
1998-10-26 23:35:19 +08:00
rfree ( i - > sock ) ;
mb_free ( i ) ;
}
1998-12-09 23:22:40 +08:00
/*
* new maybe null if we are creating initial send socket
*/
1999-06-01 04:30:16 +08:00
static struct rip_interface *
1999-05-11 17:53:45 +08:00
new_iface ( struct proto * p , struct iface * new , unsigned long flags , struct iface_patt * patt )
1998-10-26 23:35:19 +08:00
{
1998-12-09 23:22:40 +08:00
struct rip_interface * rif ;
1999-05-11 17:53:45 +08:00
int want_multicast = 0 ;
1998-12-09 23:22:40 +08:00
1999-06-01 03:37:16 +08:00
rif = mb_allocz ( p - > pool , sizeof ( struct rip_interface ) ) ;
1998-12-09 23:22:40 +08:00
rif - > iface = new ;
rif - > proto = p ;
1998-12-23 03:41:04 +08:00
rif - > busy = NULL ;
1999-05-11 17:53:45 +08:00
rif - > patt = ( struct rip_patt * ) patt ;
1998-12-09 23:22:40 +08:00
1999-05-11 17:53:45 +08:00
if ( rif - > patt )
want_multicast = ( ! ( rif - > patt - > mode & IM_BROADCAST ) ) & & ( flags & IF_MULTICAST ) ;
/* lookup multicasts over unnumbered links - no: rip is not defined over unnumbered links */
1998-12-09 23:22:40 +08:00
1999-06-01 04:30:16 +08:00
if ( want_multicast )
DBG ( " Doing multicasts! \n " ) ;
1998-12-09 23:22:40 +08:00
rif - > sock = sk_new ( p - > pool ) ;
rif - > sock - > type = want_multicast ? SK_UDP_MC : SK_UDP ;
1999-02-15 21:34:43 +08:00
rif - > sock - > sport = P_CF - > port ;
1998-12-09 23:22:40 +08:00
rif - > sock - > rx_hook = rip_rx ;
rif - > sock - > data = rif ;
rif - > sock - > rbsize = 10240 ;
1998-12-23 03:41:04 +08:00
rif - > sock - > iface = new ; /* Automagically works for dummy interface */
1998-12-09 23:22:40 +08:00
rif - > sock - > tbuf = mb_alloc ( p - > pool , sizeof ( struct rip_packet ) ) ;
rif - > sock - > tx_hook = rip_tx ;
rif - > sock - > err_hook = rip_tx_err ;
rif - > sock - > daddr = IPA_NONE ;
1999-02-15 21:34:43 +08:00
rif - > sock - > dport = P_CF - > port ;
1999-08-18 21:19:33 +08:00
if ( new )
rif - > sock - > ttl = 1 ;
else
rif - > sock - > ttl = 30 ;
1999-06-01 21:57:24 +08:00
rif - > sock - > tos = IP_PREC_INTERNET_CONTROL ;
1998-12-09 23:22:40 +08:00
if ( flags & IF_BROADCAST )
1999-05-07 05:38:11 +08:00
rif - > sock - > daddr = new - > addr - > brd ;
1999-10-02 18:44:48 +08:00
if ( flags & IF_UNNUMBERED ) {
1999-05-07 05:38:11 +08:00
rif - > sock - > daddr = new - > addr - > opposite ;
1999-10-02 18:44:48 +08:00
log ( L_WARN " RIP/%s: rip is not defined over unnumbered links \n " , P_NAME ) ;
}
1999-06-01 04:34:48 +08:00
if ( want_multicast ) {
rif - > sock - > daddr = ipa_from_u32 ( 0xe0000009 ) ;
rif - > sock - > saddr = ipa_from_u32 ( 0xe0000009 ) ;
}
1998-12-09 23:22:40 +08:00
1999-05-11 17:53:45 +08:00
if ( ! ipa_nonzero ( rif - > sock - > daddr ) ) {
log ( L_WARN " RIP/%s: interface %s is too strange for me " , P_NAME , rif - > iface ? rif - > iface - > name : " (dummy) " ) ;
} else
if ( ! ( rif - > patt - > mode & IM_NOLISTEN ) )
1999-06-01 04:30:16 +08:00
if ( sk_open ( rif - > sock ) < 0 ) {
1999-08-18 21:19:33 +08:00
log ( L_ERR " RIP/%s: could not listen on %s " , P_NAME , rif - > iface ? rif - > iface - > name : " (dummy) " ) ;
/* Don't try to transmit into this one? Well, why not? This should not happen, anyway :-) */
1999-06-01 04:30:16 +08:00
}
1999-10-02 18:44:48 +08:00
log ( L_DEBUG " RIP/%s: listening on %s, port %d, mode %s (%I) " , P_NAME , rif - > iface ? rif - > iface - > name : " (dummy) " , P_CF - > port , want_multicast ? " multicast " : " broadcast " , rif - > sock - > daddr ) ;
1998-10-26 23:35:19 +08:00
1998-12-09 23:22:40 +08:00
return rif ;
1998-07-10 03:39:04 +08:00
}
1998-07-29 05:44:11 +08:00
static void
1999-05-07 05:38:11 +08:00
rip_if_notify ( struct proto * p , unsigned c , struct iface * iface )
1998-07-29 05:44:11 +08:00
{
1998-12-10 04:08:57 +08:00
DBG ( " RIP: if notify \n " ) ;
1999-05-07 05:38:11 +08:00
if ( iface - > flags & IF_IGNORE )
return ;
if ( c & IF_CHANGE_DOWN ) {
1998-10-26 23:35:19 +08:00
struct rip_interface * i ;
1999-05-07 05:38:11 +08:00
i = find_interface ( p , iface ) ;
1998-12-04 19:45:51 +08:00
if ( i ) {
rem_node ( NODE i ) ;
kill_iface ( p , i ) ;
}
1998-10-26 23:35:19 +08:00
}
1999-05-07 05:38:11 +08:00
if ( c & IF_CHANGE_UP ) {
1998-12-09 23:22:40 +08:00
struct rip_interface * rif ;
1999-05-07 05:38:11 +08:00
struct iface_patt * k = iface_patt_match ( & P_CF - > iface_list , iface ) ;
1998-12-04 19:45:51 +08:00
if ( ! k ) return ; /* We are not interested in this interface */
1999-05-07 05:38:11 +08:00
DBG ( " adding interface %s \n " , iface - > name ) ;
1999-05-11 17:53:45 +08:00
rif = new_iface ( p , iface , iface - > flags , k ) ;
1998-12-09 23:22:40 +08:00
add_head ( & P - > interfaces , NODE rif ) ;
1998-10-26 23:35:19 +08:00
}
1998-07-29 05:44:11 +08:00
}
1999-06-01 03:16:22 +08:00
static struct ea_list *
rip_gen_attrs ( struct proto * p , struct linpool * pool , int metric , u16 tag )
{
struct ea_list * l = lp_alloc ( pool , sizeof ( struct ea_list ) + 2 * sizeof ( eattr ) ) ;
l - > next = NULL ;
l - > flags = EALF_SORTED ;
l - > count = 2 ;
l - > attrs [ 0 ] . id = EA_RIP_TAG ;
l - > attrs [ 0 ] . flags = 0 ;
l - > attrs [ 0 ] . type = EAF_TYPE_INT | EAF_INLINE ;
l - > attrs [ 0 ] . u . data = tag ;
l - > attrs [ 1 ] . id = EA_RIP_TAG ;
l - > attrs [ 1 ] . flags = 0 ;
l - > attrs [ 1 ] . type = EAF_TYPE_INT | EAF_INLINE ;
l - > attrs [ 1 ] . u . data = metric ;
return l ;
}
static int
rip_import_control ( struct proto * p , struct rte * * rt , struct ea_list * * attrs , struct linpool * pool )
{
if ( ( * rt ) - > attrs - > proto = = p ) /* My own must not be touched */
return 1 ;
if ( ( * rt ) - > attrs - > source ! = RTS_RIP ) {
struct ea_list * new = rip_gen_attrs ( p , pool , 1 , 0 ) ;
new - > next = * attrs ;
* attrs = new ;
}
return 0 ;
}
static struct ea_list *
rip_make_tmp_attrs ( struct rte * rt , struct linpool * pool )
{
struct proto * p = rt - > attrs - > proto ;
return rip_gen_attrs ( p , pool , rt - > u . rip . metric , rt - > u . rip . tag ) ;
}
static void
rip_store_tmp_attrs ( struct rte * rt , struct ea_list * attrs )
{
struct proto * p = rt - > attrs - > proto ;
rt - > u . rip . tag = ea_find ( attrs , EA_RIP_TAG ) - > u . data ;
rt - > u . rip . metric = ea_find ( attrs , EA_RIP_TAG ) - > u . data ;
}
1998-10-08 03:33:50 +08:00
static void
1999-06-01 03:16:22 +08:00
rip_rt_notify ( struct proto * p , struct network * net , struct rte * new , struct rte * old , struct ea_list * attrs )
1998-10-08 03:33:50 +08:00
{
1998-10-15 23:12:24 +08:00
CHK_MAGIC ;
1998-10-08 03:33:50 +08:00
if ( old ) {
1998-12-23 03:41:04 +08:00
struct rip_entry * e = fib_find ( & P - > rtable , & net - > n . prefix , net - > n . pxlen ) ;
1998-10-08 03:33:50 +08:00
if ( ! e )
1998-12-23 03:41:04 +08:00
log ( L_BUG " Deleting nonexistent entry?! " ) ;
fib_delete ( & P - > rtable , e ) ;
1998-10-08 03:33:50 +08:00
}
if ( new ) {
1998-12-23 03:41:04 +08:00
struct rip_entry * e ;
if ( fib_find ( & P - > rtable , & net - > n . prefix , net - > n . pxlen ) )
log ( L_BUG " Inserting entry which is already there? " ) ;
e = fib_get ( & P - > rtable , & net - > n . prefix , net - > n . pxlen ) ;
1998-10-08 03:33:50 +08:00
1998-10-17 18:25:22 +08:00
e - > nexthop = new - > attrs - > gw ;
1999-06-01 03:16:22 +08:00
e - > tag = ea_find ( attrs , EA_RIP_TAG ) - > u . data ;
e - > metric = ea_find ( attrs , EA_RIP_TAG ) - > u . data ;
if ( e - > metric > P_CF - > infinity )
e - > metric = P_CF - > infinity ;
if ( ! e - > metric )
e - > metric = 1 ;
1998-10-17 18:25:22 +08:00
e - > whotoldme = new - > attrs - > from ;
1998-10-08 03:33:50 +08:00
e - > updated = e - > changed = now ;
1998-10-13 22:32:18 +08:00
e - > flags = 0 ;
1998-10-08 03:33:50 +08:00
}
}
1998-10-21 00:12:43 +08:00
static int
1998-10-13 22:32:18 +08:00
rip_rte_better ( struct rte * new , struct rte * old )
{
1999-11-10 19:52:36 +08:00
if ( ipa_equal ( old - > attrs - > from , new - > attrs - > from ) )
return 1 ;
1998-10-13 22:32:18 +08:00
if ( old - > u . rip . metric < new - > u . rip . metric )
return 0 ;
if ( old - > u . rip . metric > new - > u . rip . metric )
return 1 ;
1999-11-10 19:52:36 +08:00
if ( ( old - > u . rip . metric = = new - > u . rip . metric ) & &
( ( now - old - > lastmod ) > 60 ) ) /* FIXME (nonurgent): this probably should be P_CF->timeout_time / 2 if old->attrs->proto == new->attrs->proto, else don't do this check */
1998-10-13 22:32:18 +08:00
return 1 ;
return 0 ;
}
1998-10-21 00:12:43 +08:00
static void
rip_rte_insert ( net * net , rte * rte )
{
struct proto * p = rte - > attrs - > proto ;
add_head ( & P - > garbage , & rte - > u . rip . garbage ) ;
}
static void
rip_rte_remove ( net * net , rte * rte )
{
struct proto * p = rte - > attrs - > proto ;
rem_node ( & rte - > u . rip . garbage ) ;
}
1998-11-28 05:08:37 +08:00
void
rip_init_instance ( struct proto * p )
1998-07-10 03:39:04 +08:00
{
1998-10-21 00:12:43 +08:00
p - > preference = DEF_PREF_RIP ;
1998-07-10 03:39:04 +08:00
p - > if_notify = rip_if_notify ;
1998-10-08 03:33:50 +08:00
p - > rt_notify = rip_rt_notify ;
1999-06-01 03:16:22 +08:00
p - > import_control = rip_import_control ;
1999-06-01 04:30:16 +08:00
p - > make_tmp_attrs = rip_make_tmp_attrs ;
p - > store_tmp_attrs = rip_store_tmp_attrs ;
1998-10-13 22:32:18 +08:00
p - > rte_better = rip_rte_better ;
1998-10-21 00:12:43 +08:00
p - > rte_insert = rip_rte_insert ;
p - > rte_remove = rip_rte_remove ;
1999-03-02 05:18:01 +08:00
}
1998-12-04 19:45:51 +08:00
1999-03-02 05:18:01 +08:00
void
rip_init_config ( struct rip_proto_config * c )
{
init_list ( & c - > iface_list ) ;
c - > infinity = 16 ;
c - > port = 520 ;
c - > period = 30 ;
c - > garbage_time = 120 + 180 ;
1999-11-10 19:52:36 +08:00
c - > timeout_time = 120 ;
1999-05-26 22:37:47 +08:00
c - > passwords = NULL ;
1999-05-11 17:53:45 +08:00
c - > authtype = AT_NONE ;
1998-07-10 03:39:04 +08:00
}
1998-11-28 05:08:37 +08:00
static void
1999-02-09 06:50:32 +08:00
rip_preconfig ( struct protocol * x , struct config * c )
1998-11-28 05:08:37 +08:00
{
1998-12-10 04:08:57 +08:00
DBG ( " RIP: preconfig \n " ) ;
1998-11-28 05:08:37 +08:00
}
1998-07-10 03:39:04 +08:00
static void
1999-02-09 06:50:32 +08:00
rip_postconfig ( struct proto_config * c )
1998-07-10 03:39:04 +08:00
{
}
struct protocol proto_rip = {
1999-02-09 06:50:32 +08:00
name : " RIP " ,
preconfig : rip_preconfig ,
postconfig : rip_postconfig ,
init : rip_init ,
dump : rip_dump ,
start : rip_start ,
1998-07-10 03:39:04 +08:00
} ;