From 7ef5fefc3c10f8dc6034344b9a0eed9b365332de Mon Sep 17 00:00:00 2001 From: Christian Franke Date: Mon, 8 May 2017 13:02:55 +0200 Subject: [PATCH] isisd: add new tlv parser Signed-off-by: Christian Franke --- isisd/Makefile.am | 8 +- isisd/isis_mt.h | 1 + isisd/isis_tlvs2.c | 3085 +++++++++++++++++++++ isisd/isis_tlvs2.h | 308 ++ tests/.gitignore | 2 + tests/Makefile.am | 21 +- tests/isisd/.gitignore | 1 + tests/isisd/test_fuzz_isis_tlv.c | 188 ++ tests/isisd/test_fuzz_isis_tlv.py | 6 + tests/isisd/test_fuzz_isis_tlv_tests.h.gz | Bin 0 -> 232370 bytes 10 files changed, 3616 insertions(+), 4 deletions(-) create mode 100644 isisd/isis_tlvs2.c create mode 100644 isisd/isis_tlvs2.h create mode 100644 tests/isisd/.gitignore create mode 100644 tests/isisd/test_fuzz_isis_tlv.c create mode 100644 tests/isisd/test_fuzz_isis_tlv.py create mode 100644 tests/isisd/test_fuzz_isis_tlv_tests.h.gz diff --git a/isisd/Makefile.am b/isisd/Makefile.am index 2973820eed..4e8665cd84 100644 --- a/isisd/Makefile.am +++ b/isisd/Makefile.am @@ -8,7 +8,7 @@ LIBS = @LIBS@ AM_CFLAGS = $(WERROR) noinst_LIBRARIES = libisis.a -sbin_PROGRAMS = isisd +sbin_PROGRAMS = isisd libisis_a_SOURCES = \ isis_memory.c \ @@ -16,7 +16,8 @@ libisis_a_SOURCES = \ isis_tlv.c isisd.c isis_misc.c isis_zebra.c isis_dr.c \ isis_flags.c isis_dynhn.c iso_checksum.c isis_csm.c isis_events.c \ isis_spf.c isis_redist.c isis_route.c isis_routemap.c isis_te.c \ - isis_vty.c isis_mt.c + isis_vty.c isis_mt.c \ + isis_tlvs2.c noinst_HEADERS = \ @@ -25,7 +26,8 @@ noinst_HEADERS = \ isis_lsp.h dict.h isis_circuit.h isis_misc.h isis_network.h \ isis_zebra.h isis_dr.h isis_flags.h isis_dynhn.h isis_common.h \ iso_checksum.h isis_csm.h isis_events.h isis_spf.h isis_redist.h \ - isis_route.h isis_routemap.h isis_te.h isis_mt.h + isis_route.h isis_routemap.h isis_te.h isis_mt.h \ + isis_tlvs2.h isisd_SOURCES = \ isis_main.c $(libisis_a_SOURCES) \ diff --git a/isisd/isis_mt.h b/isisd/isis_mt.h index eec089228e..57a7479900 100644 --- a/isisd/isis_mt.h +++ b/isisd/isis_mt.h @@ -24,6 +24,7 @@ #define ISIS_MT_MASK 0x0fff #define ISIS_MT_OL_MASK 0x8000 +#define ISIS_MT_AT_MASK 0x4000 #define ISIS_MT_IPV4_UNICAST 0 #define ISIS_MT_IPV4_MGMT 1 diff --git a/isisd/isis_tlvs2.c b/isisd/isis_tlvs2.c new file mode 100644 index 0000000000..95a12d4fe5 --- /dev/null +++ b/isisd/isis_tlvs2.c @@ -0,0 +1,3085 @@ +/* + * IS-IS TLV Serializer/Deserializer + * + * Copyright (C) 2015,2017 Christian Franke + * + * This file is part of FRR. + * + * FRR 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. + * + * FRR 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 FRR; 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 "md5.h" +#include "memory.h" +#include "stream.h" +#include "sbuf.h" + +#include "isisd/isisd.h" +#include "isisd/isis_memory.h" +#include "isisd/isis_tlvs2.h" +#include "isisd/isis_common.h" +#include "isisd/isis_mt.h" +#include "isisd/isis_misc.h" +#include "isisd/isis_adjacency.h" +#include "isisd/isis_circuit.h" +#include "isisd/isis_pdu.h" +#include "isisd/isis_lsp.h" +#include "isisd/isis_te.h" + +DEFINE_MTYPE_STATIC(ISISD, ISIS_TLV2, "ISIS TLVs (new)") +DEFINE_MTYPE_STATIC(ISISD, ISIS_SUBTLV, "ISIS Sub-TLVs") +DEFINE_MTYPE_STATIC(ISISD, ISIS_MT_ITEM_LIST, "ISIS MT Item Lists") + +typedef int (*unpack_tlv_func)(enum isis_tlv_context context, uint8_t tlv_type, + uint8_t tlv_len, struct stream *s, + struct sbuf *log, void *dest, int indent); +typedef int (*pack_item_func)(struct isis_item *item, struct stream *s); +typedef void (*free_item_func)(struct isis_item *i); +typedef int (*unpack_item_func)(uint16_t mtid, uint8_t len, struct stream *s, + struct sbuf *log, void *dest, int indent); +typedef void (*format_item_func)(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent); +typedef struct isis_item *(*copy_item_func)(struct isis_item *i); + +struct tlv_ops { + const char *name; + unpack_tlv_func unpack; + + pack_item_func pack_item; + free_item_func free_item; + unpack_item_func unpack_item; + format_item_func format_item; + copy_item_func copy_item; +}; + +enum how_to_pack { + ISIS_ITEMS, + ISIS_MT_ITEMS, +}; + +struct pack_order_entry { + enum isis_tlv_context context; + enum isis_tlv_type type; + enum how_to_pack how_to_pack; + size_t what_to_pack; +}; +#define PACK_ENTRY(t, h, w) \ + { \ + .context = ISIS_CONTEXT_LSP, .type = ISIS_TLV_##t, \ + .how_to_pack = (h), \ + .what_to_pack = offsetof(struct isis_tlvs, w), \ + } + +static struct pack_order_entry pack_order[] = { + PACK_ENTRY(OLDSTYLE_REACH, ISIS_ITEMS, oldstyle_reach), + PACK_ENTRY(LAN_NEIGHBORS, ISIS_ITEMS, lan_neighbor), + PACK_ENTRY(LSP_ENTRY, ISIS_ITEMS, lsp_entries), + PACK_ENTRY(EXTENDED_REACH, ISIS_ITEMS, extended_reach), + PACK_ENTRY(MT_REACH, ISIS_MT_ITEMS, mt_reach), + PACK_ENTRY(OLDSTYLE_IP_REACH, ISIS_ITEMS, oldstyle_ip_reach), + PACK_ENTRY(OLDSTYLE_IP_REACH_EXT, ISIS_ITEMS, oldstyle_ip_reach_ext), + PACK_ENTRY(IPV4_ADDRESS, ISIS_ITEMS, ipv4_address), + PACK_ENTRY(IPV6_ADDRESS, ISIS_ITEMS, ipv6_address), + PACK_ENTRY(EXTENDED_IP_REACH, ISIS_ITEMS, extended_ip_reach), + PACK_ENTRY(MT_IP_REACH, ISIS_MT_ITEMS, mt_ip_reach), + PACK_ENTRY(IPV6_REACH, ISIS_ITEMS, ipv6_reach), + PACK_ENTRY(MT_IPV6_REACH, ISIS_MT_ITEMS, mt_ipv6_reach)}; + +/* This is a forward definition. The table is actually initialized + * in at the bottom. */ +static const struct tlv_ops *tlv_table[ISIS_CONTEXT_MAX][ISIS_TLV_MAX]; + +/* End of _ops forward definition. */ + +/* Prototypes */ +static void append_item(struct isis_item_list *dest, struct isis_item *item); + +/* Functions for Sub-TVL ??? IPv6 Source Prefix */ + +static struct prefix_ipv6 *copy_subtlv_ipv6_source_prefix(struct prefix_ipv6 *p) +{ + if (!p) + return NULL; + + struct prefix_ipv6 *rv = XCALLOC(MTYPE_ISIS_SUBTLV, sizeof(*rv)); + rv->family = p->family; + rv->prefixlen = p->prefixlen; + memcpy(&rv->prefix, &p->prefix, sizeof(rv->prefix)); + return rv; +} + +static void format_subtlv_ipv6_source_prefix(struct prefix_ipv6 *p, + struct sbuf *buf, int indent) +{ + if (!p) + return; + + char prefixbuf[PREFIX2STR_BUFFER]; + sbuf_push(buf, indent, "IPv6 Source Prefix: %s\n", + prefix2str(p, prefixbuf, sizeof(prefixbuf))); +} + +static int pack_subtlv_ipv6_source_prefix(struct prefix_ipv6 *p, + struct stream *s) +{ + if (!p) + return 0; + + if (STREAM_WRITEABLE(s) < 3 + (unsigned)PSIZE(p->prefixlen)) + return 1; + + stream_putc(s, ISIS_SUBTLV_IPV6_SOURCE_PREFIX); + stream_putc(s, 1 + PSIZE(p->prefixlen)); + stream_putc(s, p->prefixlen); + stream_put(s, &p->prefix, PSIZE(p->prefixlen)); + return 0; +} + +static int unpack_subtlv_ipv6_source_prefix(enum isis_tlv_context context, + uint8_t tlv_type, uint8_t tlv_len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_subtlvs *subtlvs = dest; + struct prefix_ipv6 p = { + .family = AF_INET6, + }; + + sbuf_push(log, indent, "Unpacking IPv6 Source Prefix Sub-TLV...\n"); + + if (tlv_len < 1) { + sbuf_push(log, indent, + "Not enough data left. (expected 1 or more bytes, got %" PRIu8 ")\n", + tlv_len); + return 1; + } + + p.prefixlen = stream_getc(s); + if (p.prefixlen > 128) { + sbuf_push(log, indent, "Prefixlen %u is inplausible for IPv6\n", + p.prefixlen); + return 1; + } + + if (tlv_len != 1 + PSIZE(p.prefixlen)) { + sbuf_push( + log, indent, + "TLV size differs from expected size for the prefixlen. " + "(expected %u but got %" PRIu8 ")\n", + 1 + PSIZE(p.prefixlen), tlv_len); + return 1; + } + + stream_get(&p.prefix, s, PSIZE(p.prefixlen)); + + if (subtlvs->source_prefix) { + sbuf_push( + log, indent, + "WARNING: source prefix Sub-TLV present multiple times.\n"); + /* Ignore all but first occurrence of the source prefix Sub-TLV + */ + return 0; + } + + subtlvs->source_prefix = XCALLOC(MTYPE_ISIS_SUBTLV, sizeof(p)); + memcpy(subtlvs->source_prefix, &p, sizeof(p)); + return 0; +} + +/* Functions related to subtlvs */ + +static struct isis_subtlvs *isis_alloc_subtlvs(void) +{ + struct isis_subtlvs *result; + + result = XCALLOC(MTYPE_ISIS_SUBTLV, sizeof(*result)); + + return result; +} + +static struct isis_subtlvs *copy_subtlvs(struct isis_subtlvs *subtlvs) +{ + if (!subtlvs) + return NULL; + + struct isis_subtlvs *rv = XCALLOC(MTYPE_ISIS_SUBTLV, sizeof(*rv)); + + rv->source_prefix = + copy_subtlv_ipv6_source_prefix(subtlvs->source_prefix); + return rv; +} + +static void format_subtlvs(struct isis_subtlvs *subtlvs, struct sbuf *buf, + int indent) +{ + format_subtlv_ipv6_source_prefix(subtlvs->source_prefix, buf, indent); +} + +static void isis_free_subtlvs(struct isis_subtlvs *subtlvs) +{ + if (!subtlvs) + return; + + XFREE(MTYPE_ISIS_SUBTLV, subtlvs->source_prefix); + + XFREE(MTYPE_ISIS_SUBTLV, subtlvs); +} + +static int pack_subtlvs(struct isis_subtlvs *subtlvs, struct stream *s) +{ + int rv; + size_t subtlv_len_pos = stream_get_endp(s); + + if (STREAM_WRITEABLE(s) < 1) + return 1; + + stream_putc(s, 0); /* Put 0 as subtlvs length, filled in later */ + + rv = pack_subtlv_ipv6_source_prefix(subtlvs->source_prefix, s); + if (rv) + return rv; + + size_t subtlv_len = stream_get_endp(s) - subtlv_len_pos - 1; + if (subtlv_len > 255) + return 1; + + stream_putc_at(s, subtlv_len_pos, subtlv_len); + return 0; +} + +static int unpack_tlvs(enum isis_tlv_context context, size_t avail_len, + struct stream *stream, struct sbuf *log, void *dest, + int indent); + +/* Functions related to TLVs 1 Area Addresses */ + +static struct isis_item *copy_item_area_address(struct isis_item *i) +{ + struct isis_area_address *addr = (struct isis_area_address *)i; + struct isis_area_address *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->len = addr->len; + memcpy(rv->addr, addr->addr, addr->len); + return (struct isis_item *)rv; +} + +static void format_item_area_address(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_area_address *addr = (struct isis_area_address *)i; + + sbuf_push(buf, indent, "Area Address: %s\n", + isonet_print(addr->addr, addr->len)); +} + +static void free_item_area_address(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_area_address(struct isis_item *i, struct stream *s) +{ + struct isis_area_address *addr = (struct isis_area_address *)i; + + if (STREAM_WRITEABLE(s) < (unsigned)1 + addr->len) + return 1; + stream_putc(s, addr->len); + stream_put(s, addr->addr, addr->len); + return 0; +} + +static int unpack_item_area_address(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + struct isis_area_address *rv = NULL; + + sbuf_push(log, indent, "Unpack area address...\n"); + if (len < 1) { + sbuf_push( + log, indent, + "Not enough data left. (Expected 1 byte of address length, got %" PRIu8 + ")\n", + len); + goto out; + } + + rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + rv->len = stream_getc(s); + + if (len < 1 + rv->len) { + sbuf_push(log, indent, "Not enough data left. (Expected %" PRIu8 + " bytes of address, got %" PRIu8 ")\n", + rv->len, len - 1); + goto out; + } + + if (rv->len < 1 || rv->len > 20) { + sbuf_push(log, indent, + "Implausible area address length %" PRIu8 "\n", + rv->len); + goto out; + } + + stream_get(rv->addr, s, rv->len); + + format_item_area_address(ISIS_MT_IPV4_UNICAST, (struct isis_item *)rv, + log, indent + 2); + append_item(&tlvs->area_addresses, (struct isis_item *)rv); + return 0; +out: + XFREE(MTYPE_ISIS_TLV2, rv); + return 1; +} + +/* Functions related to TLV 2 (Old-Style) IS Reach */ +static struct isis_item *copy_item_oldstyle_reach(struct isis_item *i) +{ + struct isis_oldstyle_reach *r = (struct isis_oldstyle_reach *)i; + struct isis_oldstyle_reach *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + memcpy(rv->id, r->id, 7); + rv->metric = r->metric; + return (struct isis_item *)rv; +} + +static void format_item_oldstyle_reach(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_oldstyle_reach *r = (struct isis_oldstyle_reach *)i; + + sbuf_push(buf, indent, "IS Reachability: %s (Metric: %" PRIu8 ")\n", + isis_format_id(r->id, 7), r->metric); +} + +static void free_item_oldstyle_reach(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_oldstyle_reach(struct isis_item *i, struct stream *s) +{ + struct isis_oldstyle_reach *r = (struct isis_oldstyle_reach *)i; + + if (STREAM_WRITEABLE(s) < 11) + return 1; + + stream_putc(s, r->metric); + stream_putc(s, 0x80); /* delay metric - unsupported */ + stream_putc(s, 0x80); /* expense metric - unsupported */ + stream_putc(s, 0x80); /* error metric - unsupported */ + stream_put(s, r->id, 7); + + return 0; +} + +static int unpack_item_oldstyle_reach(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack oldstyle reach...\n"); + if (len < 11) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 11 bytes of reach information, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_oldstyle_reach *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + rv->metric = stream_getc(s); + if ((rv->metric & 0x3f) != rv->metric) { + sbuf_push(log, indent, "Metric has unplausible format\n"); + rv->metric &= 0x3f; + } + stream_forward_getp(s, 3); /* Skip other metrics */ + stream_get(rv->id, s, 7); + + format_item_oldstyle_reach(mtid, (struct isis_item *)rv, log, + indent + 2); + append_item(&tlvs->oldstyle_reach, (struct isis_item *)rv); + return 0; +} + +/* Functions related to TLV 6 LAN Neighbors */ +static struct isis_item *copy_item_lan_neighbor(struct isis_item *i) +{ + struct isis_lan_neighbor *n = (struct isis_lan_neighbor *)i; + struct isis_lan_neighbor *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + memcpy(rv->mac, n->mac, 6); + return (struct isis_item *)rv; +} + +static void format_item_lan_neighbor(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_lan_neighbor *n = (struct isis_lan_neighbor *)i; + + sbuf_push(buf, indent, "LAN Neighbor: %s\n", isis_format_id(n->mac, 6)); +} + +static void free_item_lan_neighbor(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_lan_neighbor(struct isis_item *i, struct stream *s) +{ + struct isis_lan_neighbor *n = (struct isis_lan_neighbor *)i; + + if (STREAM_WRITEABLE(s) < 6) + return 1; + + stream_put(s, n->mac, 6); + + return 0; +} + +static int unpack_item_lan_neighbor(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack LAN neighbor...\n"); + if (len < 6) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 6 bytes of mac, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_lan_neighbor *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + stream_get(rv->mac, s, 6); + + format_item_lan_neighbor(mtid, (struct isis_item *)rv, log, indent + 2); + append_item(&tlvs->lan_neighbor, (struct isis_item *)rv); + return 0; +} + +/* Functions related to TLV 9 LSP Entry */ +static struct isis_item *copy_item_lsp_entry(struct isis_item *i) +{ + struct isis_lsp_entry *e = (struct isis_lsp_entry *)i; + struct isis_lsp_entry *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->rem_lifetime = e->rem_lifetime; + memcpy(rv->id, e->id, sizeof(rv->id)); + rv->seqno = e->seqno; + rv->checksum = e->checksum; + + return (struct isis_item *)rv; +} + +static void format_item_lsp_entry(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_lsp_entry *e = (struct isis_lsp_entry *)i; + + sbuf_push(buf, indent, "LSP Entry: %s, seq 0x%08" PRIx32 + ", cksum 0x%04" PRIx16 ", lifetime %" PRIu16 "s\n", + isis_format_id(e->id, 8), e->seqno, e->checksum, + e->rem_lifetime); +} + +static void free_item_lsp_entry(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_lsp_entry(struct isis_item *i, struct stream *s) +{ + struct isis_lsp_entry *e = (struct isis_lsp_entry *)i; + + if (STREAM_WRITEABLE(s) < 16) + return 1; + + stream_putw(s, e->rem_lifetime); + stream_put(s, e->id, 8); + stream_putl(s, e->seqno); + stream_putw(s, e->checksum); + + return 0; +} + +static int unpack_item_lsp_entry(uint16_t mtid, uint8_t len, struct stream *s, + struct sbuf *log, void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack LSP entry...\n"); + if (len < 16) { + sbuf_push( + log, indent, + "Not enough data left. (Expected 16 bytes of LSP info, got %" PRIu8, + len); + return 1; + } + + struct isis_lsp_entry *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + rv->rem_lifetime = stream_getw(s); + stream_get(rv->id, s, 8); + rv->seqno = stream_getl(s); + rv->checksum = stream_getw(s); + + format_item_lsp_entry(mtid, (struct isis_item *)rv, log, indent + 2); + append_item(&tlvs->lsp_entries, (struct isis_item *)rv); + return 0; +} + +/* Functions related to TLVs 22/222 Extended Reach/MT Reach */ + +static struct isis_item *copy_item_extended_reach(struct isis_item *i) +{ + struct isis_extended_reach *r = (struct isis_extended_reach *)i; + struct isis_extended_reach *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + memcpy(rv->id, r->id, 7); + rv->metric = r->metric; + + if (r->subtlvs && r->subtlv_len) { + rv->subtlvs = XCALLOC(MTYPE_ISIS_TLV2, r->subtlv_len); + memcpy(rv->subtlvs, r->subtlvs, r->subtlv_len); + rv->subtlv_len = r->subtlv_len; + } + + return (struct isis_item *)rv; +} + +static void format_item_extended_reach(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_extended_reach *r = (struct isis_extended_reach *)i; + + sbuf_push(buf, indent, "%s Reachability: %s (Metric: %u)", + (mtid == ISIS_MT_IPV4_UNICAST) ? "Extended" : "MT", + isis_format_id(r->id, 7), r->metric); + if (mtid != ISIS_MT_IPV4_UNICAST) + sbuf_push(buf, 0, " %s", isis_mtid2str(mtid)); + sbuf_push(buf, 0, "\n"); + + if (r->subtlv_len && r->subtlvs) + mpls_te_print_detail(buf, indent + 2, r->subtlvs, r->subtlv_len); +} + +static void free_item_extended_reach(struct isis_item *i) +{ + struct isis_extended_reach *item = (struct isis_extended_reach *)i; + XFREE(MTYPE_ISIS_TLV2, item->subtlvs); + XFREE(MTYPE_ISIS_TLV2, item); +} + +static int pack_item_extended_reach(struct isis_item *i, struct stream *s) +{ + struct isis_extended_reach *r = (struct isis_extended_reach *)i; + + if (STREAM_WRITEABLE(s) < 11 + (unsigned)r->subtlv_len) + return 1; + stream_put(s, r->id, sizeof(r->id)); + stream_put3(s, r->metric); + stream_putc(s, r->subtlv_len); + stream_put(s, r->subtlvs, r->subtlv_len); + return 0; +} + +static int unpack_item_extended_reach(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + struct isis_extended_reach *rv = NULL; + uint8_t subtlv_len; + struct isis_item_list *items; + + if (mtid == ISIS_MT_IPV4_UNICAST) { + items = &tlvs->extended_reach; + } else { + items = isis_get_mt_items(&tlvs->mt_reach, mtid); + } + + sbuf_push(log, indent, "Unpacking %s reachability...\n", + (mtid == ISIS_MT_IPV4_UNICAST) ? "extended" : "mt"); + + if (len < 11) { + sbuf_push(log, indent, + "Not enough data left. (expected 11 or more bytes, got %" + PRIu8 ")\n", + len); + goto out; + } + + rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + stream_get(rv->id, s, 7); + rv->metric = stream_get3(s); + subtlv_len = stream_getc(s); + + format_item_extended_reach(mtid, (struct isis_item *)rv, log, + indent + 2); + + if ((size_t)len < ((size_t)11) + subtlv_len) { + sbuf_push(log, indent, + "Not enough data left for subtlv size %" PRIu8 + ", there are only %" PRIu8 " bytes left.\n", + subtlv_len, len - 11); + goto out; + } + + sbuf_push(log, indent, "Storing %" PRIu8 " bytes of subtlvs\n", + subtlv_len); + + if (subtlv_len) { + size_t subtlv_start = stream_get_getp(s); + + if (unpack_tlvs(ISIS_CONTEXT_SUBTLV_NE_REACH, subtlv_len, s, + log, NULL, indent + 4)) { + goto out; + } + + stream_set_getp(s, subtlv_start); + + rv->subtlvs = XCALLOC(MTYPE_ISIS_TLV2, subtlv_len); + stream_get(rv->subtlvs, s, subtlv_len); + rv->subtlv_len = subtlv_len; + } + + append_item(items, (struct isis_item *)rv); + return 0; +out: + if (rv) + free_item_extended_reach((struct isis_item *)rv); + + return 1; +} + +/* Functions related to TLV 128 (Old-Style) IP Reach */ +static struct isis_item *copy_item_oldstyle_ip_reach(struct isis_item *i) +{ + struct isis_oldstyle_ip_reach *r = (struct isis_oldstyle_ip_reach *)i; + struct isis_oldstyle_ip_reach *rv = + XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->metric = r->metric; + rv->prefix = r->prefix; + return (struct isis_item *)rv; +} + +static void format_item_oldstyle_ip_reach(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_oldstyle_ip_reach *r = (struct isis_oldstyle_ip_reach *)i; + char prefixbuf[PREFIX2STR_BUFFER]; + + sbuf_push(buf, indent, "IP Reachability: %s (Metric: %" PRIu8 ")\n", + prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)), r->metric); +} + +static void free_item_oldstyle_ip_reach(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_oldstyle_ip_reach(struct isis_item *i, struct stream *s) +{ + struct isis_oldstyle_ip_reach *r = (struct isis_oldstyle_ip_reach *)i; + + if (STREAM_WRITEABLE(s) < 12) + return 1; + + stream_putc(s, r->metric); + stream_putc(s, 0x80); /* delay metric - unsupported */ + stream_putc(s, 0x80); /* expense metric - unsupported */ + stream_putc(s, 0x80); /* error metric - unsupported */ + stream_put(s, &r->prefix.prefix, 4); + + struct in_addr mask; + masklen2ip(r->prefix.prefixlen, &mask); + stream_put(s, &mask, sizeof(mask)); + + return 0; +} + +static int unpack_item_oldstyle_ip_reach(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + sbuf_push(log, indent, "Unpack oldstyle ip reach...\n"); + if (len < 12) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 12 bytes of reach information, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_oldstyle_ip_reach *rv = + XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + rv->metric = stream_getc(s); + if ((rv->metric & 0x7f) != rv->metric) { + sbuf_push(log, indent, "Metric has unplausible format\n"); + rv->metric &= 0x7f; + } + stream_forward_getp(s, 3); /* Skip other metrics */ + rv->prefix.family = AF_INET; + stream_get(&rv->prefix.prefix, s, 4); + + struct in_addr mask; + stream_get(&mask, s, 4); + rv->prefix.prefixlen = ip_masklen(mask); + + format_item_oldstyle_ip_reach(mtid, (struct isis_item *)rv, log, + indent + 2); + append_item(dest, (struct isis_item *)rv); + return 0; +} + + +/* Functions related to TLV 129 protocols supported */ + +static void copy_tlv_protocols_supported(struct isis_protocols_supported *src, + struct isis_protocols_supported *dest) +{ + if (!src->protocols || !src->count) + return; + dest->count = src->count; + dest->protocols = XCALLOC(MTYPE_ISIS_TLV2, src->count); + memcpy(dest->protocols, src->protocols, src->count); +} + +static void format_tlv_protocols_supported(struct isis_protocols_supported *p, + struct sbuf *buf, int indent) +{ + if (!p || !p->count || !p->protocols) + return; + + sbuf_push(buf, indent, "Protocols Supported: "); + for (uint8_t i = 0; i < p->count; i++) { + sbuf_push(buf, 0, "%s%s", nlpid2str(p->protocols[i]), + (i + 1 < p->count) ? ", " : ""); + } + sbuf_push(buf, 0, "\n"); +} + +static void free_tlv_protocols_supported(struct isis_protocols_supported *p) +{ + XFREE(MTYPE_ISIS_TLV2, p->protocols); +} + +static int pack_tlv_protocols_supported(struct isis_protocols_supported *p, + struct stream *s) +{ + if (!p || !p->count || !p->protocols) + return 0; + + if (STREAM_WRITEABLE(s) < (unsigned)(p->count + 2)) + return 1; + + stream_putc(s, ISIS_TLV_PROTOCOLS_SUPPORTED); + stream_putc(s, p->count); + stream_put(s, p->protocols, p->count); + return 0; +} + +static int unpack_tlv_protocols_supported(enum isis_tlv_context context, + uint8_t tlv_type, uint8_t tlv_len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpacking Protocols Supported TLV...\n"); + if (!tlv_len) { + sbuf_push(log, indent, "WARNING: No protocols included\n"); + return 0; + } + if (tlvs->protocols_supported.protocols) { + sbuf_push( + log, indent, + "WARNING: protocols supported TLV present multiple times.\n"); + stream_forward_getp(s, tlv_len); + return 0; + } + + tlvs->protocols_supported.count = tlv_len; + tlvs->protocols_supported.protocols = XCALLOC(MTYPE_ISIS_TLV2, tlv_len); + stream_get(tlvs->protocols_supported.protocols, s, tlv_len); + + format_tlv_protocols_supported(&tlvs->protocols_supported, log, + indent + 2); + return 0; +} + +/* Functions related to TLV 132 IPv4 Interface addresses */ +static struct isis_item *copy_item_ipv4_address(struct isis_item *i) +{ + struct isis_ipv4_address *a = (struct isis_ipv4_address *)i; + struct isis_ipv4_address *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->addr = a->addr; + return (struct isis_item *)rv; +} + +static void format_item_ipv4_address(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_ipv4_address *a = (struct isis_ipv4_address *)i; + char addrbuf[INET_ADDRSTRLEN]; + + inet_ntop(AF_INET, &a->addr, addrbuf, sizeof(addrbuf)); + sbuf_push(buf, indent, "IPv4 Interface Address: %s\n", addrbuf); +} + +static void free_item_ipv4_address(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_ipv4_address(struct isis_item *i, struct stream *s) +{ + struct isis_ipv4_address *a = (struct isis_ipv4_address *)i; + + if (STREAM_WRITEABLE(s) < 4) + return 1; + + stream_put(s, &a->addr, 4); + + return 0; +} + +static int unpack_item_ipv4_address(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack IPv4 Interface address...\n"); + if (len < 4) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 4 bytes of IPv4 address, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_ipv4_address *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + stream_get(&rv->addr, s, 4); + + format_item_ipv4_address(mtid, (struct isis_item *)rv, log, indent + 2); + append_item(&tlvs->ipv4_address, (struct isis_item *)rv); + return 0; +} + + +/* Functions related to TLV 232 IPv6 Interface addresses */ +static struct isis_item *copy_item_ipv6_address(struct isis_item *i) +{ + struct isis_ipv6_address *a = (struct isis_ipv6_address *)i; + struct isis_ipv6_address *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->addr = a->addr; + return (struct isis_item *)rv; +} + +static void format_item_ipv6_address(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_ipv6_address *a = (struct isis_ipv6_address *)i; + char addrbuf[INET6_ADDRSTRLEN]; + + inet_ntop(AF_INET6, &a->addr, addrbuf, sizeof(addrbuf)); + sbuf_push(buf, indent, "IPv6 Interface Address: %s\n", addrbuf); +} + +static void free_item_ipv6_address(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_ipv6_address(struct isis_item *i, struct stream *s) +{ + struct isis_ipv6_address *a = (struct isis_ipv6_address *)i; + + if (STREAM_WRITEABLE(s) < 16) + return 1; + + stream_put(s, &a->addr, 16); + + return 0; +} + +static int unpack_item_ipv6_address(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack IPv6 Interface address...\n"); + if (len < 16) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 16 bytes of IPv6 address, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_ipv6_address *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + stream_get(&rv->addr, s, 16); + + format_item_ipv6_address(mtid, (struct isis_item *)rv, log, indent + 2); + append_item(&tlvs->ipv6_address, (struct isis_item *)rv); + return 0; +} + + +/* Functions related to TLV 229 MT Router information */ +static struct isis_item *copy_item_mt_router_info(struct isis_item *i) +{ + struct isis_mt_router_info *info = (struct isis_mt_router_info *)i; + struct isis_mt_router_info *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->overload = info->overload; + rv->attached = info->attached; + rv->mtid = info->mtid; + return (struct isis_item *)rv; +} + +static void format_item_mt_router_info(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_mt_router_info *info = (struct isis_mt_router_info *)i; + + sbuf_push(buf, indent, "MT Router Info: %s%s%s\n", + isis_mtid2str(info->mtid), + info->overload ? " Overload" : "", + info->attached ? " Attached" : ""); +} + +static void free_item_mt_router_info(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_mt_router_info(struct isis_item *i, struct stream *s) +{ + struct isis_mt_router_info *info = (struct isis_mt_router_info *)i; + + if (STREAM_WRITEABLE(s) < 2) + return 1; + + uint16_t entry = info->mtid; + + if (info->overload) + entry |= ISIS_MT_OL_MASK; + if (info->attached) + entry |= ISIS_MT_AT_MASK; + + stream_putw(s, entry); + + return 0; +} + +static int unpack_item_mt_router_info(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack MT Router info...\n"); + if (len < 2) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 2 bytes of MT info, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_mt_router_info *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + uint16_t entry = stream_getw(s); + rv->overload = entry & ISIS_MT_OL_MASK; + rv->attached = entry & ISIS_MT_AT_MASK; + rv->mtid = entry & ISIS_MT_MASK; + + format_item_mt_router_info(mtid, (struct isis_item *)rv, log, + indent + 2); + append_item(&tlvs->mt_router_info, (struct isis_item *)rv); + return 0; +} + +/* Functions related to TLV 134 TE Router ID */ + +static struct in_addr *copy_tlv_te_router_id(const struct in_addr *id) +{ + if (!id) + return NULL; + + struct in_addr *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + memcpy(rv, id, sizeof(*rv)); + return rv; +} + +static void format_tlv_te_router_id(const struct in_addr *id, struct sbuf *buf, + int indent) +{ + if (!id) + return; + + char addrbuf[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, id, addrbuf, sizeof(addrbuf)); + sbuf_push(buf, indent, "TE Router ID: %s\n", addrbuf); +} + +static void free_tlv_te_router_id(struct in_addr *id) +{ + XFREE(MTYPE_ISIS_TLV2, id); +} + +static int pack_tlv_te_router_id(const struct in_addr *id, struct stream *s) +{ + if (!id) + return 0; + + if (STREAM_WRITEABLE(s) < (unsigned)(2 + sizeof(*id))) + return 1; + + stream_putc(s, ISIS_TLV_TE_ROUTER_ID); + stream_putc(s, 4); + stream_put(s, id, 4); + return 0; +} + +static int unpack_tlv_te_router_id(enum isis_tlv_context context, + uint8_t tlv_type, uint8_t tlv_len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpacking TE Router ID TLV...\n"); + if (tlv_len != 4) { + sbuf_push(log, indent, "WARNING: Length invalid\n"); + return 1; + } + + if (tlvs->te_router_id) { + sbuf_push(log, indent, + "WARNING: TE Router ID present multiple times.\n"); + stream_forward_getp(s, tlv_len); + return 0; + } + + tlvs->te_router_id = XCALLOC(MTYPE_ISIS_TLV2, 4); + stream_get(tlvs->te_router_id, s, 4); + format_tlv_te_router_id(tlvs->te_router_id, log, indent + 2); + return 0; +} + + +/* Functions related to TLVs 135/235 extended IP reach/MT IP Reach */ + +static struct isis_item *copy_item_extended_ip_reach(struct isis_item *i) +{ + struct isis_extended_ip_reach *r = (struct isis_extended_ip_reach *)i; + struct isis_extended_ip_reach *rv = + XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->metric = r->metric; + rv->down = r->down; + rv->prefix = r->prefix; + + return (struct isis_item *)rv; +} + +static void format_item_extended_ip_reach(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_extended_ip_reach *r = (struct isis_extended_ip_reach *)i; + char prefixbuf[PREFIX2STR_BUFFER]; + + sbuf_push(buf, indent, "%s IP Reachability: %s (Metric: %u)%s", + (mtid == ISIS_MT_IPV4_UNICAST) ? "Extended" : "MT", + prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)), r->metric, + r->down ? " Down" : ""); + if (mtid != ISIS_MT_IPV4_UNICAST) + sbuf_push(buf, 0, " %s", isis_mtid2str(mtid)); + sbuf_push(buf, 0, "\n"); +} + +static void free_item_extended_ip_reach(struct isis_item *i) +{ + struct isis_extended_ip_reach *item = + (struct isis_extended_ip_reach *)i; + XFREE(MTYPE_ISIS_TLV2, item); +} + +static int pack_item_extended_ip_reach(struct isis_item *i, struct stream *s) +{ + struct isis_extended_ip_reach *r = (struct isis_extended_ip_reach *)i; + uint8_t control; + + if (STREAM_WRITEABLE(s) < 5) + return 1; + stream_putl(s, r->metric); + + control = r->down ? ISIS_EXTENDED_IP_REACH_DOWN : 0; + control |= r->prefix.prefixlen; + stream_putc(s, control); + + if (STREAM_WRITEABLE(s) < (unsigned)PSIZE(r->prefix.prefixlen)) + return 1; + stream_put(s, &r->prefix.prefix.s_addr, PSIZE(r->prefix.prefixlen)); + return 0; +} + +static int unpack_item_extended_ip_reach(uint16_t mtid, uint8_t len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + struct isis_extended_ip_reach *rv = NULL; + size_t consume; + uint8_t control, subtlv_len; + struct isis_item_list *items; + + if (mtid == ISIS_MT_IPV4_UNICAST) { + items = &tlvs->extended_ip_reach; + } else { + items = isis_get_mt_items(&tlvs->mt_ip_reach, mtid); + } + + sbuf_push(log, indent, "Unpacking %s IPv4 reachability...\n", + (mtid == ISIS_MT_IPV4_UNICAST) ? "extended" : "mt"); + + consume = 5; + if (len < consume) { + sbuf_push(log, indent, + "Not enough data left. (expected 5 or more bytes, got %" PRIu8 ")\n", + len); + goto out; + } + + rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->metric = stream_getl(s); + control = stream_getc(s); + rv->down = (control & ISIS_EXTENDED_IP_REACH_DOWN); + rv->prefix.family = AF_INET; + rv->prefix.prefixlen = control & 0x3f; + if (rv->prefix.prefixlen > 32) { + sbuf_push(log, indent, "Prefixlen %u is inplausible for IPv4\n", + rv->prefix.prefixlen); + goto out; + } + + consume += PSIZE(rv->prefix.prefixlen); + if (len < consume) { + sbuf_push(log, indent, + "Expected %u bytes of prefix, but only %u bytes available.\n", + PSIZE(rv->prefix.prefixlen), len - 5); + goto out; + } + stream_get(&rv->prefix.prefix.s_addr, s, PSIZE(rv->prefix.prefixlen)); + in_addr_t orig_prefix = rv->prefix.prefix.s_addr; + apply_mask_ipv4(&rv->prefix); + if (orig_prefix != rv->prefix.prefix.s_addr) + sbuf_push(log, indent + 2, + "WARNING: Prefix had hostbits set.\n"); + format_item_extended_ip_reach(mtid, (struct isis_item *)rv, log, + indent + 2); + + if (control & ISIS_EXTENDED_IP_REACH_SUBTLV) { + consume += 1; + if (len < consume) { + sbuf_push(log, indent, + "Expected 1 byte of subtlv len, but no more data present.\n"); + goto out; + } + subtlv_len = stream_getc(s); + + if (!subtlv_len) { + sbuf_push(log, indent + 2, + " WARNING: subtlv bit is set, but there are no subtlvs.\n"); + } + consume += subtlv_len; + if (len < consume) { + sbuf_push(log, indent, + "Expected %" PRIu8 + " bytes of subtlvs, but only %u bytes available.\n", + subtlv_len, + len - 6 - PSIZE(rv->prefix.prefixlen)); + goto out; + } + sbuf_push(log, indent, "Skipping %" PRIu8 " bytes of subvls", + subtlv_len); + stream_forward_getp(s, subtlv_len); + } + + append_item(items, (struct isis_item *)rv); + return 0; +out: + if (rv) + free_item_extended_ip_reach((struct isis_item *)rv); + return 1; +} + +/* Functions related to TLV 137 Dynamic Hostname */ + +static char *copy_tlv_dynamic_hostname(const char *hostname) +{ + if (!hostname) + return NULL; + + return XSTRDUP(MTYPE_ISIS_TLV2, hostname); +} + +static void format_tlv_dynamic_hostname(const char *hostname, struct sbuf *buf, + int indent) +{ + if (!hostname) + return; + + sbuf_push(buf, indent, "Hostname: %s\n", hostname); +} + +static void free_tlv_dynamic_hostname(char *hostname) +{ + XFREE(MTYPE_ISIS_TLV2, hostname); +} + +static int pack_tlv_dynamic_hostname(const char *hostname, struct stream *s) +{ + if (!hostname) + return 0; + + uint8_t name_len = strlen(hostname); + + if (STREAM_WRITEABLE(s) < (unsigned)(2 + name_len)) + return 1; + + stream_putc(s, ISIS_TLV_DYNAMIC_HOSTNAME); + stream_putc(s, name_len); + stream_put(s, hostname, name_len); + return 0; +} + +static int unpack_tlv_dynamic_hostname(enum isis_tlv_context context, + uint8_t tlv_type, uint8_t tlv_len, + struct stream *s, struct sbuf *log, + void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpacking Dynamic Hostname TLV...\n"); + if (!tlv_len) { + sbuf_push(log, indent, "WARNING: No hostname included\n"); + return 0; + } + + if (tlvs->hostname) { + sbuf_push(log, indent, + "WARNING: Hostname present multiple times.\n"); + stream_forward_getp(s, tlv_len); + return 0; + } + + tlvs->hostname = XCALLOC(MTYPE_ISIS_TLV2, tlv_len + 1); + stream_get(tlvs->hostname, s, tlv_len); + tlvs->hostname[tlv_len] = '\0'; + + bool sane = true; + for (uint8_t i = 0; i < tlv_len; i++) { + if ((unsigned char)tlvs->hostname[i] > 127 + || !isprint(tlvs->hostname[i])) { + sane = false; + tlvs->hostname[i] = '?'; + } + } + if (!sane) { + sbuf_push( + log, indent, + "WARNING: Hostname contained non-printable/non-ascii characters.\n"); + } + + return 0; +} + +/* Functions related to TLVs 236/237 IPv6/MT-IPv6 reach */ + +static struct isis_item *copy_item_ipv6_reach(struct isis_item *i) +{ + struct isis_ipv6_reach *r = (struct isis_ipv6_reach *)i; + struct isis_ipv6_reach *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + rv->metric = r->metric; + rv->down = r->down; + rv->external = r->external; + rv->prefix = r->prefix; + rv->subtlvs = copy_subtlvs(r->subtlvs); + + return (struct isis_item *)rv; +} + +static void format_item_ipv6_reach(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_ipv6_reach *r = (struct isis_ipv6_reach *)i; + char prefixbuf[PREFIX2STR_BUFFER]; + + sbuf_push(buf, indent, "%sIPv6 Reachability: %s (Metric: %u)%s%s", + (mtid == ISIS_MT_IPV4_UNICAST) ? "" : "MT ", + prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)), + r->metric, + r->down ? " Down" : "", + r->external ? " External" : ""); + if (mtid != ISIS_MT_IPV4_UNICAST) + sbuf_push(buf, 0, " %s", isis_mtid2str(mtid)); + sbuf_push(buf, 0, "\n"); + + if (r->subtlvs) { + sbuf_push(buf, indent, " Subtlvs:\n"); + format_subtlvs(r->subtlvs, buf, indent + 4); + } +} + +static void free_item_ipv6_reach(struct isis_item *i) +{ + struct isis_ipv6_reach *item = (struct isis_ipv6_reach *)i; + + isis_free_subtlvs(item->subtlvs); + XFREE(MTYPE_ISIS_TLV2, item); +} + +static int pack_item_ipv6_reach(struct isis_item *i, struct stream *s) +{ + struct isis_ipv6_reach *r = (struct isis_ipv6_reach *)i; + uint8_t control; + + if (STREAM_WRITEABLE(s) < 6) + return 1; + stream_putl(s, r->metric); + + control = r->down ? ISIS_IPV6_REACH_DOWN : 0; + control |= r->external ? ISIS_IPV6_REACH_EXTERNAL : 0; + control |= r->subtlvs ? ISIS_IPV6_REACH_SUBTLV : 0; + + stream_putc(s, control); + stream_putc(s, r->prefix.prefixlen); + + if (STREAM_WRITEABLE(s) < (unsigned)PSIZE(r->prefix.prefixlen)) + return 1; + stream_put(s, &r->prefix.prefix.s6_addr, PSIZE(r->prefix.prefixlen)); + + if (r->subtlvs) + return pack_subtlvs(r->subtlvs, s); + + return 0; +} + +static int unpack_item_ipv6_reach(uint16_t mtid, uint8_t len, struct stream *s, + struct sbuf *log, void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + struct isis_ipv6_reach *rv = NULL; + size_t consume; + uint8_t control, subtlv_len; + struct isis_item_list *items; + + if (mtid == ISIS_MT_IPV4_UNICAST) { + items = &tlvs->ipv6_reach; + } else { + items = isis_get_mt_items(&tlvs->mt_ipv6_reach, mtid); + } + + sbuf_push(log, indent, "Unpacking %sIPv6 reachability...\n", + (mtid == ISIS_MT_IPV4_UNICAST) ? "" : "mt "); + consume = 6; + if (len < consume) { + sbuf_push(log, indent, + "Not enough data left. (expected 6 or more bytes, got %" + PRIu8 ")\n", + len); + goto out; + } + + rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->metric = stream_getl(s); + control = stream_getc(s); + rv->down = (control & ISIS_IPV6_REACH_DOWN); + rv->external = (control & ISIS_IPV6_REACH_EXTERNAL); + + rv->prefix.family = AF_INET6; + rv->prefix.prefixlen = stream_getc(s); + if (rv->prefix.prefixlen > 128) { + sbuf_push(log, indent, "Prefixlen %u is inplausible for IPv6\n", + rv->prefix.prefixlen); + goto out; + } + + consume += PSIZE(rv->prefix.prefixlen); + if (len < consume) { + sbuf_push(log, indent, + "Expected %u bytes of prefix, but only %u bytes available.\n", + PSIZE(rv->prefix.prefixlen), len - 6); + goto out; + } + stream_get(&rv->prefix.prefix.s6_addr, s, PSIZE(rv->prefix.prefixlen)); + struct in6_addr orig_prefix = rv->prefix.prefix; + apply_mask_ipv6(&rv->prefix); + if (memcmp(&orig_prefix, &rv->prefix.prefix, sizeof(orig_prefix))) + sbuf_push(log, indent + 2, + "WARNING: Prefix had hostbits set.\n"); + format_item_ipv6_reach(mtid, (struct isis_item *)rv, log, indent + 2); + + if (control & ISIS_IPV6_REACH_SUBTLV) { + consume += 1; + if (len < consume) { + sbuf_push(log, indent, + "Expected 1 byte of subtlv len, but no more data persent.\n"); + goto out; + } + subtlv_len = stream_getc(s); + + if (!subtlv_len) { + sbuf_push(log, indent + 2, + " WARNING: subtlv bit set, but there are no subtlvs.\n"); + } + consume += subtlv_len; + if (len < consume) { + sbuf_push(log, indent, + "Expected %" PRIu8 + " bytes of subtlvs, but only %u bytes available.\n", + subtlv_len, + len - 6 - PSIZE(rv->prefix.prefixlen)); + goto out; + } + + rv->subtlvs = isis_alloc_subtlvs(); + if (unpack_tlvs(ISIS_CONTEXT_SUBTLV_IPV6_REACH, subtlv_len, s, + log, rv->subtlvs, indent + 4)) { + goto out; + } + } + + append_item(items, (struct isis_item *)rv); + return 0; +out: + if (rv) + free_item_ipv6_reach((struct isis_item *)rv); + return 1; +} + +/* Functions related to TLV 10 Authentication */ +static struct isis_item *copy_item_auth(struct isis_item *i) +{ + struct isis_auth *auth = (struct isis_auth *)i; + struct isis_auth *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->type = auth->type; + rv->length = auth->length; + memcpy(rv->value, auth->value, sizeof(rv->value)); + return (struct isis_item *)rv; +} + +static void format_item_auth(uint16_t mtid, struct isis_item *i, + struct sbuf *buf, int indent) +{ + struct isis_auth *auth = (struct isis_auth *)i; + char obuf[768]; + + sbuf_push(buf, indent, "Authentication:\n"); + switch (auth->type) { + case ISIS_PASSWD_TYPE_CLEARTXT: + zlog_sanitize(obuf, sizeof(obuf), auth->value, auth->length); + sbuf_push(buf, indent, " Password: %s\n", obuf); + break; + case ISIS_PASSWD_TYPE_HMAC_MD5: + for (unsigned int i = 0; i < 16; i++) { + snprintf(obuf + 2 * i, sizeof(obuf) - 2 * i, + "%02" PRIx8, auth->value[i]); + } + sbuf_push(buf, indent, " HMAC-MD5: %s\n", obuf); + break; + default: + sbuf_push(buf, indent, " Unknown (%" PRIu8 ")\n", auth->type); + break; + }; +} + +static void free_item_auth(struct isis_item *i) +{ + XFREE(MTYPE_ISIS_TLV2, i); +} + +static int pack_item_auth(struct isis_item *i, struct stream *s) +{ + struct isis_auth *auth = (struct isis_auth *)i; + + if (STREAM_WRITEABLE(s) < 1) + return 1; + stream_putc(s, auth->type); + + switch (auth->type) { + case ISIS_PASSWD_TYPE_CLEARTXT: + if (STREAM_WRITEABLE(s) < auth->length) + return 1; + stream_put(s, auth->passwd, auth->length); + break; + case ISIS_PASSWD_TYPE_HMAC_MD5: + if (STREAM_WRITEABLE(s) < 16) + return 1; + auth->offset = stream_get_endp(s); + stream_put(s, NULL, 16); + break; + default: + return 1; + } + + return 0; +} + +static int unpack_item_auth(uint16_t mtid, uint8_t len, struct stream *s, + struct sbuf *log, void *dest, int indent) +{ + struct isis_tlvs *tlvs = dest; + + sbuf_push(log, indent, "Unpack Auth TLV...\n"); + if (len < 1) { + sbuf_push( + log, indent, + "Not enough data left.(Expected 1 bytes of auth type, got %" PRIu8 + ")\n", + len); + return 1; + } + + struct isis_auth *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + rv->type = stream_getc(s); + rv->length = len - 1; + + if (rv->type == ISIS_PASSWD_TYPE_HMAC_MD5 && rv->length != 16) { + sbuf_push( + log, indent, + "Unexpected auth length for HMAC-MD5 (expected 16, got %" PRIu8 + ")\n", + rv->length); + XFREE(MTYPE_ISIS_TLV2, rv); + return 1; + } + + rv->offset = stream_get_getp(s); + stream_get(rv->value, s, rv->length); + format_item_auth(mtid, (struct isis_item *)rv, log, indent + 2); + append_item(&tlvs->isis_auth, (struct isis_item *)rv); + return 0; +} + +/* Functions relating to item TLVs */ + +static void init_item_list(struct isis_item_list *items) +{ + items->head = NULL; + items->tail = &items->head; + items->count = 0; +} + +static struct isis_item *copy_item(enum isis_tlv_context context, + enum isis_tlv_type type, + struct isis_item *item) +{ + const struct tlv_ops *ops = tlv_table[context][type]; + + if (ops && ops->copy_item) + return ops->copy_item(item); + + assert(!"Unknown item tlv type!"); + return NULL; +} + +static void copy_items(enum isis_tlv_context context, enum isis_tlv_type type, + struct isis_item_list *src, struct isis_item_list *dest) +{ + struct isis_item *item; + + init_item_list(dest); + + for (item = src->head; item; item = item->next) { + append_item(dest, copy_item(context, type, item)); + } +} + +static void format_item(uint16_t mtid, enum isis_tlv_context context, + enum isis_tlv_type type, struct isis_item *i, + struct sbuf *buf, int indent) +{ + const struct tlv_ops *ops = tlv_table[context][type]; + + if (ops && ops->format_item) { + ops->format_item(mtid, i, buf, indent); + return; + } + + assert(!"Unknown item tlv type!"); +} + +static void format_items_(uint16_t mtid, enum isis_tlv_context context, + enum isis_tlv_type type, struct isis_item_list *items, + struct sbuf *buf, int indent) +{ + struct isis_item *i; + + for (i = items->head; i; i = i->next) + format_item(mtid, context, type, i, buf, indent); +} +#define format_items(...) format_items_(ISIS_MT_IPV4_UNICAST, __VA_ARGS__) + +static void free_item(enum isis_tlv_context tlv_context, + enum isis_tlv_type tlv_type, struct isis_item *item) +{ + const struct tlv_ops *ops = tlv_table[tlv_context][tlv_type]; + + if (ops && ops->free_item) { + ops->free_item(item); + return; + } + + assert(!"Unknown item tlv type!"); +} + +static void free_items(enum isis_tlv_context context, enum isis_tlv_type type, + struct isis_item_list *items) +{ + struct isis_item *item, *next_item; + + for (item = items->head; item; item = next_item) { + next_item = item->next; + free_item(context, type, item); + } +} + +static int pack_item(enum isis_tlv_context context, enum isis_tlv_type type, + struct isis_item *i, struct stream *s, + struct isis_tlvs **fragment_tlvs, + struct pack_order_entry *pe, uint16_t mtid) +{ + const struct tlv_ops *ops = tlv_table[context][type]; + + if (ops && ops->pack_item) { + return ops->pack_item(i, s); + } + + assert(!"Unknown item tlv type!"); + return 1; +} + +static void add_item_to_fragment(struct isis_item *i, struct pack_order_entry *pe, + struct isis_tlvs *fragment_tlvs, uint16_t mtid) +{ + struct isis_item_list *l; + + if (pe->how_to_pack == ISIS_ITEMS) { + l = (struct isis_item_list *)(((char *)fragment_tlvs) + pe->what_to_pack); + } else { + struct isis_mt_item_list *m; + m = (struct isis_mt_item_list *)(((char *)fragment_tlvs) + pe->what_to_pack); + l = isis_get_mt_items(m, mtid); + } + + append_item(l, copy_item(pe->context, pe->type, i)); +} + +static int pack_items_(uint16_t mtid, enum isis_tlv_context context, + enum isis_tlv_type type, struct isis_item_list *items, + struct stream *s, struct isis_tlvs **fragment_tlvs, + struct pack_order_entry *pe, + struct isis_tlvs *(*new_fragment)(struct list *l), + struct list *new_fragment_arg) +{ + size_t len_pos, last_len, len; + struct isis_item *item = NULL; + int rv; + + if (!items->head) + return 0; + +top: + if (STREAM_WRITEABLE(s) < 2) + goto too_long; + + stream_putc(s, type); + len_pos = stream_get_endp(s); + stream_putc(s, 0); /* Put 0 as length for now */ + + if (context == ISIS_CONTEXT_LSP && IS_COMPAT_MT_TLV(type) + && mtid != ISIS_MT_IPV4_UNICAST) { + if (STREAM_WRITEABLE(s) < 2) + goto too_long; + stream_putw(s, mtid); + } + + if (context == ISIS_CONTEXT_LSP && type == ISIS_TLV_OLDSTYLE_REACH) { + if (STREAM_WRITEABLE(s) < 1) + goto too_long; + stream_putc(s, 0); /* Virtual flag is set to 0 */ + } + + last_len = len = 0; + for (item = item ? item : items->head; item; item = item->next) { + rv = pack_item(context, type, item, s, fragment_tlvs, pe, mtid); + if (rv) + goto too_long; + + len = stream_get_endp(s) - len_pos - 1; + + /* Multiple auths don't go into one TLV, so always break */ + if (context == ISIS_CONTEXT_LSP && type == ISIS_TLV_AUTH) { + item = item->next; + break; + } + + if (len > 255) { + if (!last_len) /* strange, not a single item fit */ + return 1; + /* drop last tlv, otherwise, its too long */ + stream_set_endp(s, len_pos + 1 + last_len); + len = last_len; + break; + } + + if (fragment_tlvs) + add_item_to_fragment(item, pe, *fragment_tlvs, mtid); + + last_len = len; + } + + stream_putc_at(s, len_pos, len); + if (item) + goto top; + + return 0; +too_long: + if (!fragment_tlvs) + return 1; + stream_reset(s); + *fragment_tlvs = new_fragment(new_fragment_arg); + goto top; +} +#define pack_items(...) pack_items_(ISIS_MT_IPV4_UNICAST, __VA_ARGS__) + +static void append_item(struct isis_item_list *dest, struct isis_item *item) +{ + *dest->tail = item; + dest->tail = &(*dest->tail)->next; + dest->count++; +} + +static int unpack_item(uint16_t mtid, enum isis_tlv_context context, + uint8_t tlv_type, uint8_t len, struct stream *s, + struct sbuf *log, void *dest, int indent) +{ + const struct tlv_ops *ops = tlv_table[context][tlv_type]; + + if (ops && ops->unpack_item) + return ops->unpack_item(mtid, len, s, log, dest, indent); + + assert(!"Unknown item tlv type!"); + sbuf_push(log, indent, "Unknown item tlv type!\n"); + return 1; +} + +static int unpack_tlv_with_items(enum isis_tlv_context context, + uint8_t tlv_type, uint8_t tlv_len, + struct stream *s, struct sbuf *log, void *dest, + int indent) +{ + size_t tlv_start; + size_t tlv_pos; + int rv; + uint16_t mtid; + + tlv_start = stream_get_getp(s); + tlv_pos = 0; + + if (context == ISIS_CONTEXT_LSP && IS_COMPAT_MT_TLV(tlv_type)) { + if (tlv_len < 2) { + sbuf_push(log, indent, + "TLV is too short to contain MTID\n"); + return 1; + } + mtid = stream_getw(s) & ISIS_MT_MASK; + tlv_pos += 2; + sbuf_push(log, indent, "Unpacking as MT %s item TLV...\n", + isis_mtid2str(mtid)); + } else { + sbuf_push(log, indent, "Unpacking as item TLV...\n"); + mtid = ISIS_MT_IPV4_UNICAST; + } + + if (context == ISIS_CONTEXT_LSP + && tlv_type == ISIS_TLV_OLDSTYLE_REACH) { + if (tlv_len - tlv_pos < 1) { + sbuf_push(log, indent, + "TLV is too short for old style reach\n"); + return 1; + } + stream_forward_getp(s, 1); + tlv_pos += 1; + } + + if (context == ISIS_CONTEXT_LSP + && tlv_type == ISIS_TLV_OLDSTYLE_IP_REACH) { + struct isis_tlvs *tlvs = dest; + dest = &tlvs->oldstyle_ip_reach; + } else if (context == ISIS_CONTEXT_LSP + && tlv_type == ISIS_TLV_OLDSTYLE_IP_REACH_EXT) { + struct isis_tlvs *tlvs = dest; + dest = &tlvs->oldstyle_ip_reach_ext; + } + + if (context == ISIS_CONTEXT_LSP + && tlv_type == ISIS_TLV_MT_ROUTER_INFO) { + struct isis_tlvs *tlvs = dest; + tlvs->mt_router_info_empty = (tlv_pos >= (size_t)tlv_len); + } + + while (tlv_pos < (size_t)tlv_len) { + rv = unpack_item(mtid, context, tlv_type, tlv_len - tlv_pos, s, + log, dest, indent + 2); + if (rv) + return rv; + + tlv_pos = stream_get_getp(s) - tlv_start; + } + + return 0; +} + +/* Functions to manipulate mt_item_lists */ + +static int isis_mt_item_list_cmp(const struct isis_item_list *a, + const struct isis_item_list *b) +{ + if (a->mtid < b->mtid) + return -1; + if (a->mtid > b->mtid) + return 1; + return 0; +} + +RB_PROTOTYPE(isis_mt_item_list, isis_item_list, mt_tree, isis_mt_item_list_cmp); +RB_GENERATE(isis_mt_item_list, isis_item_list, mt_tree, isis_mt_item_list_cmp); + +struct isis_item_list *isis_get_mt_items(struct isis_mt_item_list *m, + uint16_t mtid) +{ + struct isis_item_list *rv; + + rv = isis_lookup_mt_items(m, mtid); + if (!rv) { + rv = XCALLOC(MTYPE_ISIS_MT_ITEM_LIST, sizeof(*rv)); + init_item_list(rv); + rv->mtid = mtid; + RB_INSERT(isis_mt_item_list, m, rv); + } + + return rv; +} + +struct isis_item_list *isis_lookup_mt_items(struct isis_mt_item_list *m, + uint16_t mtid) +{ + struct isis_item_list key = {.mtid = mtid}; + + return RB_FIND(isis_mt_item_list, m, &key); +} + +static void free_mt_items(enum isis_tlv_context context, + enum isis_tlv_type type, struct isis_mt_item_list *m) +{ + struct isis_item_list *n, *nnext; + + RB_FOREACH_SAFE(n, isis_mt_item_list, m, nnext) + { + free_items(context, type, n); + RB_REMOVE(isis_mt_item_list, m, n); + XFREE(MTYPE_ISIS_MT_ITEM_LIST, n); + } +} + +static void format_mt_items(enum isis_tlv_context context, + enum isis_tlv_type type, + struct isis_mt_item_list *m, struct sbuf *buf, + int indent) +{ + struct isis_item_list *n; + + RB_FOREACH(n, isis_mt_item_list, m) + { + format_items_(n->mtid, context, type, n, buf, indent); + } +} + +static int pack_mt_items(enum isis_tlv_context context, enum isis_tlv_type type, + struct isis_mt_item_list *m, struct stream *s, + struct isis_tlvs **fragment_tlvs, + struct pack_order_entry *pe, + struct isis_tlvs *(*new_fragment)(struct list *l), + struct list *new_fragment_arg) +{ + struct isis_item_list *n; + + RB_FOREACH(n, isis_mt_item_list, m) + { + int rv; + + rv = pack_items_(n->mtid, context, type, n, s, fragment_tlvs, + pe, new_fragment, new_fragment_arg); + if (rv) + return rv; + } + + return 0; +} + +static void copy_mt_items(enum isis_tlv_context context, + enum isis_tlv_type type, + struct isis_mt_item_list *src, + struct isis_mt_item_list *dest) +{ + struct isis_item_list *n; + + RB_INIT(isis_mt_item_list, dest); + + RB_FOREACH(n, isis_mt_item_list, src) + { + copy_items(context, type, n, isis_get_mt_items(dest, n->mtid)); + } +} + +/* Functions related to tlvs in general */ + +struct isis_tlvs *isis_alloc_tlvs(void) +{ + struct isis_tlvs *result; + + result = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*result)); + + init_item_list(&result->isis_auth); + init_item_list(&result->area_addresses); + init_item_list(&result->mt_router_info); + init_item_list(&result->oldstyle_reach); + init_item_list(&result->lan_neighbor); + init_item_list(&result->lsp_entries); + init_item_list(&result->extended_reach); + RB_INIT(isis_mt_item_list, &result->mt_reach); + init_item_list(&result->oldstyle_ip_reach); + init_item_list(&result->oldstyle_ip_reach_ext); + init_item_list(&result->ipv4_address); + init_item_list(&result->ipv6_address); + init_item_list(&result->extended_ip_reach); + RB_INIT(isis_mt_item_list, &result->mt_ip_reach); + init_item_list(&result->ipv6_reach); + RB_INIT(isis_mt_item_list, &result->mt_ipv6_reach); + + return result; +} + +struct isis_tlvs *isis_copy_tlvs(struct isis_tlvs *tlvs) +{ + struct isis_tlvs *rv = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*rv)); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH, &tlvs->isis_auth, + &rv->isis_auth); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_AREA_ADDRESSES, + &tlvs->area_addresses, &rv->area_addresses); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_ROUTER_INFO, + &tlvs->mt_router_info, &rv->mt_router_info); + + tlvs->mt_router_info_empty = rv->mt_router_info_empty; + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_REACH, + &tlvs->oldstyle_reach, &rv->oldstyle_reach); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_LAN_NEIGHBORS, + &tlvs->lan_neighbor, &rv->lan_neighbor); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_LSP_ENTRY, &tlvs->lsp_entries, + &rv->lsp_entries); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_EXTENDED_REACH, + &tlvs->extended_reach, &rv->extended_reach); + + copy_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_REACH, &tlvs->mt_reach, + &rv->mt_reach); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_IP_REACH, + &tlvs->oldstyle_ip_reach, &rv->oldstyle_ip_reach); + + copy_tlv_protocols_supported(&tlvs->protocols_supported, + &rv->protocols_supported); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_IP_REACH_EXT, + &tlvs->oldstyle_ip_reach_ext, &rv->oldstyle_ip_reach_ext); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV4_ADDRESS, &tlvs->ipv4_address, + &rv->ipv4_address); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV6_ADDRESS, &tlvs->ipv6_address, + &rv->ipv6_address); + + rv->te_router_id = copy_tlv_te_router_id(tlvs->te_router_id); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_EXTENDED_IP_REACH, + &tlvs->extended_ip_reach, &rv->extended_ip_reach); + + copy_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_IP_REACH, + &tlvs->mt_ip_reach, &rv->mt_ip_reach); + + rv->hostname = copy_tlv_dynamic_hostname(tlvs->hostname); + + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV6_REACH, &tlvs->ipv6_reach, + &rv->ipv6_reach); + + copy_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_IPV6_REACH, + &tlvs->mt_ipv6_reach, &rv->mt_ipv6_reach); + + return rv; +} + +static void format_tlvs(struct isis_tlvs *tlvs, struct sbuf *buf, int indent) +{ + format_tlv_protocols_supported(&tlvs->protocols_supported, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH, &tlvs->isis_auth, buf, + indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_AREA_ADDRESSES, + &tlvs->area_addresses, buf, indent); + + if (tlvs->mt_router_info_empty) { + sbuf_push(buf, indent, "MT Router Info: None\n"); + } else { + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_ROUTER_INFO, + &tlvs->mt_router_info, buf, indent); + } + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_REACH, + &tlvs->oldstyle_reach, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_LAN_NEIGHBORS, + &tlvs->lan_neighbor, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_LSP_ENTRY, &tlvs->lsp_entries, + buf, indent); + + format_tlv_dynamic_hostname(tlvs->hostname, buf, indent); + format_tlv_te_router_id(tlvs->te_router_id, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_EXTENDED_REACH, + &tlvs->extended_reach, buf, indent); + + format_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_REACH, &tlvs->mt_reach, + buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_IP_REACH, + &tlvs->oldstyle_ip_reach, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_IP_REACH_EXT, + &tlvs->oldstyle_ip_reach_ext, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV4_ADDRESS, + &tlvs->ipv4_address, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV6_ADDRESS, + &tlvs->ipv6_address, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_EXTENDED_IP_REACH, + &tlvs->extended_ip_reach, buf, indent); + + format_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_IP_REACH, + &tlvs->mt_ip_reach, buf, indent); + + format_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV6_REACH, &tlvs->ipv6_reach, + buf, indent); + + format_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_IPV6_REACH, + &tlvs->mt_ipv6_reach, buf, indent); +} + +const char *isis_format_tlvs(struct isis_tlvs *tlvs) +{ + static struct sbuf buf; + + if (!sbuf_buf(&buf)) + sbuf_init(&buf, NULL, 0); + + sbuf_reset(&buf); + format_tlvs(tlvs, &buf, 0); + return sbuf_buf(&buf); +} + +void isis_free_tlvs(struct isis_tlvs *tlvs) +{ + if (!tlvs) + return; + + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH, &tlvs->isis_auth); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_AREA_ADDRESSES, + &tlvs->area_addresses); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_ROUTER_INFO, + &tlvs->mt_router_info); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_REACH, + &tlvs->oldstyle_reach); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_LAN_NEIGHBORS, + &tlvs->lan_neighbor); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_LSP_ENTRY, &tlvs->lsp_entries); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_EXTENDED_REACH, + &tlvs->extended_reach); + free_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_REACH, &tlvs->mt_reach); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_IP_REACH, + &tlvs->oldstyle_ip_reach); + free_tlv_protocols_supported(&tlvs->protocols_supported); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_OLDSTYLE_IP_REACH_EXT, + &tlvs->oldstyle_ip_reach_ext); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV4_ADDRESS, + &tlvs->ipv4_address); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV6_ADDRESS, + &tlvs->ipv6_address); + free_tlv_te_router_id(tlvs->te_router_id); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_EXTENDED_IP_REACH, + &tlvs->extended_ip_reach); + free_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_IP_REACH, + &tlvs->mt_ip_reach); + free_tlv_dynamic_hostname(tlvs->hostname); + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_IPV6_REACH, &tlvs->ipv6_reach); + free_mt_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_IPV6_REACH, + &tlvs->mt_ipv6_reach); + + XFREE(MTYPE_ISIS_TLV2, tlvs); +} + +static void add_padding(struct stream *s) +{ + while (STREAM_WRITEABLE(s)) { + if (STREAM_WRITEABLE(s) == 1) + break; + uint32_t padding_len = STREAM_WRITEABLE(s) - 2; + + if (padding_len > 255) { + if (padding_len == 256) + padding_len = 254; + else + padding_len = 255; + } + + stream_putc(s, ISIS_TLV_PADDING); + stream_putc(s, padding_len); + stream_put(s, NULL, padding_len); + } +} + +#define LSP_REM_LIFETIME_OFF 10 +#define LSP_CHECKSUM_OFF 24 +static void safe_auth_md5(struct stream *s, uint16_t *checksum, + uint16_t *rem_lifetime) +{ + memcpy(rem_lifetime, STREAM_DATA(s) + LSP_REM_LIFETIME_OFF, + sizeof(*rem_lifetime)); + memset(STREAM_DATA(s) + LSP_REM_LIFETIME_OFF, 0, sizeof(*rem_lifetime)); + memcpy(checksum, STREAM_DATA(s) + LSP_CHECKSUM_OFF, sizeof(*checksum)); + memset(STREAM_DATA(s) + LSP_CHECKSUM_OFF, 0, sizeof(*checksum)); +} + +static void restore_auth_md5(struct stream *s, uint16_t checksum, + uint16_t rem_lifetime) +{ + memcpy(STREAM_DATA(s) + LSP_REM_LIFETIME_OFF, &rem_lifetime, + sizeof(rem_lifetime)); + memcpy(STREAM_DATA(s) + LSP_CHECKSUM_OFF, &checksum, sizeof(checksum)); +} + +static void update_auth_hmac_md5(struct isis_auth *auth, struct stream *s, + bool is_lsp) +{ + uint8_t digest[16]; + uint16_t checksum, rem_lifetime; + + if (is_lsp) + safe_auth_md5(s, &checksum, &rem_lifetime); + + memset(STREAM_DATA(s) + auth->offset, 0, 16); + hmac_md5(STREAM_DATA(s), stream_get_endp(s), auth->passwd, + auth->plength, digest); + memcpy(auth->value, digest, 16); + memcpy(STREAM_DATA(s) + auth->offset, digest, 16); + + if (is_lsp) + restore_auth_md5(s, checksum, rem_lifetime); +} + +static void update_auth(struct isis_tlvs *tlvs, struct stream *s, bool is_lsp) +{ + struct isis_auth *auth_head = (struct isis_auth *)tlvs->isis_auth.head; + + for (struct isis_auth *auth = auth_head; auth; auth = auth->next) { + if (auth->type == ISIS_PASSWD_TYPE_HMAC_MD5) + update_auth_hmac_md5(auth, s, is_lsp); + } +} + +static int handle_pack_entry(struct pack_order_entry *pe, + struct isis_tlvs *tlvs, struct stream *stream, + struct isis_tlvs **fragment_tlvs, + struct isis_tlvs *(*new_fragment)(struct list *l), + struct list *new_fragment_arg) +{ + int rv; + + if (pe->how_to_pack == ISIS_ITEMS) { + struct isis_item_list *l; + l = (struct isis_item_list *)(((char *)tlvs) + + pe->what_to_pack); + rv = pack_items(pe->context, pe->type, l, stream, fragment_tlvs, + pe, new_fragment, new_fragment_arg); + } else { + struct isis_mt_item_list *l; + l = (struct isis_mt_item_list *)(((char *)tlvs) + + pe->what_to_pack); + rv = pack_mt_items(pe->context, pe->type, l, stream, + fragment_tlvs, pe, new_fragment, + new_fragment_arg); + } + + return rv; +} + +static int pack_tlvs(struct isis_tlvs *tlvs, struct stream *stream, + struct isis_tlvs *fragment_tlvs, + struct isis_tlvs *(*new_fragment)(struct list *l), + struct list *new_fragment_arg) +{ + int rv; + + /* When fragmenting, don't add auth as it's already accounted for in the + * size we are given. */ + if (!fragment_tlvs) { + rv = pack_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH, &tlvs->isis_auth, + stream, NULL, NULL, NULL, NULL); + if (rv) + return rv; + } + + rv = pack_tlv_protocols_supported(&tlvs->protocols_supported, stream); + if (rv) + return rv; + if (fragment_tlvs) { + copy_tlv_protocols_supported( + &tlvs->protocols_supported, + &fragment_tlvs->protocols_supported); + } + + rv = pack_items(ISIS_CONTEXT_LSP, ISIS_TLV_AREA_ADDRESSES, + &tlvs->area_addresses, stream, NULL, NULL, NULL, NULL); + if (rv) + return rv; + if (fragment_tlvs) { + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_AREA_ADDRESSES, + &tlvs->area_addresses, + &fragment_tlvs->area_addresses); + } + + + if (tlvs->mt_router_info_empty) { + if (STREAM_WRITEABLE(stream) < 2) + return 1; + stream_putc(stream, ISIS_TLV_MT_ROUTER_INFO); + stream_putc(stream, 0); + if (fragment_tlvs) + fragment_tlvs->mt_router_info_empty = true; + } else { + rv = pack_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_ROUTER_INFO, + &tlvs->mt_router_info, stream, NULL, NULL, NULL, + NULL); + if (rv) + return rv; + if (fragment_tlvs) { + copy_items(ISIS_CONTEXT_LSP, ISIS_TLV_MT_ROUTER_INFO, + &tlvs->mt_router_info, + &fragment_tlvs->mt_router_info); + } + } + + rv = pack_tlv_dynamic_hostname(tlvs->hostname, stream); + if (rv) + return rv; + if (fragment_tlvs) + fragment_tlvs->hostname = + copy_tlv_dynamic_hostname(tlvs->hostname); + + rv = pack_tlv_te_router_id(tlvs->te_router_id, stream); + if (rv) + return rv; + if (fragment_tlvs) { + fragment_tlvs->te_router_id = + copy_tlv_te_router_id(tlvs->te_router_id); + } + + for (size_t pack_idx = 0; pack_idx < array_size(pack_order); + pack_idx++) { + rv = handle_pack_entry(&pack_order[pack_idx], tlvs, stream, + fragment_tlvs ? &fragment_tlvs : NULL, + new_fragment, new_fragment_arg); + + if (rv) + return rv; + } + + return 0; +} + +int isis_pack_tlvs(struct isis_tlvs *tlvs, struct stream *stream, + size_t len_pointer, bool pad, bool is_lsp) +{ + int rv; + + rv = pack_tlvs(tlvs, stream, NULL, NULL, NULL); + if (rv) + return rv; + + if (pad) + add_padding(stream); + + if (len_pointer != (size_t)-1) { + stream_putw_at(stream, len_pointer, stream_get_endp(stream)); + } + + update_auth(tlvs, stream, is_lsp); + + return 0; +} + +static struct isis_tlvs *new_fragment(struct list *l) +{ + struct isis_tlvs *rv = isis_alloc_tlvs(); + + listnode_add(l, rv); + return rv; +} + +struct list *isis_fragment_tlvs(struct isis_tlvs *tlvs, size_t size) +{ + struct stream *dummy_stream = stream_new(size); + struct list *rv = list_new(); + struct isis_tlvs *fragment_tlvs = new_fragment(rv); + + if (pack_tlvs(tlvs, dummy_stream, fragment_tlvs, new_fragment, rv)) { + struct listnode *node; + for (ALL_LIST_ELEMENTS_RO(rv, node, fragment_tlvs)) + isis_free_tlvs(fragment_tlvs); + list_delete(rv); + rv = NULL; + } + + stream_free(dummy_stream); + return rv; +} + +static int unpack_tlv_unknown(enum isis_tlv_context context, uint8_t tlv_type, + uint8_t tlv_len, struct stream *s, + struct sbuf *log, int indent) +{ + stream_forward_getp(s, tlv_len); + sbuf_push(log, indent, + "Skipping unknown TLV %" PRIu8 " (%" PRIu8 " bytes)\n", + tlv_type, tlv_len); + return 0; +} + +static int unpack_tlv(enum isis_tlv_context context, size_t avail_len, + struct stream *stream, struct sbuf *log, void *dest, + int indent) +{ + uint8_t tlv_type, tlv_len; + const struct tlv_ops *ops; + + sbuf_push(log, indent, "Unpacking TLV...\n"); + + if (avail_len < 2) { + sbuf_push( + log, indent + 2, + "Available data %zu too short to contain a TLV header.\n", + avail_len); + return 1; + } + + tlv_type = stream_getc(stream); + tlv_len = stream_getc(stream); + + sbuf_push(log, indent + 2, + "Found TLV of type %" PRIu8 " and len %" PRIu8 ".\n", + tlv_type, tlv_len); + + if (avail_len < ((size_t)tlv_len) + 2) { + sbuf_push(log, indent + 2, + "Available data %zu too short for claimed TLV len %" PRIu8 ".\n", + avail_len - 2, tlv_len); + return 1; + } + + ops = tlv_table[context][tlv_type]; + if (ops && ops->unpack) { + return ops->unpack(context, tlv_type, tlv_len, stream, log, + dest, indent + 2); + } + + return unpack_tlv_unknown(context, tlv_type, tlv_len, stream, log, + indent + 2); +} + +static int unpack_tlvs(enum isis_tlv_context context, size_t avail_len, + struct stream *stream, struct sbuf *log, void *dest, + int indent) +{ + int rv; + size_t tlv_start, tlv_pos; + + tlv_start = stream_get_getp(stream); + tlv_pos = 0; + + sbuf_push(log, indent, "Unpacking %zu bytes of %s...\n", avail_len, + (context == ISIS_CONTEXT_LSP) ? "TLVs" : "sub-TLVs"); + + while (tlv_pos < avail_len) { + rv = unpack_tlv(context, avail_len - tlv_pos, stream, log, dest, + indent + 2); + if (rv) + return rv; + + tlv_pos = stream_get_getp(stream) - tlv_start; + } + + return 0; +} + +int isis_unpack_tlvs(size_t avail_len, struct stream *stream, + struct isis_tlvs **dest, const char **log) +{ + static struct sbuf logbuf; + int indent = 0; + int rv; + struct isis_tlvs *result; + + if (!sbuf_buf(&logbuf)) + sbuf_init(&logbuf, NULL, 0); + + sbuf_reset(&logbuf); + if (avail_len > STREAM_READABLE(stream)) { + sbuf_push(&logbuf, indent, + "Stream doesn't contain sufficient data. " + "Claimed %zu, available %zu\n", + avail_len, STREAM_READABLE(stream)); + return 1; + } + + result = isis_alloc_tlvs(); + rv = unpack_tlvs(ISIS_CONTEXT_LSP, avail_len, stream, &logbuf, result, + indent); + + *log = sbuf_buf(&logbuf); + *dest = result; + + return rv; +} + +#define TLV_OPS(_name_, _desc_) \ + static const struct tlv_ops tlv_##_name_##_ops = { \ + .name = _desc_, .unpack = unpack_tlv_##_name_, \ + } + +#define ITEM_TLV_OPS(_name_, _desc_) \ + static const struct tlv_ops tlv_##_name_##_ops = { \ + .name = _desc_, \ + .unpack = unpack_tlv_with_items, \ + \ + .pack_item = pack_item_##_name_, \ + .free_item = free_item_##_name_, \ + .unpack_item = unpack_item_##_name_, \ + .format_item = format_item_##_name_, \ + .copy_item = copy_item_##_name_} + +#define SUBTLV_OPS(_name_, _desc_) \ + static const struct tlv_ops subtlv_##_name_##_ops = { \ + .name = _desc_, .unpack = unpack_subtlv_##_name_, \ + } + +ITEM_TLV_OPS(area_address, "TLV 1 Area Addresses"); +ITEM_TLV_OPS(oldstyle_reach, "TLV 2 IS Reachability"); +ITEM_TLV_OPS(lan_neighbor, "TLV 6 LAN Neighbors"); +ITEM_TLV_OPS(lsp_entry, "TLV 9 LSP Entries"); +ITEM_TLV_OPS(auth, "TLV 10 IS-IS Auth"); +ITEM_TLV_OPS(extended_reach, "TLV 22 Extended Reachability"); +ITEM_TLV_OPS(oldstyle_ip_reach, "TLV 128/130 IP Reachability"); +TLV_OPS(protocols_supported, "TLV 129 Protocols Supported"); +ITEM_TLV_OPS(ipv4_address, "TLV 132 IPv4 Interface Address"); +TLV_OPS(te_router_id, "TLV 134 TE Router ID"); +ITEM_TLV_OPS(extended_ip_reach, "TLV 135 Extended IP Reachability"); +TLV_OPS(dynamic_hostname, "TLV 137 Dynamic Hostname"); +ITEM_TLV_OPS(mt_router_info, "TLV 229 MT Router Information"); +ITEM_TLV_OPS(ipv6_address, "TLV 232 IPv6 Interface Address"); +ITEM_TLV_OPS(ipv6_reach, "TLV 236 IPv6 Reachability"); + +SUBTLV_OPS(ipv6_source_prefix, "Sub-TLV 22 IPv6 Source Prefix"); + +static const struct tlv_ops *tlv_table[ISIS_CONTEXT_MAX][ISIS_TLV_MAX] = { + [ISIS_CONTEXT_LSP] = { + [ISIS_TLV_AREA_ADDRESSES] = &tlv_area_address_ops, + [ISIS_TLV_OLDSTYLE_REACH] = &tlv_oldstyle_reach_ops, + [ISIS_TLV_LAN_NEIGHBORS] = &tlv_lan_neighbor_ops, + [ISIS_TLV_LSP_ENTRY] = &tlv_lsp_entry_ops, + [ISIS_TLV_AUTH] = &tlv_auth_ops, + [ISIS_TLV_EXTENDED_REACH] = &tlv_extended_reach_ops, + [ISIS_TLV_MT_REACH] = &tlv_extended_reach_ops, + [ISIS_TLV_OLDSTYLE_IP_REACH] = &tlv_oldstyle_ip_reach_ops, + [ISIS_TLV_PROTOCOLS_SUPPORTED] = &tlv_protocols_supported_ops, + [ISIS_TLV_OLDSTYLE_IP_REACH_EXT] = &tlv_oldstyle_ip_reach_ops, + [ISIS_TLV_IPV4_ADDRESS] = &tlv_ipv4_address_ops, + [ISIS_TLV_TE_ROUTER_ID] = &tlv_te_router_id_ops, + [ISIS_TLV_EXTENDED_IP_REACH] = &tlv_extended_ip_reach_ops, + [ISIS_TLV_MT_IP_REACH] = &tlv_extended_ip_reach_ops, + [ISIS_TLV_DYNAMIC_HOSTNAME] = &tlv_dynamic_hostname_ops, + [ISIS_TLV_MT_ROUTER_INFO] = &tlv_mt_router_info_ops, + [ISIS_TLV_IPV6_ADDRESS] = &tlv_ipv6_address_ops, + [ISIS_TLV_IPV6_REACH] = &tlv_ipv6_reach_ops, + [ISIS_TLV_MT_IPV6_REACH] = &tlv_ipv6_reach_ops, + }, + [ISIS_CONTEXT_SUBTLV_NE_REACH] = {}, + [ISIS_CONTEXT_SUBTLV_IP_REACH] = {}, + [ISIS_CONTEXT_SUBTLV_IPV6_REACH] = { + [ISIS_SUBTLV_IPV6_SOURCE_PREFIX] = &subtlv_ipv6_source_prefix_ops, + } +}; + +/* Accessor functions */ + +void isis_tlvs_add_auth(struct isis_tlvs *tlvs, struct isis_passwd *passwd) +{ + free_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH, &tlvs->isis_auth); + init_item_list(&tlvs->isis_auth); + + if (passwd->type == ISIS_PASSWD_TYPE_UNUSED) + return; + + struct isis_auth *auth = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*auth)); + + auth->type = passwd->type; + + auth->plength = passwd->len; + memcpy(auth->passwd, passwd->passwd, + MIN(sizeof(auth->passwd), sizeof(passwd->passwd))); + + if (auth->type == ISIS_PASSWD_TYPE_CLEARTXT) { + auth->length = passwd->len; + memcpy(auth->value, passwd->passwd, + MIN(sizeof(auth->value), sizeof(passwd->passwd))); + } + + append_item(&tlvs->isis_auth, (struct isis_item *)auth); +} + +void isis_tlvs_add_area_addresses(struct isis_tlvs *tlvs, + struct list *addresses) +{ + struct listnode *node; + struct area_addr *area_addr; + + for (ALL_LIST_ELEMENTS_RO(addresses, node, area_addr)) { + struct isis_area_address *a = + XCALLOC(MTYPE_ISIS_TLV2, sizeof(*a)); + + a->len = area_addr->addr_len; + memcpy(a->addr, area_addr->area_addr, 20); + append_item(&tlvs->area_addresses, (struct isis_item *)a); + } +} + +void isis_tlvs_add_lan_neighbors(struct isis_tlvs *tlvs, struct list *neighbors) +{ + struct listnode *node; + u_char *snpa; + + for (ALL_LIST_ELEMENTS_RO(neighbors, node, snpa)) { + struct isis_lan_neighbor *n = + XCALLOC(MTYPE_ISIS_TLV2, sizeof(*n)); + + memcpy(n->mac, snpa, 6); + append_item(&tlvs->lan_neighbor, (struct isis_item *)n); + } +} + +void isis_tlvs_set_protocols_supported(struct isis_tlvs *tlvs, + struct nlpids *nlpids) +{ + tlvs->protocols_supported.count = nlpids->count; + if (tlvs->protocols_supported.protocols) + XFREE(MTYPE_ISIS_TLV2, tlvs->protocols_supported.protocols); + if (nlpids->count) { + tlvs->protocols_supported.protocols = + XCALLOC(MTYPE_ISIS_TLV2, nlpids->count); + memcpy(tlvs->protocols_supported.protocols, nlpids->nlpids, + nlpids->count); + } else { + tlvs->protocols_supported.protocols = NULL; + } +} + +void isis_tlvs_add_mt_router_info(struct isis_tlvs *tlvs, uint16_t mtid, + bool overload, bool attached) +{ + struct isis_mt_router_info *i = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*i)); + + i->overload = overload; + i->attached = attached; + i->mtid = mtid; + append_item(&tlvs->mt_router_info, (struct isis_item *)i); +} + +void isis_tlvs_add_ipv4_address(struct isis_tlvs *tlvs, struct in_addr *addr) +{ + struct isis_ipv4_address *a = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*a)); + a->addr = *addr; + append_item(&tlvs->ipv4_address, (struct isis_item *)a); +} + + +void isis_tlvs_add_ipv4_addresses(struct isis_tlvs *tlvs, + struct list *addresses) +{ + struct listnode *node; + struct prefix_ipv4 *ip_addr; + + for (ALL_LIST_ELEMENTS_RO(addresses, node, ip_addr)) + isis_tlvs_add_ipv4_address(tlvs, &ip_addr->prefix); +} + +void isis_tlvs_add_ipv6_addresses(struct isis_tlvs *tlvs, + struct list *addresses) +{ + struct listnode *node; + struct prefix_ipv6 *ip_addr; + + for (ALL_LIST_ELEMENTS_RO(addresses, node, ip_addr)) { + struct isis_ipv6_address *a = + XCALLOC(MTYPE_ISIS_TLV2, sizeof(*a)); + + a->addr = ip_addr->prefix; + append_item(&tlvs->ipv6_address, (struct isis_item *)a); + } +} + +typedef bool (*auth_validator_func)(struct isis_passwd *passwd, + struct stream *stream, + struct isis_auth *auth, bool is_lsp); + +static bool auth_validator_cleartxt(struct isis_passwd *passwd, + struct stream *stream, + struct isis_auth *auth, bool is_lsp) +{ + return (auth->length == passwd->len + && !memcmp(auth->value, passwd->passwd, passwd->len)); +} + +static bool auth_validator_hmac_md5(struct isis_passwd *passwd, + struct stream *stream, + struct isis_auth *auth, bool is_lsp) +{ + uint8_t digest[16]; + uint16_t checksum; + uint16_t rem_lifetime; + + if (is_lsp) + safe_auth_md5(stream, &checksum, &rem_lifetime); + + memset(STREAM_DATA(stream) + auth->offset, 0, 16); + hmac_md5(STREAM_DATA(stream), stream_get_endp(stream), passwd->passwd, + passwd->len, digest); + memcpy(STREAM_DATA(stream) + auth->offset, auth->value, 16); + + bool rv = !memcmp(digest, auth->value, 16); + + if (is_lsp) + restore_auth_md5(stream, checksum, rem_lifetime); + + return rv; +} + +static const auth_validator_func auth_validators[] = { + [ISIS_PASSWD_TYPE_CLEARTXT] = auth_validator_cleartxt, + [ISIS_PASSWD_TYPE_HMAC_MD5] = auth_validator_hmac_md5, +}; + +bool isis_tlvs_auth_is_valid(struct isis_tlvs *tlvs, struct isis_passwd *passwd, + struct stream *stream, bool is_lsp) +{ + /* If no auth is set, always pass authentication */ + if (!passwd->type) + return true; + + /* If we don't known how to validate the auth, return invalid */ + if (passwd->type >= array_size(auth_validators) + || !auth_validators[passwd->type]) + return false; + + struct isis_auth *auth_head = (struct isis_auth *)tlvs->isis_auth.head; + struct isis_auth *auth; + for (auth = auth_head; auth; auth = auth->next) { + if (auth->type == passwd->type) + break; + } + + /* If matching auth TLV could not be found, return invalid */ + if (!auth) + return false; + + /* Perform validation and return result */ + return auth_validators[passwd->type](passwd, stream, auth, is_lsp); +} + +bool isis_tlvs_area_addresses_match(struct isis_tlvs *tlvs, + struct list *addresses) +{ + struct isis_area_address *addr_head; + + addr_head = (struct isis_area_address *)tlvs->area_addresses.head; + for (struct isis_area_address *addr = addr_head; addr; + addr = addr->next) { + struct listnode *node; + struct area_addr *a; + + for (ALL_LIST_ELEMENTS_RO(addresses, node, a)) { + if (a->addr_len == addr->len + && !memcmp(a->area_addr, addr->addr, addr->len)) + return true; + } + } + + return false; +} + +static void tlvs_area_addresses_to_adj(struct isis_tlvs *tlvs, + struct isis_adjacency *adj, + bool *changed) +{ + if (adj->area_address_count != tlvs->area_addresses.count) { + *changed = true; + adj->area_address_count = tlvs->area_addresses.count; + adj->area_addresses = XREALLOC( + MTYPE_ISIS_ADJACENCY_INFO, adj->area_addresses, + adj->area_address_count * sizeof(*adj->area_addresses)); + } + + struct isis_area_address *addr = NULL; + for (unsigned int i = 0; i < tlvs->area_addresses.count; i++) { + if (!addr) + addr = (struct isis_area_address *) + tlvs->area_addresses.head; + else + addr = addr->next; + + if (adj->area_addresses[i].addr_len == addr->len + && !memcmp(adj->area_addresses[i].area_addr, addr->addr, + addr->len)) { + continue; + } + + *changed = true; + adj->area_addresses[i].addr_len = addr->len; + memcpy(adj->area_addresses[i].area_addr, addr->addr, addr->len); + } +} + +static void tlvs_protocols_supported_to_adj(struct isis_tlvs *tlvs, + struct isis_adjacency *adj, + bool *changed) +{ + bool ipv4_supported = false, ipv6_supported = false; + + for (uint8_t i = 0; i < tlvs->protocols_supported.count; i++) { + if (tlvs->protocols_supported.protocols[i] == NLPID_IP) + ipv4_supported = true; + if (tlvs->protocols_supported.protocols[i] == NLPID_IPV6) + ipv6_supported = true; + } + + struct nlpids reduced = {}; + + if (ipv4_supported && ipv6_supported) { + reduced.count = 2; + reduced.nlpids[0] = NLPID_IP; + reduced.nlpids[1] = NLPID_IPV6; + } else if (ipv4_supported) { + reduced.count = 1; + reduced.nlpids[0] = NLPID_IP; + } else if (ipv6_supported) { + reduced.count = 1; + reduced.nlpids[1] = NLPID_IPV6; + } else { + reduced.count = 0; + } + + if (adj->nlpids.count == reduced.count + && !memcmp(adj->nlpids.nlpids, reduced.nlpids, reduced.count)) + return; + + *changed = true; + adj->nlpids.count = reduced.count; + memcpy(adj->nlpids.nlpids, reduced.nlpids, reduced.count); +} + +static void tlvs_ipv4_addresses_to_adj(struct isis_tlvs *tlvs, + struct isis_adjacency *adj, + bool *changed) +{ + if (adj->ipv4_address_count != tlvs->ipv4_address.count) { + *changed = true; + adj->ipv4_address_count = tlvs->ipv4_address.count; + adj->ipv4_addresses = XREALLOC( + MTYPE_ISIS_ADJACENCY_INFO, adj->ipv4_addresses, + adj->ipv4_address_count * sizeof(*adj->ipv4_addresses)); + } + + struct isis_ipv4_address *addr = NULL; + for (unsigned int i = 0; i < tlvs->ipv4_address.count; i++) { + if (!addr) + addr = (struct isis_ipv4_address *) + tlvs->ipv4_address.head; + else + addr = addr->next; + + if (!memcmp(&adj->ipv4_addresses[i], &addr->addr, + sizeof(addr->addr))) + continue; + + *changed = true; + adj->ipv4_addresses[i] = addr->addr; + } +} + +static void tlvs_ipv6_addresses_to_adj(struct isis_tlvs *tlvs, + struct isis_adjacency *adj, + bool *changed) +{ + if (adj->ipv6_address_count != tlvs->ipv6_address.count) { + *changed = true; + adj->ipv6_address_count = tlvs->ipv6_address.count; + adj->ipv6_addresses = XREALLOC( + MTYPE_ISIS_ADJACENCY_INFO, adj->ipv6_addresses, + adj->ipv6_address_count * sizeof(*adj->ipv6_addresses)); + } + + struct isis_ipv6_address *addr = NULL; + for (unsigned int i = 0; i < tlvs->ipv6_address.count; i++) { + if (!addr) + addr = (struct isis_ipv6_address *) + tlvs->ipv6_address.head; + else + addr = addr->next; + + if (!memcmp(&adj->ipv6_addresses[i], &addr->addr, + sizeof(addr->addr))) + continue; + + *changed = true; + adj->ipv6_addresses[i] = addr->addr; + } +} + +void isis_tlvs_to_adj(struct isis_tlvs *tlvs, struct isis_adjacency *adj, + bool *changed) +{ + *changed = false; + + tlvs_area_addresses_to_adj(tlvs, adj, changed); + tlvs_protocols_supported_to_adj(tlvs, adj, changed); + tlvs_ipv4_addresses_to_adj(tlvs, adj, changed); + tlvs_ipv6_addresses_to_adj(tlvs, adj, changed); +} + +bool isis_tlvs_own_snpa_found(struct isis_tlvs *tlvs, uint8_t *snpa) +{ + struct isis_lan_neighbor *ne_head; + + ne_head = (struct isis_lan_neighbor *)tlvs->lan_neighbor.head; + for (struct isis_lan_neighbor *ne = ne_head; ne; ne = ne->next) { + if (!memcmp(ne->mac, snpa, ETH_ALEN)) + return true; + } + + return false; +} + +void isis_tlvs_add_lsp_entry(struct isis_tlvs *tlvs, struct isis_lsp *lsp) +{ + struct isis_lsp_entry *entry = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*entry)); + + entry->rem_lifetime = lsp->hdr.rem_lifetime; + memcpy(entry->id, lsp->hdr.lsp_id, ISIS_SYS_ID_LEN + 2); + entry->checksum = lsp->hdr.checksum; + entry->seqno = lsp->hdr.seqno; + entry->lsp = lsp; + + append_item(&tlvs->lsp_entries, (struct isis_item *)entry); +} + +void isis_tlvs_add_csnp_entries(struct isis_tlvs *tlvs, uint8_t *start_id, + uint8_t *stop_id, uint16_t num_lsps, + dict_t *lspdb, struct isis_lsp **last_lsp) +{ + dnode_t *first = dict_lower_bound(lspdb, start_id); + if (!first) + return; + + dnode_t *last = dict_upper_bound(lspdb, stop_id); + dnode_t *curr = first; + + isis_tlvs_add_lsp_entry(tlvs, first->dict_data); + *last_lsp = first->dict_data; + + while (curr) { + curr = dict_next(lspdb, curr); + if (curr) { + isis_tlvs_add_lsp_entry(tlvs, curr->dict_data); + *last_lsp = curr->dict_data; + } + if (curr == last || tlvs->lsp_entries.count == num_lsps) + break; + } +} + +void isis_tlvs_set_dynamic_hostname(struct isis_tlvs *tlvs, + const char *hostname) +{ + XFREE(MTYPE_ISIS_TLV2, tlvs->hostname); + if (hostname) + tlvs->hostname = XSTRDUP(MTYPE_ISIS_TLV2, hostname); +} + +void isis_tlvs_set_te_router_id(struct isis_tlvs *tlvs, + const struct in_addr *id) +{ + XFREE(MTYPE_ISIS_TLV2, tlvs->te_router_id); + if (!id) + return; + tlvs->te_router_id = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*id)); + memcpy(tlvs->te_router_id, id, sizeof(*id)); +} + +void isis_tlvs_add_oldstyle_ip_reach(struct isis_tlvs *tlvs, + struct prefix_ipv4 *dest, uint8_t metric) +{ + struct isis_oldstyle_ip_reach *r = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*r)); + + r->metric = metric; + memcpy(&r->prefix, dest, sizeof(*dest)); + apply_mask_ipv4(&r->prefix); + append_item(&tlvs->oldstyle_ip_reach, (struct isis_item *)r); +} + +void isis_tlvs_add_extended_ip_reach(struct isis_tlvs *tlvs, + struct prefix_ipv4 *dest, uint32_t metric) +{ + struct isis_extended_ip_reach *r = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*r)); + + r->metric = metric; + memcpy(&r->prefix, dest, sizeof(*dest)); + apply_mask_ipv4(&r->prefix); + append_item(&tlvs->extended_ip_reach, (struct isis_item *)r); +} + +void isis_tlvs_add_ipv6_reach(struct isis_tlvs *tlvs, uint16_t mtid, + struct prefix_ipv6 *dest, uint32_t metric) +{ + struct isis_ipv6_reach *r = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*r)); + + r->metric = metric; + memcpy(&r->prefix, dest, sizeof(*dest)); + apply_mask_ipv6(&r->prefix); + + struct isis_item_list *l; + l = (mtid == ISIS_MT_IPV4_UNICAST) + ? &tlvs->ipv6_reach + : isis_get_mt_items(&tlvs->mt_ipv6_reach, mtid); + append_item(l, (struct isis_item *)r); +} + +void isis_tlvs_add_oldstyle_reach(struct isis_tlvs *tlvs, uint8_t *id, + uint8_t metric) +{ + struct isis_oldstyle_reach *r = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*r)); + + r->metric = metric; + memcpy(r->id, id, sizeof(r->id)); + append_item(&tlvs->oldstyle_reach, (struct isis_item *)r); +} + +void isis_tlvs_add_extended_reach(struct isis_tlvs *tlvs, uint16_t mtid, + uint8_t *id, uint32_t metric, + uint8_t *subtlvs, uint8_t subtlv_len) +{ + struct isis_extended_reach *r = XCALLOC(MTYPE_ISIS_TLV2, sizeof(*r)); + + memcpy(r->id, id, sizeof(r->id)); + r->metric = metric; + if (subtlvs && subtlv_len) { + r->subtlvs = XCALLOC(MTYPE_ISIS_TLV2, subtlv_len); + memcpy(r->subtlvs, subtlvs, subtlv_len); + r->subtlv_len = subtlv_len; + } + + struct isis_item_list *l; + if (mtid == ISIS_MT_IPV4_UNICAST) + l = &tlvs->extended_reach; + else + l = isis_get_mt_items(&tlvs->mt_reach, mtid); + append_item(l, (struct isis_item *)r); +} + +struct isis_mt_router_info * +isis_tlvs_lookup_mt_router_info(struct isis_tlvs *tlvs, uint16_t mtid) +{ + if (tlvs->mt_router_info_empty) + return NULL; + + struct isis_mt_router_info *rv; + for (rv = (struct isis_mt_router_info *)tlvs->mt_router_info.head; rv; + rv = rv->next) { + if (rv->mtid == mtid) + return rv; + } + + return NULL; +} diff --git a/isisd/isis_tlvs2.h b/isisd/isis_tlvs2.h new file mode 100644 index 0000000000..c15adf37d1 --- /dev/null +++ b/isisd/isis_tlvs2.h @@ -0,0 +1,308 @@ +/* + * IS-IS TLV Serializer/Deserializer + * + * Copyright (C) 2015,2017 Christian Franke + * + * This file is part of FRR. + * + * FRR 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. + * + * FRR 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 FRR; see the file COPYING. If not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ +#ifndef ISIS_TLVS2_H +#define ISIS_TLVS2_H + +#include "openbsd-tree.h" +#include "prefix.h" +#include "isisd/dict.h" + +struct isis_subtlvs; + +struct isis_area_address; +struct isis_area_address { + struct isis_area_address *next; + + uint8_t addr[20]; + uint8_t len; +}; + +struct isis_oldstyle_reach; +struct isis_oldstyle_reach { + struct isis_oldstyle_reach *next; + + uint8_t id[7]; + uint8_t metric; +}; + +struct isis_oldstyle_ip_reach; +struct isis_oldstyle_ip_reach { + struct isis_oldstyle_ip_reach *next; + + uint8_t metric; + struct prefix_ipv4 prefix; +}; + +struct isis_lsp_entry; +struct isis_lsp_entry { + struct isis_lsp_entry *next; + + uint16_t rem_lifetime; + uint8_t id[8]; + uint16_t checksum; + uint32_t seqno; + + struct isis_lsp *lsp; +}; + +struct isis_extended_reach; +struct isis_extended_reach { + struct isis_extended_reach *next; + + uint8_t id[7]; + uint32_t metric; + + uint8_t *subtlvs; + uint8_t subtlv_len; +}; + +struct isis_extended_ip_reach; +struct isis_extended_ip_reach { + struct isis_extended_ip_reach *next; + + uint32_t metric; + bool down; + struct prefix_ipv4 prefix; +}; + +struct isis_ipv6_reach; +struct isis_ipv6_reach { + struct isis_ipv6_reach *next; + + uint32_t metric; + bool down; + bool external; + + struct prefix_ipv6 prefix; + + struct isis_subtlvs *subtlvs; +}; + +struct isis_protocols_supported { + uint8_t count; + uint8_t *protocols; +}; + +struct isis_item; +struct isis_item { + struct isis_item *next; +}; + +struct isis_lan_neighbor; +struct isis_lan_neighbor { + struct isis_lan_neighbor *next; + + uint8_t mac[6]; +}; + +struct isis_ipv4_address; +struct isis_ipv4_address { + struct isis_ipv4_address *next; + + struct in_addr addr; +}; + +struct isis_ipv6_address; +struct isis_ipv6_address { + struct isis_ipv6_address *next; + + struct in6_addr addr; +}; + +struct isis_mt_router_info; +struct isis_mt_router_info { + struct isis_mt_router_info *next; + + bool overload; + bool attached; + uint16_t mtid; +}; + +struct isis_auth; +struct isis_auth { + struct isis_auth *next; + + uint8_t type; + uint8_t length; + uint8_t value[256]; + + uint8_t plength; + uint8_t passwd[256]; + + size_t offset; /* Only valid after packing */ +}; + +struct isis_item_list; +struct isis_item_list { + struct isis_item *head; + struct isis_item **tail; + + RB_ENTRY(isis_item_list) mt_tree; + uint16_t mtid; + unsigned int count; +}; + +RB_HEAD(isis_mt_item_list, isis_item_list); + +struct isis_item_list *isis_get_mt_items(struct isis_mt_item_list *m, + uint16_t mtid); +struct isis_item_list *isis_lookup_mt_items(struct isis_mt_item_list *m, + uint16_t mtid); + +struct isis_tlvs { + struct isis_item_list isis_auth; + struct isis_item_list area_addresses; + struct isis_item_list oldstyle_reach; + struct isis_item_list lan_neighbor; + struct isis_item_list lsp_entries; + struct isis_item_list extended_reach; + struct isis_mt_item_list mt_reach; + struct isis_item_list oldstyle_ip_reach; + struct isis_protocols_supported protocols_supported; + struct isis_item_list oldstyle_ip_reach_ext; + struct isis_item_list ipv4_address; + struct isis_item_list ipv6_address; + struct isis_item_list mt_router_info; + bool mt_router_info_empty; + struct in_addr *te_router_id; + struct isis_item_list extended_ip_reach; + struct isis_mt_item_list mt_ip_reach; + char *hostname; + struct isis_item_list ipv6_reach; + struct isis_mt_item_list mt_ipv6_reach; +}; + +struct isis_subtlvs { + /* draft-baker-ipv6-isis-dst-src-routing-06 */ + struct prefix_ipv6 *source_prefix; +}; + +enum isis_tlv_context { + ISIS_CONTEXT_LSP, + ISIS_CONTEXT_SUBTLV_NE_REACH, + ISIS_CONTEXT_SUBTLV_IP_REACH, + ISIS_CONTEXT_SUBTLV_IPV6_REACH, + ISIS_CONTEXT_MAX +}; + +enum isis_tlv_type { + ISIS_TLV_AREA_ADDRESSES = 1, + ISIS_TLV_OLDSTYLE_REACH = 2, + ISIS_TLV_LAN_NEIGHBORS = 6, + ISIS_TLV_PADDING = 8, + ISIS_TLV_LSP_ENTRY = 9, + ISIS_TLV_AUTH = 10, + ISIS_TLV_EXTENDED_REACH = 22, + + ISIS_TLV_OLDSTYLE_IP_REACH = 128, + ISIS_TLV_PROTOCOLS_SUPPORTED = 129, + ISIS_TLV_OLDSTYLE_IP_REACH_EXT = 130, + ISIS_TLV_IPV4_ADDRESS = 132, + ISIS_TLV_TE_ROUTER_ID = 134, + ISIS_TLV_EXTENDED_IP_REACH = 135, + ISIS_TLV_DYNAMIC_HOSTNAME = 137, + ISIS_TLV_MT_REACH = 222, + ISIS_TLV_MT_ROUTER_INFO = 229, + ISIS_TLV_IPV6_ADDRESS = 232, + ISIS_TLV_MT_IP_REACH = 235, + ISIS_TLV_IPV6_REACH = 236, + ISIS_TLV_MT_IPV6_REACH = 237, + ISIS_TLV_MAX = 256, + + ISIS_SUBTLV_IPV6_SOURCE_PREFIX = 22 +}; + +#define IS_COMPAT_MT_TLV(tlv_type) \ + ((tlv_type == ISIS_TLV_MT_REACH) || (tlv_type == ISIS_TLV_MT_IP_REACH) \ + || (tlv_type == ISIS_TLV_MT_IPV6_REACH)) + +struct stream; +int isis_pack_tlvs(struct isis_tlvs *tlvs, struct stream *stream, + size_t len_pointer, bool pad, bool is_lsp); +void isis_free_tlvs(struct isis_tlvs *tlvs); +struct isis_tlvs *isis_alloc_tlvs(void); +int isis_unpack_tlvs(size_t avail_len, struct stream *stream, + struct isis_tlvs **dest, const char **error_log); +const char *isis_format_tlvs(struct isis_tlvs *tlvs); +struct isis_tlvs *isis_copy_tlvs(struct isis_tlvs *tlvs); +struct list *isis_fragment_tlvs(struct isis_tlvs *tlvs, size_t size); + +#define ISIS_EXTENDED_IP_REACH_DOWN 0x80 +#define ISIS_EXTENDED_IP_REACH_SUBTLV 0x40 + +#define ISIS_IPV6_REACH_DOWN 0x80 +#define ISIS_IPV6_REACH_EXTERNAL 0x40 +#define ISIS_IPV6_REACH_SUBTLV 0x20 + +#ifndef ISIS_MT_MASK +#define ISIS_MT_MASK 0x0fff +#define ISIS_MT_OL_MASK 0x8000 +#define ISIS_MT_AT_MASK 0x4000 +#endif + + +void isis_tlvs_add_auth(struct isis_tlvs *tlvs, struct isis_passwd *passwd); +void isis_tlvs_add_area_addresses(struct isis_tlvs *tlvs, + struct list *addresses); +void isis_tlvs_add_lan_neighbors(struct isis_tlvs *tlvs, + struct list *neighbors); +void isis_tlvs_set_protocols_supported(struct isis_tlvs *tlvs, + struct nlpids *nlpids); +void isis_tlvs_add_mt_router_info(struct isis_tlvs *tlvs, uint16_t mtid, + bool overload, bool attached); +void isis_tlvs_add_ipv4_address(struct isis_tlvs *tlvs, struct in_addr *addr); +void isis_tlvs_add_ipv4_addresses(struct isis_tlvs *tlvs, + struct list *addresses); +void isis_tlvs_add_ipv6_addresses(struct isis_tlvs *tlvs, + struct list *addresses); +bool isis_tlvs_auth_is_valid(struct isis_tlvs *tlvs, struct isis_passwd *passwd, + struct stream *stream, bool is_lsp); +bool isis_tlvs_area_addresses_match(struct isis_tlvs *tlvs, + struct list *addresses); +struct isis_adjacency; +void isis_tlvs_to_adj(struct isis_tlvs *tlvs, struct isis_adjacency *adj, + bool *changed); +bool isis_tlvs_own_snpa_found(struct isis_tlvs *tlvs, uint8_t *snpa); +void isis_tlvs_add_lsp_entry(struct isis_tlvs *tlvs, struct isis_lsp *lsp); +void isis_tlvs_add_csnp_entries(struct isis_tlvs *tlvs, uint8_t *start_id, + uint8_t *stop_id, uint16_t num_lsps, + dict_t *lspdb, struct isis_lsp **last_lsp); +void isis_tlvs_set_dynamic_hostname(struct isis_tlvs *tlvs, + const char *hostname); +void isis_tlvs_set_te_router_id(struct isis_tlvs *tlvs, + const struct in_addr *id); +void isis_tlvs_add_oldstyle_ip_reach(struct isis_tlvs *tlvs, + struct prefix_ipv4 *dest, uint8_t metric); +void isis_tlvs_add_extended_ip_reach(struct isis_tlvs *tlvs, + struct prefix_ipv4 *dest, uint32_t metric); +void isis_tlvs_add_ipv6_reach(struct isis_tlvs *tlvs, uint16_t mtid, + struct prefix_ipv6 *dest, uint32_t metric); +void isis_tlvs_add_oldstyle_reach(struct isis_tlvs *tlvs, uint8_t *id, + uint8_t metric); +void isis_tlvs_add_extended_reach(struct isis_tlvs *tlvs, uint16_t mtid, + uint8_t *id, uint32_t metric, + uint8_t *subtlvs, uint8_t subtlv_len); + +struct isis_mt_router_info * +isis_tlvs_lookup_mt_router_info(struct isis_tlvs *tlvs, uint16_t mtid); +#endif diff --git a/tests/.gitignore b/tests/.gitignore index 6d54ae155b..113bdea098 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -25,6 +25,8 @@ __pycache__ /bgpd/test_ecommunity /bgpd/test_mp_attr /bgpd/test_mpath +/isisd/test_fuzz_isis_tlv +/isisd/test_fuzz_isis_tlv_tests.h /lib/cli/test_cli /lib/cli/test_commands /lib/cli/test_commands_defun.c diff --git a/tests/Makefile.am b/tests/Makefile.am index 43003e7075..0c31c0441a 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -24,6 +24,13 @@ else TESTS_BGPD = endif +if ISISD +TESTS_ISISD = \ + isisd/test_fuzz_isis_tlv +else +TESTS_ISISD = +endif + if OSPF6D TESTS_OSPF6D = \ ospf6d/test_lsdb \ @@ -61,6 +68,7 @@ check_PROGRAMS = \ lib/cli/test_cli \ lib/cli/test_commands \ $(TESTS_BGPD) \ + $(TESTS_ISISD) \ $(TESTS_OSPF6D) \ # end @@ -75,7 +83,12 @@ lib/cli/test_commands_defun.c: ../vtysh/vtysh_cmd.c < ../vtysh/vtysh_cmd.c \ > "$@" -BUILT_SOURCES = lib/cli/test_commands_defun.c +isisd/test_fuzz_isis_tlv_tests.h: $(top_srcdir)/tests/isisd/test_fuzz_isis_tlv_tests.h.gz + gzip -d < $(top_srcdir)/tests/isisd/test_fuzz_isis_tlv_tests.h.gz > "$@" + +BUILT_SOURCES = \ + lib/cli/test_commands_defun.c \ + isisd/test_fuzz_isis_tlv_tests.h noinst_HEADERS = \ ./helpers/c/prng.h \ @@ -110,11 +123,14 @@ bgpd_test_capability_SOURCES = bgpd/test_capability.c bgpd_test_ecommunity_SOURCES = bgpd/test_ecommunity.c bgpd_test_mp_attr_SOURCES = bgpd/test_mp_attr.c bgpd_test_mpath_SOURCES = bgpd/test_mpath.c +isisd_test_fuzz_isis_tlv_SOURCES = isisd/test_fuzz_isis_tlv.c +isisd_test_fuzz_isis_tlv_CPPFLAGS = $(AM_CPPFLAGS) -I$(top_builddir)/tests/isisd ospf6d_test_lsdb_SOURCES = ospf6d/test_lsdb.c lib/cli/common_cli.c ALL_TESTS_LDADD = ../lib/libfrr.la @LIBCAP@ BGP_TEST_LDADD = ../bgpd/libbgp.a $(BGP_VNC_RFP_LIB) $(ALL_TESTS_LDADD) -lm +ISISD_TEST_LDADD = ../isisd/libisis.a $(ALL_TESTS_LDADD) OSPF6_TEST_LDADD = ../ospf6d/libospf6.a $(ALL_TESTS_LDADD) lib_test_buffer_LDADD = $(ALL_TESTS_LDADD) @@ -140,6 +156,7 @@ bgpd_test_capability_LDADD = $(BGP_TEST_LDADD) bgpd_test_ecommunity_LDADD = $(BGP_TEST_LDADD) bgpd_test_mp_attr_LDADD = $(BGP_TEST_LDADD) bgpd_test_mpath_LDADD = $(BGP_TEST_LDADD) +isisd_test_fuzz_isis_tlv_LDADD = $(ISISD_TEST_LDADD) ospf6d_test_lsdb_LDADD = $(OSPF6_TEST_LDADD) EXTRA_DIST = \ @@ -151,6 +168,8 @@ EXTRA_DIST = \ bgpd/test_mpath.py \ helpers/python/frrsix.py \ helpers/python/frrtest.py \ + isisd/test_fuzz_isis_tlv.py \ + isisd/test_fuzz_isis_tlv_tests.h.gz \ lib/cli/test_commands.in \ lib/cli/test_commands.py \ lib/cli/test_commands.refout \ diff --git a/tests/isisd/.gitignore b/tests/isisd/.gitignore new file mode 100644 index 0000000000..e124221296 --- /dev/null +++ b/tests/isisd/.gitignore @@ -0,0 +1 @@ +/*_afl/* diff --git a/tests/isisd/test_fuzz_isis_tlv.c b/tests/isisd/test_fuzz_isis_tlv.c new file mode 100644 index 0000000000..33eb4b523d --- /dev/null +++ b/tests/isisd/test_fuzz_isis_tlv.c @@ -0,0 +1,188 @@ +#include "test_fuzz_isis_tlv_tests.h" + +#include + +#include "memory.h" +#include "sbuf.h" +#include "stream.h" +#include "thread.h" + +#include "isisd/isis_circuit.h" +#include "isisd/isis_tlvs2.h" + +#define TEST_STREAM_SIZE 1500 + +struct thread_master *master; +int isis_sock_init(struct isis_circuit *circuit); +int isis_sock_init(struct isis_circuit *circuit) +{ + return 0; +} + +static bool atexit_registered; + +static void show_meminfo_at_exit(void) +{ + log_memstats_stderr("isis fuzztest"); +} + +static int comp_line(const void *p1, const void *p2) +{ + return strcmp(*(char * const *)p1, *(char * const *)p2); +} + +static char *sortlines(char *in) +{ + size_t line_count = 1; + size_t rv_len = strlen(in) + 1; + size_t rv_pos = 0; + char *rv = XMALLOC(MTYPE_TMP, rv_len); + + for (char *c = in; *c; c++) { + if (*c == '\n') + line_count++; + } + + if (line_count == 1) { + strncpy(rv, in, rv_len); + return rv; + } + + char **lines = XCALLOC(MTYPE_TMP, sizeof(char *)*line_count); + char *saveptr = NULL; + size_t i = 0; + + for (char *line = strtok_r(in, "\n", &saveptr); line; + line = strtok_r(NULL, "\n", &saveptr)) { + lines[i++] = line; + assert(i <= line_count); + } + + line_count = i; + + qsort(lines, line_count, sizeof(char *), comp_line); + + for (i = 0; i < line_count; i++) { + int printf_rv = snprintf(rv + rv_pos, rv_len - rv_pos, "%s\n", lines[i]); + assert(printf_rv >= 0); + rv_pos += printf_rv; + } + + XFREE(MTYPE_TMP, lines); + return rv; +} + +static int test(FILE *input, FILE *output) +{ + struct stream *s = stream_new(TEST_STREAM_SIZE); + char buf[TEST_STREAM_SIZE]; + size_t bytes_read = 0; + + if (!atexit_registered) { + atexit(show_meminfo_at_exit); + atexit_registered = true; + } + + while (STREAM_WRITEABLE(s) && !feof(input)) { + bytes_read = fread(buf, 1, STREAM_WRITEABLE(s), input); + if (bytes_read == 0) + break; + stream_put(s, buf, bytes_read); + } + + if (bytes_read && !feof(input)) { + fprintf(output, "Too much input data.\n"); + stream_free(s); + return 1; + } + + stream_set_getp(s, 0); + struct isis_tlvs *tlvs; + const char *log; + int rv = isis_unpack_tlvs(STREAM_READABLE(s), s, &tlvs, &log); + + if (rv) { + fprintf(output, "Could not unpack TLVs:\n%s\n", log); + isis_free_tlvs(tlvs); + stream_free(s); + return 2; + } + + fprintf(output, "Unpack log:\n%s", log); + const char *s_tlvs = isis_format_tlvs(tlvs); + fprintf(output, "Unpacked TLVs:\n%s", s_tlvs); + + struct isis_tlvs *tlv_copy = isis_copy_tlvs(tlvs); + isis_free_tlvs(tlvs); + + struct stream *s2 = stream_new(TEST_STREAM_SIZE); + + if (isis_pack_tlvs(tlv_copy, s2, (size_t)-1, false, false)) { + fprintf(output, "Could not pack TLVs.\n"); + assert(0); + } + + stream_set_getp(s2, 0); + rv = isis_unpack_tlvs(STREAM_READABLE(s2), s2, &tlvs, &log); + if (rv) { + fprintf(output, "Could not unpack own TLVs:\n%s\n", log); + assert(0); + } + + char *orig_tlvs = XSTRDUP(MTYPE_TMP, s_tlvs); + s_tlvs = isis_format_tlvs(tlvs); + + if (strcmp(orig_tlvs, s_tlvs)) { + fprintf(output, + "Deserialized and Serialized LSP seem to differ.\n"); + fprintf(output, "Re-Unpacked TLVs:\n%s", s_tlvs); + assert(0); + } + + isis_free_tlvs(tlv_copy); + stream_free(s); + stream_free(s2); + + struct list *fragments = isis_fragment_tlvs(tlvs, 550); + isis_free_tlvs(tlvs); + if (!fragments) { + XFREE(MTYPE_TMP, orig_tlvs); + return 0; + } + + s = stream_new(550); + + struct sbuf fragment_format; + sbuf_init(&fragment_format, NULL, 0); + + struct listnode *node; + for (ALL_LIST_ELEMENTS_RO(fragments, node, tlvs)) { + stream_reset(s); + int rv = isis_pack_tlvs(tlvs, s, (size_t)-1, false, false); + if (rv) { + fprintf(output, "Could not pack fragment, too large.\n"); + assert(0); + } + sbuf_push(&fragment_format, 0, "%s", isis_format_tlvs(tlvs)); + isis_free_tlvs(tlvs); + } + list_delete(fragments); + stream_free(s); + + char *fragment_content = sortlines((char *)sbuf_buf(&fragment_format)); + sbuf_free(&fragment_format); + char *orig_tlv_content = sortlines(orig_tlvs); + XFREE(MTYPE_TMP, orig_tlvs); + + if (strcmp(fragment_content, orig_tlv_content)) { + fprintf(output, "Fragmented and unfragmented LSP seem to differ.\n"); + fprintf(output, "Original:\n%s\nFragmented:\n%s\n", + orig_tlv_content, fragment_content); + assert(0); + } + + XFREE(MTYPE_TMP, fragment_content); + XFREE(MTYPE_TMP, orig_tlv_content); + + return 0; +} diff --git a/tests/isisd/test_fuzz_isis_tlv.py b/tests/isisd/test_fuzz_isis_tlv.py new file mode 100644 index 0000000000..60938472b5 --- /dev/null +++ b/tests/isisd/test_fuzz_isis_tlv.py @@ -0,0 +1,6 @@ +import frrtest + +class TestFuzzIsisTLV(frrtest.TestMultiOut): + program = './test_fuzz_isis_tlv' + +TestFuzzIsisTLV.exit_cleanly() diff --git a/tests/isisd/test_fuzz_isis_tlv_tests.h.gz b/tests/isisd/test_fuzz_isis_tlv_tests.h.gz new file mode 100644 index 0000000000000000000000000000000000000000..3eb0205a5db812b83d5818bf4c161dcdeadcd7b3 GIT binary patch literal 232370 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

;=qqC$_xBy7!;-cAWLBFff`r}dSpnS+nj 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

ebVA`g7e=zTA~`BNCQVqM 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