/* * 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 /* Include other stuffs */ #include #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); }