Gitiles
Code Review Sign In
gerrit.opencord.org / quagga / 872277f2745b4ca2938840559b3ddb15ce36ecca / . / ospf6d / ospf6_lsa.c
blob: b14979ffa27a503887a7b8cc3ef64a2aa1966025 [file] [log] [blame]
/*
* LSA function
* Copyright (C) 1999 Yasuhiro Ohara
*
* This file is part of GNU Zebra.
*
* GNU Zebra 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, or (at your option) any
* later version.
*
* GNU Zebra 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 GNU Zebra; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <zebra.h>
/* Include other stuffs */
#include "version.h"
#include "log.h"
#include "getopt.h"
#include "linklist.h"
#include "thread.h"
#include "command.h"
#include "memory.h"
#include "sockunion.h"
#include "if.h"
#include "prefix.h"
#include "stream.h"
#include "thread.h"
#include "filter.h"
#include "zclient.h"
#include "table.h"
#include "plist.h"
#include "ospf6_proto.h"
#include "ospf6_prefix.h"
#include "ospf6_lsa.h"
#include "ospf6_lsdb.h"
#include "ospf6_message.h"
#include "ospf6_dump.h"
#include "ospf6_top.h"
#include "ospf6_area.h"
#include "ospf6_interface.h"
#include "ospf6_neighbor.h"
#include "ospf6_ism.h"
#include "ospf6_nsm.h"
#include "ospf6_dbex.h"
#define HEADER_DEPENDENCY
#include "ospf6d.h"
#undef HEADER_DEPENDENCY
/* test LSAs identity */
static int
ospf6_lsa_issame (struct ospf6_lsa_header__ *lsh1,
struct ospf6_lsa_header__ *lsh2)
{
assert (lsh1 && lsh2);
if (lsh1->adv_router != lsh2->adv_router)
return 0;
if (lsh1->id != lsh2->id)
return 0;
if (lsh1->type != lsh2->type)
return 0;
return 1;
}
/* RFC2328: Section 13.2 */
int
ospf6_lsa_differ (struct ospf6_lsa *lsa1,
struct ospf6_lsa *lsa2)
{
int diff, cmplen;
if (! ospf6_lsa_issame (lsa1->header, lsa2->header))
return 1;
/* check Options field */
/* xxx */
ospf6_lsa_age_current (lsa1);
ospf6_lsa_age_current (lsa2);
if (ntohs (lsa1->header->age) == MAXAGE &&
ntohs (lsa2->header->age) != MAXAGE)
return 1;
if (ntohs (lsa1->header->age) != MAXAGE &&
ntohs (lsa2->header->age) == MAXAGE)
return 1;
/* compare body */
if (ntohs (lsa1->header->length) != ntohs (lsa2->header->length))
return 1;
cmplen = ntohs (lsa1->header->length) - sizeof (struct ospf6_lsa_header);
diff = memcmp (lsa1->header + 1, lsa2->header + 1, cmplen);
return diff;
}
int
ospf6_lsa_match (u_int16_t type, u_int32_t id, u_int32_t adv_router,
struct ospf6_lsa_header *lsh)
{
if (lsh->advrtr != adv_router)
return 0;
if (lsh->ls_id != id)
return 0;
if (lsh->type != type)
return 0;
return 1;
}
/* ospf6 age functions */
/* calculate birth and set expire timer */
static void
ospf6_lsa_age_set (struct ospf6_lsa *lsa)
{
struct timeval now;
assert (lsa && lsa->header);
if (gettimeofday (&now, (struct timezone *)NULL) < 0)
zlog_warn ("LSA: gettimeofday failed, may fail LSA AGEs: %s",
strerror (errno));
lsa->birth.tv_sec = now.tv_sec - ntohs (lsa->header->age);
lsa->birth.tv_usec = now.tv_usec;
if (ntohs (lsa->header->age) != MAXAGE)
lsa->expire = thread_add_timer (master, ospf6_lsa_expire, lsa,
lsa->birth.tv_sec + MAXAGE - now.tv_sec);
else
lsa->expire = NULL;
return;
}
/* this function calculates current age from its birth,
then update age field of LSA header. return value is current age */
u_int16_t
ospf6_lsa_age_current (struct ospf6_lsa *lsa)
{
struct timeval now;
u_int32_t ulage;
u_int16_t age;
assert (lsa);
assert (lsa->header);
/* current time */
if (gettimeofday (&now, (struct timezone *)NULL) < 0)
zlog_warn ("LSA: gettimeofday failed, may fail ages: %s",
strerror (errno));
/* calculate age */
ulage = now.tv_sec - lsa->birth.tv_sec;
/* if over MAXAGE, set to it */
if (ulage > MAXAGE)
age = MAXAGE;
else
age = ulage;
lsa->header->age = htons (age);
return age;
}
/* update age field of LSA header with adding InfTransDelay */
void
ospf6_lsa_age_update_to_send (struct ospf6_lsa *lsa, u_int32_t transdelay)
{
unsigned short age;
age = ospf6_lsa_age_current (lsa) + transdelay;
if (age > MAXAGE)
age = MAXAGE;
lsa->header->age = htons (age);
return;
}
void
ospf6_lsa_premature_aging (struct ospf6_lsa *lsa)
{
/* log */
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: Premature aging: %s", lsa->str);
if (lsa->expire)
thread_cancel (lsa->expire);
lsa->expire = (struct thread *) NULL;
if (lsa->refresh)
thread_cancel (lsa->refresh);
lsa->refresh = (struct thread *) NULL;
memset (&lsa->birth, 0, sizeof (struct timeval));
thread_execute (master, ospf6_lsa_expire, lsa, 0);
}
/* check which is more recent. if a is more recent, return -1;
if the same, return 0; otherwise(b is more recent), return 1 */
int
ospf6_lsa_check_recent (struct ospf6_lsa *a, struct ospf6_lsa *b)
{
signed long seqnuma, seqnumb;
u_int16_t cksuma, cksumb;
u_int16_t agea, ageb;
assert (a && a->header);
assert (b && b->header);
assert (ospf6_lsa_issame (a->header, b->header));
seqnuma = ((signed long) ntohl (a->header->seqnum))
- (signed long) INITIAL_SEQUENCE_NUMBER;
seqnumb = ((signed long) ntohl (b->header->seqnum))
- (signed long) INITIAL_SEQUENCE_NUMBER;
/* compare by sequence number */
/* xxx, care about LS sequence number wrapping */
recent_reason = "seqnum";
if (seqnuma > seqnumb)
return -1;
else if (seqnuma < seqnumb)
return 1;
/* Checksum */
cksuma = ntohs (a->header->checksum);
cksumb = ntohs (b->header->checksum);
if (cksuma > cksumb)
return -1;
if (cksuma < cksumb)
return 0;
/* Age check */
agea = ospf6_lsa_age_current (a);
ageb = ospf6_lsa_age_current (b);
/* MaxAge check */
recent_reason = "max age";
if (agea == OSPF6_LSA_MAXAGE && ageb != OSPF6_LSA_MAXAGE)
return -1;
else if (agea != OSPF6_LSA_MAXAGE && ageb == OSPF6_LSA_MAXAGE)
return 1;
recent_reason = "age differ";
if (agea > ageb && agea - ageb >= OSPF6_LSA_MAXAGEDIFF)
return 1;
else if (agea < ageb && ageb - agea >= OSPF6_LSA_MAXAGEDIFF)
return -1;
/* neither recent */
recent_reason = "the same instance";
return 0;
}
int
ospf6_lsa_lsd_num (struct ospf6_lsa_header *lsa_header)
{
int ldnum = 0;
u_int16_t len;
len = ntohs (lsa_header->length);
len -= sizeof (struct ospf6_lsa_header);
if (lsa_header->type == htons (OSPF6_LSA_TYPE_ROUTER))
{
len -= sizeof (struct ospf6_router_lsa);
ldnum = len / sizeof (struct ospf6_router_lsd);
}
else /* (lsa_header->type == htons (OSPF6_LSA_TYPE_NETWORK)) */
{
len -= sizeof (struct ospf6_network_lsa);
ldnum = len / sizeof (u_int32_t);
}
return ldnum;
}
void *
ospf6_lsa_lsd_get (int index, struct ospf6_lsa_header *lsa_header)
{
void *p;
struct ospf6_router_lsa *router_lsa;
struct ospf6_router_lsd *router_lsd;
struct ospf6_network_lsa *network_lsa;
struct ospf6_network_lsd *network_lsd;
if (lsa_header->type == htons (OSPF6_LSA_TYPE_ROUTER))
{
router_lsa = (struct ospf6_router_lsa *) (lsa_header + 1);
router_lsd = (struct ospf6_router_lsd *) (router_lsa + 1);
router_lsd += index;
p = (void *) router_lsd;
}
else if (lsa_header->type == htons (OSPF6_LSA_TYPE_NETWORK))
{
network_lsa = (struct ospf6_network_lsa *) (lsa_header + 1);
network_lsd = (struct ospf6_network_lsd *) (network_lsa + 1);
network_lsd += index;
p = (void *) network_lsd;
}
else
{
p = (void *) NULL;
}
return p;
}
/* network_lsd <-> router_lsd */
static int
ospf6_lsa_lsd_network_reference_match (struct ospf6_network_lsd *network_lsd1,
struct ospf6_lsa_header *lsa_header1,
struct ospf6_router_lsd *router_lsd2,
struct ospf6_lsa_header *lsa_header2)
{
if (network_lsd1->adv_router != lsa_header2->advrtr)
return 0;
if (router_lsd2->type != OSPF6_ROUTER_LSD_TYPE_TRANSIT_NETWORK)
return 0;
if (router_lsd2->neighbor_router_id != lsa_header1->advrtr)
return 0;
if (router_lsd2->neighbor_interface_id != lsa_header1->ls_id)
return 0;
return 1;
}
/* router_lsd <-> router_lsd */
static int
ospf6_lsa_lsd_router_reference_match (struct ospf6_router_lsd *router_lsd1,
struct ospf6_lsa_header *lsa_header1,
struct ospf6_router_lsd *router_lsd2,
struct ospf6_lsa_header *lsa_header2)
{
if (router_lsd1->type != OSPF6_ROUTER_LSD_TYPE_POINTTOPOINT)
return 0;
if (router_lsd2->type != OSPF6_ROUTER_LSD_TYPE_POINTTOPOINT)
return 0;
if (router_lsd1->neighbor_router_id != lsa_header2->advrtr)
return 0;
if (router_lsd2->neighbor_router_id != lsa_header1->advrtr)
return 0;
if (router_lsd1->neighbor_interface_id != router_lsd2->interface_id)
return 0;
if (router_lsd2->neighbor_interface_id != router_lsd1->interface_id)
return 0;
return 1;
}
int
ospf6_lsa_lsd_is_refer_ok (int index1, struct ospf6_lsa_header *lsa_header1,
int index2, struct ospf6_lsa_header *lsa_header2)
{
struct ospf6_router_lsd *r1, *r2;
struct ospf6_network_lsd *n;
r1 = (struct ospf6_router_lsd *) NULL;
r2 = (struct ospf6_router_lsd *) NULL;
n = (struct ospf6_network_lsd *) NULL;
if (lsa_header1->type == htons (OSPF6_LSA_TYPE_ROUTER))
r1 = (struct ospf6_router_lsd *) ospf6_lsa_lsd_get (index1, lsa_header1);
else
n = (struct ospf6_network_lsd *) ospf6_lsa_lsd_get (index1, lsa_header1);
if (lsa_header2->type == htons (OSPF6_LSA_TYPE_ROUTER))
r2 = (struct ospf6_router_lsd *) ospf6_lsa_lsd_get (index2, lsa_header2);
else
n = (struct ospf6_network_lsd *) ospf6_lsa_lsd_get (index2, lsa_header2);
if (r1 && r2)
return ospf6_lsa_lsd_router_reference_match (r1, lsa_header1,
r2, lsa_header2);
else if (r1 && n)
return ospf6_lsa_lsd_network_reference_match (n, lsa_header2,
r1, lsa_header1);
else if (n && r2)
return ospf6_lsa_lsd_network_reference_match (n, lsa_header1,
r2, lsa_header2);
return 0;
}
void
ospf6_lsa_show (struct vty *vty, struct ospf6_lsa *lsa)
{
char adv_router[64], id[64], type[32];
assert (lsa);
assert (lsa->header);
ospf6_lsa_type_string (lsa->header->type, type, sizeof (type));
inet_ntop (AF_INET, &lsa->header->id, id, sizeof (id));
inet_ntop (AF_INET, &lsa->header->adv_router,
adv_router, sizeof (adv_router));
vty_out (vty, "%s", VTY_NEWLINE);
vty_out (vty, "Age: %4hu Type: %s%s", ospf6_lsa_age_current (lsa),
type, VTY_NEWLINE);
vty_out (vty, "Link State ID: %s%s", id, VTY_NEWLINE);
vty_out (vty, "Advertising Router: %s%s", adv_router, VTY_NEWLINE);
vty_out (vty, "LS Sequence Number: %#lx%s", (u_long)ntohl (lsa->header->seqnum),
VTY_NEWLINE);
vty_out (vty, "CheckSum: %#hx Length: %hu%s", ntohs (lsa->header->checksum),
ntohs (lsa->header->length), VTY_NEWLINE);
{
struct ospf6_lsa_slot *slot;
slot = ospf6_lsa_slot_get (lsa->header->type);
if (slot)
{
(*slot->func_show) (vty, lsa);
vty_out (vty, "%s", VTY_NEWLINE);
return;
}
}
vty_out (vty, "%sUnknown LSA type ...%s", VTY_NEWLINE, VTY_NEWLINE);
}
void
ospf6_lsa_show_summary_header (struct vty *vty)
{
vty_out (vty, "%-12s %-15s %-15s %4s %8s %4s %4s %-8s%s",
"Type", "LSId", "AdvRouter", "Age", "SeqNum",
"Cksm", "Len", "Duration", VTY_NEWLINE);
}
void
ospf6_lsa_show_summary (struct vty *vty, struct ospf6_lsa *lsa)
{
char adv_router[16], id[16], type[16];
struct timeval now, res;
char duration[16];
assert (lsa);
assert (lsa->header);
memset (type, 0, sizeof (type));
ospf6_lsa_type_string (lsa->header->type, type, 13);
inet_ntop (AF_INET, &lsa->header->id, id, sizeof (id));
inet_ntop (AF_INET, &lsa->header->adv_router, adv_router,
sizeof (adv_router));
gettimeofday (&now, NULL);
ospf6_timeval_sub (&now, &lsa->installed, &res);
ospf6_timeval_string_summary (&res, duration, sizeof (duration));
vty_out (vty, "%-12s %-15s %-15s %4hu %8lx %04hx %4hu %8s%s",
type, id, adv_router, ospf6_lsa_age_current (lsa),
(u_long) ntohl (lsa->header->seqnum),
ntohs (lsa->header->checksum), ntohs (lsa->header->length),
duration, VTY_NEWLINE);
}
void
ospf6_lsa_show_dump (struct vty *vty, struct ospf6_lsa *lsa)
{
u_char *start, *end, *current;
char byte[4];
start = (char *) lsa->header;
end = (char *) lsa->header + ntohs (lsa->header->length);
vty_out (vty, "%s", VTY_NEWLINE);
vty_out (vty, "%s:%s", lsa->str, VTY_NEWLINE);
for (current = start; current < end; current ++)
{
if ((current - start) % 16 == 0)
vty_out (vty, "%s ", VTY_NEWLINE);
else if ((current - start) % 4 == 0)
vty_out (vty, " ");
snprintf (byte, sizeof (byte), "%02x", *current);
vty_out (vty, "%s", byte);
}
vty_out (vty, "%s%s", VTY_NEWLINE, VTY_NEWLINE);
}
/* OSPFv3 LSA creation/deletion function */
/* calculate LS sequence number for my new LSA.
return value is network byte order */
static signed long
ospf6_lsa_seqnum_new (u_int16_t type, u_int32_t id, u_int32_t adv_router,
void *scope)
{
struct ospf6_lsa *lsa;
signed long seqnum;
/* get current database copy */
lsa = ospf6_lsdb_lookup (type, id, adv_router, scope);
/* if current database copy not found, return InitialSequenceNumber */
if (!lsa)
seqnum = INITIAL_SEQUENCE_NUMBER;
else
seqnum = (signed long) ntohl (lsa->header->seqnum) + 1;
return (htonl (seqnum));
}
#if 0
static void
ospf6_lsa_header_set (u_int16_t type, u_int32_t ls_id, u_int32_t advrtr,
struct ospf6_lsa_header *lsa_header, int bodysize)
{
/* fill LSA header */
lsa_header->age = 0;
lsa_header->type = type;
lsa_header->ls_id = ls_id;
lsa_header->advrtr = advrtr;
lsa_header->seqnum =
ospf6_lsa_seqnum_new (lsa_header->type, lsa_header->ls_id,
lsa_header->advrtr);
lsa_header->length = htons (sizeof (struct ospf6_lsa_header) + bodysize);
/* LSA checksum */
ospf6_lsa_checksum (lsa_header);
}
#endif /*0*/
struct ospf6_lsa *
ospf6_lsa_create (struct ospf6_lsa_header *source)
{
struct ospf6_lsa *lsa = NULL;
struct ospf6_lsa_header *lsa_header = NULL;
u_int16_t lsa_size = 0;
char buf_router[16], buf_id[16], typebuf[32];
/* whole length of this LSA */
lsa_size = ntohs (source->length);
/* allocate memory for this LSA */
lsa_header = (struct ospf6_lsa_header *)
XMALLOC (MTYPE_OSPF6_LSA, lsa_size);
if (! lsa_header)
{
zlog_err ("Can't allocate memory for LSA Header");
return (struct ospf6_lsa *) NULL;
}
memset (lsa_header, 0, lsa_size);
/* copy LSA from source */
memcpy (lsa_header, source, lsa_size);
/* LSA information structure */
/* allocate memory */
lsa = (struct ospf6_lsa *)
XMALLOC (MTYPE_OSPF6_LSA, sizeof (struct ospf6_lsa));
memset (lsa, 0, sizeof (struct ospf6_lsa));
lsa->lsa_hdr = (struct ospf6_lsa_hdr *) lsa_header;
lsa->header = (struct ospf6_lsa_header__ *) lsa_header;
lsa->summary = 0; /* this is not LSA summary */
/* dump string */
inet_ntop (AF_INET, &lsa->header->id, buf_id, sizeof (buf_id));
inet_ntop (AF_INET, &lsa->header->adv_router, buf_router,
sizeof (buf_router));
snprintf (lsa->str, sizeof (lsa->str), "[%s ID=%s Adv=%s]",
ospf6_lsa_type_string (lsa_header->type, typebuf,
sizeof (typebuf)),
buf_id, buf_router);
/* calculate birth, expire and refresh of this lsa */
ospf6_lsa_age_set (lsa);
#ifdef DEBUG
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Create: %s (%p/%p)", lsa->str, lsa, lsa->header);
#endif /*DEBUG*/
return lsa;
}
struct ospf6_lsa *
ospf6_lsa_summary_create (struct ospf6_lsa_header__ *source)
{
struct ospf6_lsa *lsa = NULL;
struct ospf6_lsa_header *lsa_header = NULL;
u_int16_t lsa_size = 0;
char buf_router[16], buf_id[16], typebuf[16];
/* LSA summary contains LSA Header only */
lsa_size = sizeof (struct ospf6_lsa_header);
/* allocate memory for this LSA */
lsa_header = (struct ospf6_lsa_header *)
XMALLOC (MTYPE_OSPF6_LSA_SUMMARY, lsa_size);
memset (lsa_header, 0, lsa_size);
/* copy LSA from source */
memcpy (lsa_header, source, lsa_size);
/* LSA information structure */
/* allocate memory */
lsa = (struct ospf6_lsa *)
XMALLOC (MTYPE_OSPF6_LSA_SUMMARY, sizeof (struct ospf6_lsa));
memset (lsa, 0, sizeof (struct ospf6_lsa));
lsa->lsa_hdr = (struct ospf6_lsa_hdr *) lsa_header;
lsa->header = (struct ospf6_lsa_header__ *) lsa_header;
lsa->summary = 1; /* this is LSA summary */
/* dump string */
inet_ntop (AF_INET, &lsa->header->id, buf_id, sizeof (buf_id));
inet_ntop (AF_INET, &lsa->header->adv_router, buf_router,
sizeof (buf_router));
snprintf (lsa->str, sizeof (lsa->str), "[%s Summary ID=%s Adv=%s]",
ospf6_lsa_type_string (lsa->header->type, typebuf,
sizeof (typebuf)),
buf_id, buf_router);
/* calculate birth, expire and refresh of this lsa */
ospf6_lsa_age_set (lsa);
#ifdef DEBUG
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Create: %s (%p/%p)", lsa->str, lsa, lsa->header);
#endif /*DEBUG*/
return lsa;
}
void
ospf6_lsa_delete (struct ospf6_lsa *lsa)
{
/* just to make sure */
if (lsa->lock != 0)
{
zlog_err ("Can't delete %s: lock: %ld", lsa->str, lsa->lock);
return;
}
/* cancel threads */
if (lsa->expire)
thread_cancel (lsa->expire);
lsa->expire = (struct thread *) NULL;
if (lsa->refresh)
thread_cancel (lsa->refresh);
lsa->refresh = (struct thread *) NULL;
#ifdef DEBUG
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Delete %s (%p/%p)", lsa->str, lsa, lsa->header);
#endif /*DEBUG*/
/* do free */
if (lsa->summary)
XFREE (MTYPE_OSPF6_LSA_SUMMARY, lsa->header);
else
XFREE (MTYPE_OSPF6_LSA, lsa->header);
lsa->header = NULL;
if (lsa->summary)
XFREE (MTYPE_OSPF6_LSA_SUMMARY, lsa);
else
XFREE (MTYPE_OSPF6_LSA, lsa);
}
/* increment reference counter of struct ospf6_lsa */
void
ospf6_lsa_lock (struct ospf6_lsa *lsa)
{
lsa->lock++;
return;
}
/* decrement reference counter of struct ospf6_lsa */
void
ospf6_lsa_unlock (struct ospf6_lsa *lsa)
{
/* decrement reference counter */
if (lsa->lock > 0)
lsa->lock--;
else
zlog_warn ("Can't unlock %s: already no lock", lsa->str);
if (lsa->lock == 0)
ospf6_lsa_delete (lsa);
}
void
ospf6_lsa_originate (u_int16_t type, u_int32_t id, u_int32_t adv_router,
char *data, int data_len, void *scope)
{
char buffer[MAXLSASIZE];
struct ospf6_lsa_header *lsa_header;
struct ospf6_lsa *lsa;
struct ospf6_lsa *old;
assert (data_len <= sizeof (buffer) - sizeof (struct ospf6_lsa_header));
lsa_header = (struct ospf6_lsa_header *) buffer;
/* Copy LSA Body */
memcpy (buffer + sizeof (struct ospf6_lsa_header), data, data_len);
/* Fill LSA Header */
lsa_header->age = 0;
lsa_header->type = type;
lsa_header->ls_id = id;
lsa_header->advrtr = adv_router;
lsa_header->seqnum =
ospf6_lsa_seqnum_new (lsa_header->type, lsa_header->ls_id,
lsa_header->advrtr, scope);
lsa_header->length = htons (sizeof (struct ospf6_lsa_header) + data_len);
/* LSA checksum */
ospf6_lsa_checksum (lsa_header);
/* create LSA */
lsa = ospf6_lsa_create ((struct ospf6_lsa_header *) buffer);
lsa->scope = scope;
/* find previous LSA */
old = ospf6_lsdb_lookup (lsa->header->type, lsa->header->id,
lsa->header->adv_router, lsa->scope);
if (old)
{
/* Check if this is neither different instance nor refresh, return */
if (! CHECK_FLAG (old->flag, OSPF6_LSA_FLAG_REFRESH) &&
! ospf6_lsa_differ (lsa, old))
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: Suppress updating %s", lsa->str);
ospf6_lsa_delete (lsa);
return;
}
}
lsa->refresh = thread_add_timer (master, ospf6_lsa_refresh, lsa,
OSPF6_LS_REFRESH_TIME);
gettimeofday (&lsa->originated, NULL);
//if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: originate %s seq: %#x age: %hu %ld.%06ld",
lsa->str, ntohl (lsa->header->seqnum),
ospf6_lsa_age_current (lsa),
lsa->originated.tv_sec, lsa->originated.tv_usec);
ospf6_dbex_remove_from_all_retrans_list (lsa);
ospf6_dbex_flood (lsa, NULL);
ospf6_lsdb_install (lsa);
}
/* ospf6_lsa expired */
int
ospf6_lsa_expire (struct thread *thread)
{
struct ospf6_lsa *lsa;
struct ospf6_lsdb *lsdb = NULL;
void (*hook) (struct ospf6_lsa *, struct ospf6_lsa *);
lsa = (struct ospf6_lsa *) THREAD_ARG (thread);
assert (lsa && lsa->lsa_hdr);
/* assertion */
assert (IS_LSA_MAXAGE (lsa));
assert (!lsa->refresh);
lsa->expire = (struct thread *) NULL;
/* log */
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: Expire: %s", lsa->str);
if (!lsa->summary)
{
/* reflood lsa */
ospf6_dbex_flood (lsa, NULL);
/* get scoped lsdb, call remove hook */
if (OSPF6_LSA_IS_SCOPE_LINKLOCAL (ntohs (lsa->header->type)))
lsdb = ((struct ospf6_interface *) lsa->scope)->lsdb;
else if (OSPF6_LSA_IS_SCOPE_AREA (ntohs (lsa->header->type)))
lsdb = ((struct ospf6_area *) lsa->scope)->lsdb;
else if (OSPF6_LSA_IS_SCOPE_AS (ntohs (lsa->header->type)))
lsdb = ((struct ospf6 *) lsa->scope)->lsdb;
else
assert (0);
/* call LSDB hook to re-process LSA */
hook = ospf6_lsdb_hook[ntohs (lsa->header->type) &
OSPF6_LSTYPE_CODE_MASK].hook;
if (hook)
(*hook) (NULL, lsa);
/* do not free LSA, and do nothing about lslists.
wait event (ospf6_lsdb_check_maxage) */
}
return 0;
}
int
ospf6_lsa_refresh (struct thread *thread)
{
struct ospf6_lsa *lsa;
struct ospf6_lsa_slot *slot;
assert (thread);
lsa = (struct ospf6_lsa *) THREAD_ARG (thread);
assert (lsa && lsa->lsa_hdr);
/* this will be used later as flag to decide really originate */
lsa->refresh = (struct thread *) NULL;
SET_FLAG (lsa->flag, OSPF6_LSA_FLAG_REFRESH);
/* log */
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA Refresh: %s", lsa->str);
slot = ospf6_lsa_slot_get (lsa->header->type);
if (slot)
{
zlog_info ("LSA Refresh: %s", slot->name);
(*slot->func_refresh) (lsa);
return 0;
}
zlog_warn ("Can't Refresh LSA: Unknown type: %#x",
ntohs (lsa->header->type));
return 1;
}
/* enhanced Fletcher checksum algorithm, RFC1008 7.2 */
#define MODX 4102
#define LSA_CHECKSUM_OFFSET 15
unsigned short
ospf6_lsa_checksum (struct ospf6_lsa_header *lsa_header)
{
u_char *sp, *ep, *p, *q;
int c0 = 0, c1 = 0;
int x, y;
u_int16_t length;
lsa_header->checksum = 0;
length = ntohs (lsa_header->length) - 2;
sp = (char *) &lsa_header->type;
for (ep = sp + length; sp < ep; sp = q)
{
q = sp + MODX;
if (q > ep)
q = ep;
for (p = sp; p < q; p++)
{
c0 += *p;
c1 += c0;
}
c0 %= 255;
c1 %= 255;
}
/* r = (c1 << 8) + c0; */
x = ((length - LSA_CHECKSUM_OFFSET) * c0 - c1) % 255;
if (x <= 0)
x += 255;
y = 510 - c0 - x;
if (y > 255)
y -= 255;
lsa_header->checksum = htons ((x << 8) + y);
return (lsa_header->checksum);
}
int
ospf6_lsa_is_known_type (struct ospf6_lsa_header *lsa_header)
{
struct ospf6_lsa_slot *slot;
slot = ospf6_lsa_slot_get (lsa_header->type);
if (slot)
return 1;
return 0;
}
struct ospf6_lsa_slot *slot_head = NULL;
struct ospf6_lsa_slot *
ospf6_lsa_slot_get (u_int16_t type)
{
struct ospf6_lsa_slot *slot;
for (slot = slot_head; slot; slot = slot->next)
{
if (slot->type == type)
return slot;
}
return NULL;
}
int
ospf6_lsa_slot_register (struct ospf6_lsa_slot *src)
{
struct ospf6_lsa_slot *new, *slot;
slot = ospf6_lsa_slot_get (src->type);
if (slot)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: Slot register: already exists: %#x %s",
slot->type, slot->name);
return -1;
}
new = (struct ospf6_lsa_slot *)
XMALLOC (MTYPE_OSPF6_LSA, sizeof (struct ospf6_lsa_slot));
if (! new)
{
zlog_err ("Can't allocate memory for LSA slot: %s", strerror (errno));
return -1;
}
memset (new, 0, sizeof (struct ospf6_lsa_slot));
memcpy (new, src, sizeof (struct ospf6_lsa_slot));
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: Slot register: %#x %s", slot->type, slot->name);
if (slot_head == NULL)
{
new->prev = NULL;
new->next = NULL;
slot_head = new;
return 0;
}
slot = slot_head;
while (slot->next)
slot = slot->next;
slot->next = new;
new->prev = slot;
return 0;
}
int
ospf6_lsa_slot_unregister (u_int16_t type)
{
struct ospf6_lsa_slot *slot;
slot = ospf6_lsa_slot_get (type);
if (slot == NULL)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Registering LSA slot: no such slot: %#x", type);
return -1;
}
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Unregistering LSA Slot: %#x %s", slot->type, slot->name);
if (slot->prev)
slot->prev->next = slot->next;
if (slot->next)
slot->next->prev = slot->prev;
if (slot_head == slot)
slot_head = slot->next;
XFREE (MTYPE_OSPF6_LSA, slot);
return 0;
}
char *
ospf6_lsa_type_string (u_int16_t type, char *buf, int bufsize)
{
struct ospf6_lsa_slot *slot;
slot = ospf6_lsa_slot_get (type);
if (slot)
snprintf (buf, bufsize, "%s", slot->name);
else
snprintf (buf, bufsize, "Type=0x%04x", ntohs (type));
return buf;
}
/*******************/
/* LSA Origination */
/*******************/
#define CONTINUE_IF_ADDRESS_LINKLOCAL(addr)\
if (IN6_IS_ADDR_LINKLOCAL (&(addr)->u.prefix6))\
{\
char buf[64];\
prefix2str (addr, buf, sizeof (buf));\
if (IS_OSPF6_DUMP_LSA)\
zlog_info (" Filter out Linklocal: %s", buf);\
continue;\
}
#define CONTINUE_IF_ADDRESS_UNSPECIFIED(addr)\
if (IN6_IS_ADDR_UNSPECIFIED (&(addr)->u.prefix6))\
{\
char buf[64];\
prefix2str (addr, buf, sizeof (buf));\
if (IS_OSPF6_DUMP_LSA)\
zlog_info (" Filter out Unspecified: %s", buf);\
continue;\
}
#define CONTINUE_IF_ADDRESS_LOOPBACK(addr)\
if (IN6_IS_ADDR_LOOPBACK (&(addr)->u.prefix6))\
{\
char buf[64];\
prefix2str (addr, buf, sizeof (buf));\
if (IS_OSPF6_DUMP_LSA)\
zlog_info (" Filter out Loopback: %s", buf);\
continue;\
}
#define CONTINUE_IF_ADDRESS_V4COMPAT(addr)\
if (IN6_IS_ADDR_V4COMPAT (&(addr)->u.prefix6))\
{\
char buf[64];\
prefix2str (addr, buf, sizeof (buf));\
if (IS_OSPF6_DUMP_LSA)\
zlog_info (" Filter out V4Compat: %s", buf);\
continue;\
}
#define CONTINUE_IF_ADDRESS_V4MAPPED(addr)\
if (IN6_IS_ADDR_V4MAPPED (&(addr)->u.prefix6))\
{\
char buf[64];\
prefix2str (addr, buf, sizeof (buf));\
if (IS_OSPF6_DUMP_LSA)\
zlog_info (" Filter out V4Mapped: %s", buf);\
continue;\
}
/******************************/
/* RFC2740 3.4.3.1 Router-LSA */
/******************************/
char *
ospf6_lsa_router_bits_string (u_char router_bits, char *buf, int size)
{
char w, v, e, b;
w = (router_bits & OSPF6_ROUTER_LSA_BIT_W ? 'W' : '-');
v = (router_bits & OSPF6_ROUTER_LSA_BIT_V ? 'V' : '-');
e = (router_bits & OSPF6_ROUTER_LSA_BIT_E ? 'E' : '-');
b = (router_bits & OSPF6_ROUTER_LSA_BIT_B ? 'B' : '-');
snprintf (buf, size, "----%c%c%c%c", w, v, e, b);
return buf;
}
int
ospf6_lsa_router_show (struct vty *vty, struct ospf6_lsa *lsa)
{
char *start, *end, *current;
char buf[32], name[32], bits[32], options[32];
struct ospf6_router_lsa *router_lsa;
struct ospf6_router_lsd *lsdesc;
assert (lsa->header);
router_lsa = (struct ospf6_router_lsa *)
((char *) lsa->header + sizeof (struct ospf6_lsa_header));
ospf6_lsa_router_bits_string (router_lsa->bits, bits, sizeof (bits));
ospf6_options_string (router_lsa->options, options, sizeof (options));
vty_out (vty, " Bits: %s Options: %s%s", bits, options, VTY_NEWLINE);
start = (char *) router_lsa + sizeof (struct ospf6_router_lsa);
end = (char *) lsa->header + ntohs (lsa->header->length);
for (current = start; current + sizeof (struct ospf6_router_lsd) <= end;
current += sizeof (struct ospf6_router_lsd))
{
lsdesc = (struct ospf6_router_lsd *) current;
if (lsdesc->type == OSPF6_ROUTER_LSD_TYPE_POINTTOPOINT)
snprintf (name, sizeof (name), "Point-To-Point");
else if (lsdesc->type == OSPF6_ROUTER_LSD_TYPE_TRANSIT_NETWORK)
snprintf (name, sizeof (name), "Transit-Network");
else if (lsdesc->type == OSPF6_ROUTER_LSD_TYPE_STUB_NETWORK)
snprintf (name, sizeof (name), "Stub-Network");
else if (lsdesc->type == OSPF6_ROUTER_LSD_TYPE_VIRTUAL_LINK)
snprintf (name, sizeof (name), "Virtual-Link");
else
snprintf (name, sizeof (name), "Unknown (%#x)", lsdesc->type);
vty_out (vty, " Type: %s Metric: %d%s",
name, ntohs (lsdesc->metric), VTY_NEWLINE);
vty_out (vty, " Interface ID: %s%s",
inet_ntop (AF_INET, &lsdesc->interface_id,
buf, sizeof (buf)), VTY_NEWLINE);
vty_out (vty, " Neighbor Interface ID: %s%s",
inet_ntop (AF_INET, &lsdesc->neighbor_interface_id,
buf, sizeof (buf)), VTY_NEWLINE);
vty_out (vty, " Neighbor Router ID: %s%s",
inet_ntop (AF_INET, &lsdesc->neighbor_router_id,
buf, sizeof (buf)), VTY_NEWLINE);
}
return 0;
}
u_long
ospf6_lsa_has_elasped (u_int16_t type, u_int32_t id,
u_int32_t adv_router, void *scope)
{
struct ospf6_lsa *old;
struct timeval now;
if (adv_router != ospf6->router_id)
zlog_info ("LSA: Router-ID changed ?");
old = ospf6_lsdb_lookup (type, id, adv_router, scope);
if (! old)
return OSPF6_LSA_MAXAGE;
gettimeofday (&now, NULL);
return ((u_long) SEC_TVDIFF (&now, &old->originated));
}
int
ospf6_lsa_originate_router (struct thread *thread)
{
char buffer [MAXLSASIZE];
u_int16_t size;
struct ospf6_area *o6a;
int count;
u_int32_t area_id;
struct ospf6_router_lsa *router_lsa;
struct ospf6_router_lsd *router_lsd;
listnode i;
struct ospf6_interface *o6i;
struct ospf6_neighbor *o6n = NULL;
area_id = (u_int32_t) THREAD_ARG (thread);
o6a = ospf6_area_lookup (area_id, ospf6);
if (! o6a)
{
inet_ntop (AF_INET, &area_id, buffer, sizeof (buffer));
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: Update Router-LSA: No such area: %s", buffer);
return 0;
}
/* clear thread */
o6a->thread_router_lsa = NULL;
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: originate Router-LSA for Area %s", o6a->str);
size = sizeof (struct ospf6_router_lsa);
memset (buffer, 0, sizeof (buffer));
router_lsa = (struct ospf6_router_lsa *) buffer;
OSPF6_OPT_CLEAR_ALL (router_lsa->options);
OSPF6_OPT_SET (router_lsa->options, OSPF6_OPT_V6);
OSPF6_OPT_SET (router_lsa->options, OSPF6_OPT_E);
OSPF6_OPT_CLEAR (router_lsa->options, OSPF6_OPT_MC);
OSPF6_OPT_CLEAR (router_lsa->options, OSPF6_OPT_N);
OSPF6_OPT_SET (router_lsa->options, OSPF6_OPT_R);
OSPF6_OPT_CLEAR (router_lsa->options, OSPF6_OPT_DC);
OSPF6_ROUTER_LSA_CLEAR_ALL_BITS (router_lsa);
OSPF6_ROUTER_LSA_CLEAR (router_lsa, OSPF6_ROUTER_LSA_BIT_B);
if (ospf6_is_asbr (o6a->ospf6))
OSPF6_ROUTER_LSA_SET (router_lsa, OSPF6_ROUTER_LSA_BIT_E);
else
OSPF6_ROUTER_LSA_CLEAR (router_lsa, OSPF6_ROUTER_LSA_BIT_E);
OSPF6_ROUTER_LSA_CLEAR (router_lsa, OSPF6_ROUTER_LSA_BIT_V);
OSPF6_ROUTER_LSA_CLEAR (router_lsa, OSPF6_ROUTER_LSA_BIT_W);
/* describe links for each interfaces */
router_lsd = (struct ospf6_router_lsd *) (router_lsa + 1);
for (i = listhead (o6a->if_list); i; nextnode (i))
{
o6i = (struct ospf6_interface *) getdata (i);
assert (o6i);
/* Interfaces in state Down or Loopback are not described */
if (o6i->state == IFS_DOWN || o6i->state == IFS_LOOPBACK)
continue;
/* Nor are interfaces without any full adjacencies described */
count = 0;
o6i->foreach_nei (o6i, &count, NBS_FULL, ospf6_count_state);
if (count == 0)
continue;
/* Point-to-Point interfaces */
if (if_is_pointopoint (o6i->interface))
{
if (listcount (o6i->neighbor_list) == 0)
continue;
if (listcount (o6i->neighbor_list) != 1)
zlog_warn ("LSA: Multiple neighbors on PoinToPoint: %s",
o6i->interface->name);
o6n = (struct ospf6_neighbor *)
getdata (listhead (o6i->neighbor_list));
assert (o6n);
router_lsd->type = OSPF6_ROUTER_LSD_TYPE_POINTTOPOINT;
router_lsd->metric = htons (o6i->cost);
router_lsd->interface_id = htonl (o6i->if_id);
router_lsd->neighbor_interface_id = htonl (o6n->ifid);
router_lsd->neighbor_router_id = o6n->router_id;
size += sizeof (struct ospf6_router_lsd);
router_lsd ++;
continue;
}
/* Broadcast and NBMA interfaces */
if (if_is_broadcast (o6i->interface))
{
/* If this router is not DR,
and If this router not fully adjacent with DR,
this interface is not transit yet: ignore. */
if (o6i->state != IFS_DR)
{
o6n = ospf6_neighbor_lookup (o6i->dr, o6i); /* find DR */
if (o6n == NULL || o6n->state != NBS_FULL)
continue;
}
else
{
count = 0;
o6i->foreach_nei (o6i, &count, NBS_FULL, ospf6_count_state);
if (count == 0)
continue;
}
router_lsd->type = OSPF6_ROUTER_LSD_TYPE_TRANSIT_NETWORK;
router_lsd->metric = htons (o6i->cost);
router_lsd->interface_id = htonl (o6i->if_id);
if (o6i->state != IFS_DR)
{
router_lsd->neighbor_interface_id = htonl (o6n->ifid);
router_lsd->neighbor_router_id = o6n->router_id;
}
else
{
router_lsd->neighbor_interface_id = htonl (o6i->if_id);
router_lsd->neighbor_router_id = o6i->area->ospf6->router_id;
}
size += sizeof (struct ospf6_router_lsd);
router_lsd ++;
continue;
}
/* Virtual links */
/* xxx */
/* Point-to-Multipoint interfaces */
/* xxx */
}
ospf6_lsa_originate (htons (OSPF6_LSA_TYPE_ROUTER),
htonl (0), o6a->ospf6->router_id,
(char *) router_lsa, size, o6a);
return 0;
}
void
ospf6_lsa_schedule_router (struct ospf6_area *area)
{
u_long elasped_time, time = 0;
if (area->thread_router_lsa)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: schedule: Router-LSA for Area %s: another thread",
area->str);
return;
}
elasped_time =
ospf6_lsa_has_elasped (htons (OSPF6_LSA_TYPE_ROUTER), htonl (0),
area->ospf6->router_id, area);
if (elasped_time < OSPF6_MIN_LS_INTERVAL)
time = (u_long) (OSPF6_MIN_LS_INTERVAL - elasped_time);
else
time = 0;
if (IS_OSPF6_DUMP_LSA)
zlog_info ("LSA: schedule: Router-LSA for Area %s after %lu sec",
area->str, time);
if (time)
area->thread_router_lsa =
thread_add_timer (master, ospf6_lsa_originate_router,
(void *) area->area_id, time);
else
area->thread_router_lsa =
thread_add_event (master, ospf6_lsa_originate_router,
(void *) area->area_id, 0);
}
int
ospf6_lsa_router_hook_neighbor (void *neighbor)
{
struct ospf6_neighbor *o6n = neighbor;
if (o6n->ospf6_interface->area)
ospf6_lsa_schedule_router (o6n->ospf6_interface->area);
return 0;
}
int
ospf6_lsa_router_hook_interface (void *interface)
{
struct ospf6_interface *o6i = interface;
if (o6i->area)
ospf6_lsa_schedule_router (o6i->area);
return 0;
}
int
ospf6_lsa_router_hook_area (void *area)
{
struct ospf6_area *o6a = area;
ospf6_lsa_schedule_router (o6a);
return 0;
}
int
ospf6_lsa_router_hook_top (void *ospf6)
{
struct ospf6 *o6 = ospf6;
struct ospf6_area *o6a;
listnode node;
for (node = listhead (o6->area_list); node; nextnode (node))
{
o6a = getdata (node);
ospf6_lsa_schedule_router (o6a);
}
return 0;
}
int
ospf6_lsa_router_refresh (void *old)
{
struct ospf6_lsa *lsa = old;
struct ospf6_area *o6a;
o6a = lsa->scope;
ospf6_lsa_schedule_router (o6a);
return 0;
}
void
ospf6_lsa_slot_register_router ()
{
struct ospf6_lsa_slot slot;
struct ospf6_hook hook;
memset (&slot, 0, sizeof (struct ospf6_lsa_slot));
slot.type = htons (OSPF6_LSA_TYPE_ROUTER);
slot.name = "Router";
slot.func_show = ospf6_lsa_router_show;
slot.func_refresh = ospf6_lsa_router_refresh;
ospf6_lsa_slot_register (&slot);
ospf6_lsdb_hook[OSPF6_LSA_TYPE_ROUTER & OSPF6_LSTYPE_CODE_MASK].hook =
ospf6_spf_database_hook;
memset (&hook, 0, sizeof (hook));
hook.name = "OriginateRouter";
hook.hook_change = ospf6_lsa_router_hook_neighbor;
ospf6_hook_register (&hook, &neighbor_hook);
memset (&hook, 0, sizeof (hook));
hook.name = "OriginateRouter";
hook.hook_change = ospf6_lsa_router_hook_interface;
ospf6_hook_register (&hook, &interface_hook);
memset (&hook, 0, sizeof (hook));
hook.name = "OriginateRouter";
hook.hook_change = ospf6_lsa_router_hook_area;
ospf6_hook_register (&hook, &area_hook);
memset (&hook, 0, sizeof (hook));
hook.name = "OriginateRouter";
hook.hook_change = ospf6_lsa_router_hook_top;
ospf6_hook_register (&hook, &top_hook);
}
/*******************************/
/* RFC2740 3.4.3.2 Network-LSA */
/*******************************/
int
ospf6_lsa_network_show (struct vty *vty, struct ospf6_lsa *lsa)
{
char *start, *end, *current;
struct ospf6_network_lsa *network_lsa;
u_int32_t *router_id;
char buf[128], options[32];
assert (lsa->header);
network_lsa = (struct ospf6_network_lsa *) (lsa->header + 1);
router_id = (u_int32_t *)(network_lsa + 1);
ospf6_options_string (network_lsa->options, options, sizeof (options));
vty_out (vty, " Options: %s%s", options, VTY_NEWLINE);
start = (char *) network_lsa + sizeof (struct ospf6_network_lsa);
end = (char *) lsa->header + ntohs (lsa->header->length);
for (current = start; current + sizeof (u_int32_t) <= end;
current += sizeof (u_int32_t))
{
router_id = (u_int32_t *) current;
inet_ntop (AF_INET, router_id, buf, sizeof (buf));
vty_out (vty, " Attached Router: %s%s", buf, VTY_NEWLINE);
}
return 0;
}
void
ospf6_lsa_network_update (char *ifname)
{
char buffer [MAXLSASIZE];
u_int16_t size;
struct ospf6_lsa *old;
struct interface *ifp;
struct ospf6_interface *o6i;
int count;
struct ospf6_network_lsa *network_lsa;
struct ospf6_neighbor *o6n;
u_int32_t *router_id;
listnode node;
ifp = if_lookup_by_name (ifname);
if (! ifp)
{
if (IS_OSPF6_DUMP_LSA)
zlog_warn ("Update Network: No such Interface: %s", ifname);
return;
}
o6i = (struct ospf6_interface *) ifp->info;
if (! o6i || ! o6i->area)
{
if (IS_OSPF6_DUMP_LSA)
zlog_warn ("Update Network: Interface not enabled: %s", ifname);
return;
}
/* find previous LSA */
old = ospf6_lsdb_lookup (htons (OSPF6_LSA_TYPE_NETWORK),
htonl (o6i->if_id),
o6i->area->ospf6->router_id, o6i->area);
/* Don't originate Network-LSA if not DR */
if (o6i->state != IFS_DR)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Update Network: Interface %s is not DR",
o6i->interface->name);
if (old)
ospf6_lsa_premature_aging (old);
return;
}
/* If none of neighbor is adjacent to us */
count = 0;
o6i->foreach_nei (o6i, &count, NBS_FULL, ospf6_count_state);
if (count == 0)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Update Network: Interface %s is Stub",
o6i->interface->name);
if (old)
ospf6_lsa_premature_aging (old);
return;
}
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Update Network: Interface %s", o6i->interface->name);
/* prepare buffer */
memset (buffer, 0, sizeof (buffer));
size = sizeof (struct ospf6_network_lsa);
network_lsa = (struct ospf6_network_lsa *) buffer;
router_id = (u_int32_t *)(network_lsa + 1);
/* set fields of myself */
*router_id++ = o6i->area->ospf6->router_id;
size += sizeof (u_int32_t);
network_lsa->options[0] |= o6i->area->options[0];
network_lsa->options[1] |= o6i->area->options[1];
network_lsa->options[2] |= o6i->area->options[2];
/* Walk through neighbors */
for (node = listhead (o6i->neighbor_list); node; nextnode (node))
{
o6n = (struct ospf6_neighbor *) getdata (node);
if (o6n->state != NBS_FULL)
continue;
/* set this neighbor's Router-ID to LSA */
*router_id++ = o6n->router_id;
size += sizeof (u_int32_t);
/* options field is logical OR */
network_lsa->options[0] |= o6n->options[0];
network_lsa->options[1] |= o6n->options[1];
network_lsa->options[2] |= o6n->options[2];
}
ospf6_lsa_originate (htons (OSPF6_LSA_TYPE_NETWORK),
htonl (o6i->if_id), o6i->area->ospf6->router_id,
(char *) network_lsa, size, o6i->area);
}
int
ospf6_lsa_network_hook_neighbor (void *neighbor)
{
struct ospf6_neighbor *o6n = neighbor;
ospf6_lsa_network_update (o6n->ospf6_interface->interface->name);
return 0;
}
int
ospf6_lsa_network_hook_interface (void *interface)
{
struct ospf6_interface *o6i = interface;
if (o6i->area)
ospf6_lsa_network_update (o6i->interface->name);
return 0;
}
int
ospf6_lsa_network_refresh (void *old)
{
struct ospf6_lsa *lsa = old;
struct interface *ifp;
ifp = if_lookup_by_index (ntohl (lsa->header->id));
if (! ifp)
ospf6_lsa_premature_aging (old);
else
ospf6_lsa_network_update (ifp->name);
return 0;
}
void
ospf6_lsa_slot_register_network ()
{
struct ospf6_lsa_slot slot;
struct ospf6_hook hook;
memset (&slot, 0, sizeof (struct ospf6_lsa_slot));
slot.type = htons (OSPF6_LSA_TYPE_NETWORK);
slot.name = "Network";
slot.func_show = ospf6_lsa_network_show;
slot.func_refresh = ospf6_lsa_network_refresh;
ospf6_lsa_slot_register (&slot);
ospf6_lsdb_hook[OSPF6_LSA_TYPE_NETWORK & OSPF6_LSTYPE_CODE_MASK].hook =
ospf6_spf_database_hook;
memset (&hook, 0, sizeof (hook));
hook.name = "OriginateNetwork";
hook.hook_change = ospf6_lsa_network_hook_neighbor;
ospf6_hook_register (&hook, &neighbor_hook);
memset (&hook, 0, sizeof (hook));
hook.name = "OriginateNetwork";
hook.hook_change = ospf6_lsa_network_hook_interface;
ospf6_hook_register (&hook, &interface_hook);
}
/****************************/
/* RFC2740 3.4.3.6 Link-LSA */
/****************************/
int
ospf6_lsa_link_show (struct vty *vty, struct ospf6_lsa *lsa)
{
char *start, *end, *current;
struct ospf6_link_lsa *link_lsa;
int prefixnum;
struct ospf6_prefix *prefix;
char buf[128];
struct in6_addr in6;
assert (lsa->header);
link_lsa = (struct ospf6_link_lsa *) (lsa->header + 1);
prefixnum = ntohl (link_lsa->llsa_prefix_num);
inet_ntop (AF_INET6, (void *)&link_lsa->llsa_linklocal, buf, sizeof (buf));
vty_out (vty, " LinkLocal Address: %s%s", buf, VTY_NEWLINE);
vty_out (vty, " Number of Prefix: %d%s", prefixnum, VTY_NEWLINE);
start = (char *) link_lsa + sizeof (struct ospf6_link_lsa);
end = (char *) lsa->header + ntohs (lsa->header->length);
for (current = start; current < end; current += OSPF6_PREFIX_SIZE (prefix))
{
prefix = (struct ospf6_prefix *) current;
if (current + OSPF6_PREFIX_SIZE (prefix) > end)
{
vty_out (vty, " Trailing %d byte garbage ... Malformed%s",
end - current, VTY_NEWLINE);
return -1;
}
ospf6_prefix_options_str (prefix->prefix_options, buf, sizeof (buf));
vty_out (vty, " Prefix Options: %s%s", buf, VTY_NEWLINE);
ospf6_prefix_in6_addr (prefix, &in6);
inet_ntop (AF_INET6, &in6, buf, sizeof (buf));
vty_out (vty, " Prefix: %s/%d%s",
buf, prefix->prefix_length, VTY_NEWLINE);
}
return 0;
}
void
ospf6_lsa_link_update (char *ifname)
{
char *cp, buffer [MAXLSASIZE], buf[32];
u_int16_t size;
struct ospf6_lsa *old;
struct interface *ifp;
struct ospf6_interface *o6i;
struct ospf6_link_lsa *link_lsa;
struct ospf6_prefix *p;
list prefix_connected;
listnode node;
struct connected *c;
ifp = if_lookup_by_name (ifname);
if (! ifp)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Update Link: No such Interface: %s", ifname);
return;
}
o6i = (struct ospf6_interface *) ifp->info;
if (! o6i || ! o6i->area)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Update Link: Interface not enabled: %s", ifname);
return;
}
#if 0
/* Link-LSA is on Broadcast or NBMA */
if (! if_is_broadcast (o6i->interface) /* && ! NBMA xxx */)
{
return;
}
#endif /*0*/
/* find previous LSA */
old = ospf6_lsdb_lookup (htons (OSPF6_LSA_TYPE_LINK), htonl (o6i->if_id),
ospf6->router_id, o6i->area);
/* can't make Link-LSA if linklocal address not set */
if (! o6i->lladdr)
{
if (IS_OSPF6_DUMP_LSA)
zlog_warn ("Update Link: No Linklocal Address: %s",
o6i->interface->name);
if (old)
ospf6_lsa_premature_aging (old);
return;
}
if (IS_OSPF6_DUMP_LSA)
zlog_info ("Update Link: Interface %s", o6i->interface->name);
if (! ospf6_interface_is_enabled (o6i->interface->ifindex))
{
if (IS_OSPF6_DUMP_LSA)
zlog_info (" Interface %s not enabled", o6i->interface->name);
if (old)
ospf6_lsa_premature_aging (old);
return;
}
/* check connected prefix */
prefix_connected = list_new ();
for (node = listhead (o6i->interface->connected); node; nextnode (node))
{
c = (struct connected *) getdata (node);
/* filter prefix not IPv6 */
if (c->address->family != AF_INET6)
continue;
/* for log */
prefix2str (c->address, buf, sizeof (buf));
CONTINUE_IF_ADDRESS_LINKLOCAL (c->address);
CONTINUE_IF_ADDRESS_UNSPECIFIED (c->address);
CONTINUE_IF_ADDRESS_LOOPBACK (c->address);
CONTINUE_IF_ADDRESS_V4COMPAT (c->address);
CONTINUE_IF_ADDRESS_V4MAPPED (c->address);
/* filter prefix specified by configuration */
if (o6i->plist_name)
{
struct prefix_list *plist;
enum prefix_list_type result = PREFIX_PERMIT;
plist = prefix_list_lookup (AFI_IP6, o6i->plist_name);
if (plist)
result = prefix_list_apply (plist, c->address);
else if (IS_OSPF6_DUMP_LSA)
zlog_warn ("Update Intra-Prefix (Stub): "
"Prefix list \"%s\" not found", o6i->plist_name);
if (result == PREFIX_DENY)
{
if (IS_OSPF6_DUMP_LSA)
zlog_info (" Filter out Prefix-list %s: %s",
o6i->plist_name, buf);
continue;
}
}
if (IS_OSPF6_DUMP_LSA)
zlog_info (" Advertise %s", buf);
/* hold prefix in list. duplicate is filtered in ospf6_prefix_add() */
p = ospf6_prefix_create (0, 0, (struct prefix_ipv6 *) c->address);
ospf6_prefix_add (prefix_connected, p);
}
/* Note: even if no prefix configured, still we have to create Link-LSA
for next-hop resolution */
memset (buffer, 0, sizeof (buffer));
size = sizeof (struct ospf6_link_lsa);
link_lsa = (struct ospf6_link_lsa *) buffer;
/* fill Link LSA and calculate size */
link_lsa->llsa_rtr_pri = o6i->priority;
link_lsa->llsa_options[0] = o6i->area->options[0];
link_lsa->llsa_options[1] = o6i->area->options[1];
link_lsa->llsa_options[2] = o6i->area->options[2];
/* linklocal address */
memcpy (&link_lsa->llsa_linklocal, o6i->lladdr, sizeof (struct in6_addr));
#ifdef KAME /* clear ifindex */
if (link_lsa->llsa_linklocal.s6_addr[3] & 0x0f)
link_lsa->llsa_linklocal.s6_addr[3] &= ~((char)0x0f);
#endif /* KAME */
link_lsa->llsa_prefix_num = htonl (listcount (prefix_connected));
cp = (char *)(link_lsa + 1);
for (node = listhead (prefix_connected); node; nextnode (node))
{
p = (struct ospf6_prefix *) getdata (node);
size += OSPF6_PREFIX_SIZE (p);
memcpy (cp, p, OSPF6_PREFIX_SIZE (p));
cp += OSPF6_PREFIX_SIZE (p);
}
for (node = listhead (prefix_connected); node; nextnode (node))
{
p = (struct ospf6_prefix *) getdata (node);
ospf6_prefix_delete (p);
}
list_delete (prefix_connected);
ospf6_lsa_originate (htons (OSPF6_LSA_TYPE_LINK),
htonl (o6i->if_id), o6i->area->ospf6->router_id,
(char *) link_lsa, size, o6i);
}
int
ospf6_lsa_link_hook_interface (void *interface)
{
struct ospf6_interface *o6i = interface;
if (o6i->area)
ospf6_lsa_link_update (o6i->interface->name);
return 0;
}
int
ospf6_lsa_link_refresh (void *old)
{
struct ospf6_lsa *lsa = old;
struct interface *ifp;
ifp = if_lookup_by_index (ntohl (lsa->header->id));
if (! ifp)
ospf6_lsa_premature_aging (old);
else
ospf6_lsa_link_update (ifp->name);
return 0;
}
void
ospf6_lsa_slot_register_link ()
{
struct ospf6_lsa_slot slot;
memset (&slot, 0, sizeof (struct ospf6_lsa_slot));
slot.type = htons (OSPF6_LSA_TYPE_LINK);
slot.name = "Link";
slot.func_show = ospf6_lsa_link_show;
slot.func_refresh = ospf6_lsa_link_refresh;
slot.hook_interface.name = "OriginateLink";
slot.hook_interface.hook_change = ospf6_lsa_link_hook_interface;
ospf6_lsa_slot_register (&slot);
/*
* Link LSA handling will be shift in ospf6_intra.c
* Currently, only database hook only moved to ospf6_intra.c
*/
#if 0
ospf6_lsdb_hook[OSPF6_LSA_TYPE_LINK & OSPF6_LSTYPE_CODE_MASK].hook =
ospf6_spf_database_hook;
#endif /*0*/
}
int
ospf6_lsa_add_hook (void *data)
{
struct ospf6_lsa *lsa = data;
struct ospf6_lsa_slot *sp;
sp = ospf6_lsa_slot_get (lsa->header->type);
if (sp)
{
CALL_CHANGE_HOOK (&sp->database_hook, lsa);
}
else
zlog_warn ("Unknown LSA added to database: %s", lsa->str);
return 0;
}
int
ospf6_lsa_change_hook (void *data)
{
struct ospf6_lsa *lsa = data;
struct ospf6_lsa_slot *sp;
sp = ospf6_lsa_slot_get (lsa->header->type);
if (sp)
{
CALL_CHANGE_HOOK (&sp->database_hook, lsa);
}
else
zlog_warn ("Unknown LSA changed in database: %s", lsa->str);
return 0;
}
int
ospf6_lsa_remove_hook (void *data)
{
struct ospf6_lsa *lsa = data;
struct ospf6_lsa_slot *sp;
sp = ospf6_lsa_slot_get (lsa->header->type);
if (sp)
{
CALL_REMOVE_HOOK (&sp->database_hook, lsa);
}
else
zlog_warn ("Unknown LSA removed from database: %s", lsa->str);
return 0;
}
/* Initialize LSA slots */
void
ospf6_lsa_init ()
{
struct ospf6_hook hook;
slot_head = NULL;
ospf6_lsa_slot_register_router ();
ospf6_lsa_slot_register_network ();
ospf6_lsa_slot_register_link ();
#if 0
ospf6_lsa_slot_register_intra_prefix ();
ospf6_lsa_slot_register_as_external ();
#endif /*0*/
hook.name = "LSADatabaseHook";
hook.hook_add = ospf6_lsa_add_hook;
hook.hook_change = ospf6_lsa_change_hook;
hook.hook_remove = ospf6_lsa_remove_hook;
ospf6_hook_register (&hook, &database_hook);
}