mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2024-12-23 02:01:55 +00:00
361 lines
8.4 KiB
C
361 lines
8.4 KiB
C
/*
|
|
* BIRD -- OSPF Topological Database
|
|
*
|
|
* (c) 1999 Martin Mares <mj@ucw.cz>
|
|
* (c) 1999 - 2000 Ondrej Filip <feela@network.cz>
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
#define LOCAL_DEBUG
|
|
|
|
#include <string.h>
|
|
|
|
#include "nest/bird.h"
|
|
|
|
#include "ospf.h"
|
|
|
|
#define HASH_DEF_ORDER 6 /* FIXME: Increase */
|
|
#define HASH_HI_MARK *4
|
|
#define HASH_HI_STEP 2
|
|
#define HASH_HI_MAX 16
|
|
#define HASH_LO_MARK /5
|
|
#define HASH_LO_STEP 2
|
|
#define HASH_LO_MIN 8
|
|
|
|
void
|
|
make_rt_lsa(struct ospf_area *oa, struct proto_ospf *p)
|
|
{
|
|
struct ospf_iface *ifa;
|
|
int i=0,j=0,k=0,v=0,e=0,b=0;
|
|
struct ospf_lsa_rt *rt;
|
|
struct ospf_lsa_rt_link *ln;
|
|
struct ospf_neighbor *neigh;
|
|
struct top_hash_entry *old;
|
|
|
|
old=oa->rt;
|
|
|
|
WALK_LIST (ifa, p->iface_list) i++;
|
|
{
|
|
if((ifa->an==oa->areaid) && (ifa->state!=OSPF_IS_DOWN))
|
|
{
|
|
i++;
|
|
if(ifa->type==OSPF_IT_VLINK) v=1;
|
|
}
|
|
}
|
|
rt=mb_allocz(p->proto.pool, sizeof(struct ospf_lsa_rt)+
|
|
i*sizeof(struct ospf_lsa_rt_link));
|
|
if((p->areano>1) && (!oa->stub)) e=1;
|
|
rt->VEB=(v>>LSA_RT_V)+(e>>LSA_RT_E)+(b>>LSA_RT_B);
|
|
ln=(struct ospf_lsa_rt_link *)(rt+1);
|
|
|
|
WALK_LIST (ifa, p->iface_list)
|
|
{
|
|
if((ifa->an==oa->areaid) && (ifa->state!=OSPF_IS_DOWN))
|
|
{
|
|
if(ifa->state==OSPF_IS_LOOP)
|
|
{
|
|
ln->type=3;
|
|
ln->id=ipa_to_u32(ifa->iface->addr->ip);
|
|
ln->data=0xffffffff;
|
|
ln->metric=0;
|
|
ln->notos=0;
|
|
}
|
|
else
|
|
{
|
|
switch(ifa->type)
|
|
{
|
|
case OSPF_IT_PTP: /* rfc2328 - pg126 */
|
|
neigh=(struct ospf_neighbor *)HEAD(ifa->neigh_list);
|
|
if((neigh!=NULL) || (neigh->state==NEIGHBOR_FULL))
|
|
{
|
|
ln->type=LSART_PTP;
|
|
ln->id=neigh->rid;
|
|
ln->metric=ifa->cost;
|
|
ln->notos=0;
|
|
if(ifa->iface->flags && IA_UNNUMBERED)
|
|
{
|
|
ln->data=ifa->iface->index;
|
|
}
|
|
else
|
|
{
|
|
ln->id=ipa_to_u32(ifa->iface->addr->ip);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(ifa->state==OSPF_IS_PTP)
|
|
{
|
|
ln->type=LSART_STUB;
|
|
ln->id=ln->id=ipa_to_u32(ifa->iface->addr->opposite);
|
|
ln->metric=ifa->cost;
|
|
ln->notos=0;
|
|
ln->data=0xffffffff;
|
|
}
|
|
else
|
|
{
|
|
i--; /* No link added */
|
|
}
|
|
}
|
|
break;
|
|
case OSPF_IT_BCAST: /*FIXME Go on */
|
|
case OSPF_IT_NBMA:
|
|
if(ifa->state==OSPF_IS_WAITING)
|
|
{
|
|
ln->type=LSART_STUB;
|
|
ln->id=ipa_to_u32(ifa->iface->addr->prefix);
|
|
ln->data=ipa_to_u32(ipa_mkmask(ifa->iface->addr->pxlen));
|
|
ln->metric=ifa->cost;
|
|
ln->notos=0;
|
|
}
|
|
else
|
|
{
|
|
j=0,k=0;
|
|
WALK_LIST(neigh, ifa->neigh_list)
|
|
{
|
|
if((neigh->rid==ifa->drid) &&
|
|
(neigh->state==NEIGHBOR_FULL)) k=1;
|
|
if(neigh->state==NEIGHBOR_FULL) j=1;
|
|
}
|
|
if(((ifa->state=OSPF_IS_DR) && (j==1)) || (k==1))
|
|
{
|
|
ln->type=LSART_NET;
|
|
ln->id=ipa_to_u32(ifa->drip);
|
|
ln->data=ipa_to_u32(ifa->iface->addr->ip);
|
|
ln->metric=ifa->cost;
|
|
ln->notos=0;
|
|
}
|
|
else
|
|
{
|
|
ln->type=LSART_STUB;
|
|
ln->id=ipa_to_u32(ifa->iface->addr->prefix);
|
|
ln->data=ipa_to_u32(ipa_mkmask(ifa->iface->addr->pxlen));
|
|
ln->metric=ifa->cost;
|
|
ln->notos=0;
|
|
}
|
|
}
|
|
break;
|
|
case OSPF_IT_VLINK: /* FIXME Add virtual links! */
|
|
i--;
|
|
break;
|
|
}
|
|
}
|
|
if(ifa->type==OSPF_IT_VLINK) v=1;
|
|
}
|
|
ln=(ln+1);
|
|
}
|
|
rt->links=i;
|
|
if(old->lsa_body!=NULL) mb_free(old->lsa_body);
|
|
old->lsa_body=rt;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
addifa_rtlsa(struct ospf_iface *ifa)
|
|
{
|
|
struct ospf_area *oa;
|
|
struct proto_ospf *po;
|
|
u32 rtid;
|
|
struct top_hash_entry *rt;
|
|
struct top_graph_rtlsa_link *li, *lih;
|
|
|
|
po=ifa->proto;
|
|
oa=po->firstarea;
|
|
rtid=po->proto.cf->global->router_id;
|
|
|
|
while(oa!=NULL)
|
|
{
|
|
if(oa->areaid==ifa->an) break;
|
|
oa=oa->next;
|
|
}
|
|
|
|
ifa->oa=oa;
|
|
|
|
if(oa==NULL) /* New area */
|
|
{
|
|
oa=po->firstarea;
|
|
po->firstarea=mb_alloc(po->proto.pool, sizeof(struct ospf_area));
|
|
po->firstarea->next=oa;
|
|
oa=po->firstarea;
|
|
oa->areaid=ifa->an;
|
|
oa->gr=ospf_top_new(po);
|
|
s_init_list(&(oa->lsal));
|
|
oa->rt=ospf_hash_get(oa->gr, rtid, rtid, LSA_T_RT);
|
|
s_add_head(&(oa->lsal), (snode *)oa->rt);
|
|
oa->rt->lsa_body=NULL;
|
|
oa->rt->lsa.age=0;
|
|
oa->rt->lsa.sn=LSA_INITSEQNO-1; /* FIXME Check it latter */
|
|
DBG("%s: New OSPF area \"%d\" added.\n", po->proto.name, ifa->an);
|
|
|
|
}
|
|
make_rt_lsa(oa, po);
|
|
/*FIXME seq no++ */
|
|
/*FIXME lsa_flood(oa->rt) */
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
ospf_top_ht_alloc(struct top_graph *f)
|
|
{
|
|
f->hash_size = 1 << f->hash_order;
|
|
f->hash_mask = f->hash_size - 1;
|
|
if (f->hash_order > HASH_HI_MAX - HASH_HI_STEP)
|
|
f->hash_entries_max = ~0;
|
|
else
|
|
f->hash_entries_max = f->hash_size HASH_HI_MARK;
|
|
if (f->hash_order < HASH_LO_MIN + HASH_LO_STEP)
|
|
f->hash_entries_min = 0;
|
|
else
|
|
f->hash_entries_min = f->hash_size HASH_LO_MARK;
|
|
DBG("Allocating OSPF hash of order %d: %d hash_entries, %d low, %d high\n",
|
|
f->hash_order, f->hash_size, f->hash_entries_min, f->hash_entries_max);
|
|
f->hash_table = mb_alloc(f->pool, f->hash_size * sizeof(struct top_hash_entry *));
|
|
bzero(f->hash_table, f->hash_size * sizeof(struct top_hash_entry *));
|
|
}
|
|
|
|
static inline void
|
|
ospf_top_ht_free(struct top_hash_entry **h)
|
|
{
|
|
mb_free(h);
|
|
}
|
|
|
|
static inline u32
|
|
ospf_top_hash_u32(u32 a)
|
|
{
|
|
/* Shamelessly stolen from IP address hashing in ipv4.h */
|
|
a ^= a >> 16;
|
|
a ^= a << 10;
|
|
return a;
|
|
}
|
|
|
|
static inline unsigned
|
|
ospf_top_hash(struct top_graph *f, u32 lsaid, u32 rtrid, u32 type)
|
|
{
|
|
return (ospf_top_hash_u32(lsaid) + ospf_top_hash_u32(rtrid) + type) & f->hash_mask;
|
|
}
|
|
|
|
struct top_graph *
|
|
ospf_top_new(struct proto_ospf *p)
|
|
{
|
|
struct top_graph *f;
|
|
|
|
f = mb_allocz(p->proto.pool, sizeof(struct top_graph));
|
|
f->pool = p->proto.pool;
|
|
f->hash_slab = sl_new(f->pool, sizeof(struct top_hash_entry));
|
|
f->hash_order = HASH_DEF_ORDER;
|
|
ospf_top_ht_alloc(f);
|
|
f->hash_entries = 0;
|
|
f->hash_entries_min = 0;
|
|
return f;
|
|
}
|
|
|
|
void
|
|
ospf_top_free(struct top_graph *f)
|
|
{
|
|
rfree(f->hash_slab);
|
|
ospf_top_ht_free(f->hash_table);
|
|
mb_free(f);
|
|
}
|
|
|
|
static void
|
|
ospf_top_rehash(struct top_graph *f, int step)
|
|
{
|
|
unsigned int oldn, oldh;
|
|
struct top_hash_entry **n, **oldt, **newt, *e, *x;
|
|
|
|
oldn = f->hash_size;
|
|
oldt = f->hash_table;
|
|
DBG("Re-hashing topology hash from order %d to %d\n", f->hash_order, f->hash_order+step);
|
|
f->hash_order += step;
|
|
ospf_top_ht_alloc(f);
|
|
newt = f->hash_table;
|
|
|
|
for(oldh=0; oldh < oldn; oldh++)
|
|
{
|
|
e = oldt[oldh];
|
|
while (e)
|
|
{
|
|
x = e->next;
|
|
n = newt + ospf_top_hash(f, e->lsa.id, e->lsa.rt, e->lsa.type);
|
|
e->next = *n;
|
|
*n = e;
|
|
e = x;
|
|
}
|
|
}
|
|
ospf_top_ht_free(oldt);
|
|
}
|
|
|
|
struct top_hash_entry *
|
|
ospf_hash_find(struct top_graph *f, u32 lsa, u32 rtr, u32 type)
|
|
{
|
|
struct top_hash_entry *e = f->hash_table[ospf_top_hash(f, lsa, rtr, type)];
|
|
|
|
while (e && (e->lsa.id != lsa || e->lsa.rt != rtr || e->lsa.type != type))
|
|
e = e->next;
|
|
return e;
|
|
}
|
|
|
|
struct top_hash_entry *
|
|
ospf_hash_get(struct top_graph *f, u32 lsa, u32 rtr, u32 type)
|
|
{
|
|
struct top_hash_entry **ee = f->hash_table + ospf_top_hash(f, lsa, rtr, type);
|
|
struct top_hash_entry *e = *ee;
|
|
|
|
while (e && (e->lsa.id != lsa || e->lsa.rt != rtr || e->lsa.type != type))
|
|
e = e->next;
|
|
if (e)
|
|
return e;
|
|
e = sl_alloc(f->hash_slab);
|
|
e->lsa.id = lsa;
|
|
e->lsa.rt = rtr;
|
|
e->lsa.type = type;
|
|
e->lsa_body = NULL;
|
|
e->next=*ee; /* MJ you forgot this :-) */
|
|
*ee=e;
|
|
if (f->hash_entries++ > f->hash_entries_max)
|
|
ospf_top_rehash(f, HASH_HI_STEP);
|
|
return e;
|
|
}
|
|
|
|
void
|
|
ospf_hash_delete(struct top_graph *f, struct top_hash_entry *e)
|
|
{
|
|
unsigned int h = ospf_top_hash(f, e->lsa.id, e->lsa.rt, e->lsa.type);
|
|
struct top_hash_entry **ee = f->hash_table + h;
|
|
|
|
while (*ee)
|
|
{
|
|
if (*ee == e)
|
|
{
|
|
*ee = e->next;
|
|
sl_free(f->hash_slab, e);
|
|
if (f->hash_entries-- < f->hash_entries_min)
|
|
ospf_top_rehash(f, -HASH_LO_STEP);
|
|
return;
|
|
}
|
|
ee = &((*ee)->next);
|
|
}
|
|
bug("ospf_hash_delete() called for invalid node");
|
|
}
|
|
|
|
void
|
|
ospf_top_dump(struct top_graph *f)
|
|
{
|
|
unsigned int i;
|
|
debug("Hash entries: %d\n", f->hash_entries);
|
|
|
|
for(i=0; i<f->hash_size; i++)
|
|
{
|
|
struct top_hash_entry *e = f->hash_table[i];
|
|
while (e)
|
|
{
|
|
debug("\t%04x %08x %08x %p\n", e->lsa.type, e->lsa.id,
|
|
e->lsa.rt, e->lsa_body);
|
|
e = e->next;
|
|
}
|
|
}
|
|
}
|
|
|