*: make consistent & update GPLv2 file headers

[mirror_frr.git] / isisd / isis_tlv.c

/*
 * IS-IS Rout(e)ing protocol - isis_tlv.c
 *                             IS-IS TLV related routines
 *
 * Copyright (C) 2001,2002   Sampo Saaristo
 *                           Tampere University of Technology      
 *                           Institute of Communications Engineering
 *
 * This program is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU General Public Licenseas published by the Free 
 * Software Foundation; either version 2 of the License, or (at your option) 
 * any later version.
 *
 * This program 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 this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "log.h"
#include "linklist.h"
#include "stream.h"
#include "memory.h"
#include "prefix.h"
#include "vty.h"
#include "if.h"

#include "isisd/dict.h"
#include "isisd/isis_constants.h"
#include "isisd/isis_common.h"
#include "isisd/isis_flags.h"
#include "isisd/isis_circuit.h"
#include "isisd/isis_tlv.h"
#include "isisd/isisd.h"
#include "isisd/isis_dynhn.h"
#include "isisd/isis_misc.h"
#include "isisd/isis_pdu.h"
#include "isisd/isis_lsp.h"
#include "isisd/isis_te.h"
#include "isisd/isis_mt.h"

void
free_tlv (void *val)
{
  XFREE (MTYPE_ISIS_TLV, val);

  return;
}

/*
 * Called after parsing of a PDU. There shouldn't be any tlv's left, so this
 * is only a caution to avoid memory leaks
 */
void
free_tlvs (struct tlvs *tlvs)
{
  if (tlvs->area_addrs)
    list_delete (tlvs->area_addrs);
  if (tlvs->mt_router_info)
    list_delete (tlvs->mt_router_info);
  if (tlvs->is_neighs)
    list_delete (tlvs->is_neighs);
  if (tlvs->te_is_neighs)
    list_delete (tlvs->te_is_neighs);
  if (tlvs->mt_is_neighs)
    list_delete (tlvs->mt_is_neighs);
  if (tlvs->es_neighs)
    list_delete (tlvs->es_neighs);
  if (tlvs->lsp_entries)
    list_delete (tlvs->lsp_entries);
  if (tlvs->prefix_neighs)
    list_delete (tlvs->prefix_neighs);
  if (tlvs->lan_neighs)
    list_delete (tlvs->lan_neighs);
  if (tlvs->ipv4_addrs)
    list_delete (tlvs->ipv4_addrs);
  if (tlvs->ipv4_int_reachs)
    list_delete (tlvs->ipv4_int_reachs);
  if (tlvs->ipv4_ext_reachs)
    list_delete (tlvs->ipv4_ext_reachs);
  if (tlvs->te_ipv4_reachs)
    list_delete (tlvs->te_ipv4_reachs);
  if (tlvs->mt_ipv4_reachs)
    list_delete (tlvs->mt_ipv4_reachs);
  if (tlvs->ipv6_addrs)
    list_delete (tlvs->ipv6_addrs);
  if (tlvs->ipv6_reachs)
    list_delete (tlvs->ipv6_reachs);
  if (tlvs->mt_ipv6_reachs)
    list_delete (tlvs->mt_ipv6_reachs);

  memset (tlvs, 0, sizeof (struct tlvs));

  return;
}

static int
parse_mtid(uint16_t *mtid, bool read_mtid,
           unsigned int *length, u_char **pnt)
{
  if (!read_mtid)
    {
      *mtid = ISIS_MT_IPV4_UNICAST;
      return ISIS_OK;
    }

  uint16_t mtid_buf;

  if (*length < sizeof(mtid_buf))
    {
      zlog_warn("ISIS-TLV: mt tlv too short to contain MT id");
      return ISIS_WARNING;
    }

  memcpy(&mtid_buf, *pnt, sizeof(mtid_buf));
  *pnt += sizeof(mtid_buf);
  *length -= sizeof(mtid_buf);

  *mtid = ntohs(mtid_buf) & ISIS_MT_MASK;
  return ISIS_OK;
}

static int
parse_mt_is_neighs(struct tlvs *tlvs, bool read_mtid,
                   unsigned int length, u_char *pnt)
{
  struct list *neigh_list;
  uint16_t mtid;
  int rv;

  rv = parse_mtid(&mtid, read_mtid, &length, &pnt);
  if (rv != ISIS_OK)
    return rv;

  if (mtid == ISIS_MT_IPV4_UNICAST)
    {
      if (!tlvs->te_is_neighs)
        {
          tlvs->te_is_neighs = list_new();
          tlvs->te_is_neighs->del = free_tlv;
        }
      neigh_list = tlvs->te_is_neighs;
    }
  else
    {
      struct tlv_mt_neighbors *neighbors;

      neighbors = tlvs_get_mt_neighbors(tlvs, mtid);
      neighbors->list->del = free_tlv;
      neigh_list = neighbors->list;
    }

  while (length >= IS_NEIGHBOURS_LEN)
    {
      struct te_is_neigh *neigh = XCALLOC(MTYPE_ISIS_TLV, sizeof(*neigh));

      memcpy(neigh, pnt, IS_NEIGHBOURS_LEN);
      pnt += IS_NEIGHBOURS_LEN;
      length -= IS_NEIGHBOURS_LEN;

      if (neigh->sub_tlvs_length > length)
        {
          zlog_warn("ISIS-TLV: neighbor subtlv length exceeds TLV size");
          XFREE(MTYPE_ISIS_TLV, neigh);
          return ISIS_WARNING;
        }

      memcpy(neigh->sub_tlvs, pnt, neigh->sub_tlvs_length);
      pnt += neigh->sub_tlvs_length;
      length -= neigh->sub_tlvs_length;

      listnode_add(neigh_list, neigh);
    }

  if (length)
    {
      zlog_warn("ISIS-TLV: TE/MT neighor TLV has trailing data");
      return ISIS_WARNING;
    }

  return ISIS_OK;
}

static int
parse_mt_ipv4_reachs(struct tlvs *tlvs, bool read_mtid,
                     unsigned int length, u_char *pnt)
{
  struct list *reach_list;
  uint16_t mtid;
  int rv;

  rv = parse_mtid(&mtid, read_mtid, &length, &pnt);
  if (rv != ISIS_OK)
    return rv;

  if (mtid == ISIS_MT_IPV4_UNICAST)
    {
      if (!tlvs->te_ipv4_reachs)
        {
          tlvs->te_ipv4_reachs = list_new();
          tlvs->te_ipv4_reachs->del = free_tlv;
        }
      reach_list = tlvs->te_ipv4_reachs;
    }
  else
    {
      struct tlv_mt_ipv4_reachs *reachs;

      reachs = tlvs_get_mt_ipv4_reachs(tlvs, mtid);
      reachs->list->del = free_tlv;
      reach_list = reachs->list;
    }

  while (length >= 5) /* Metric + Control */
    {
      struct te_ipv4_reachability *reach = XCALLOC(MTYPE_ISIS_TLV, TE_IPV4_REACH_LEN);

      memcpy(reach, pnt, 5); /* Metric + Control */
      pnt += 5;
      length -= 5;

      unsigned char prefixlen = reach->control & 0x3F;

      if (prefixlen > IPV4_MAX_BITLEN)
        {
          zlog_warn("ISIS-TLV: invalid IPv4 extended reachability prefix length %d", prefixlen);
          XFREE(MTYPE_ISIS_TLV, reach);
          return ISIS_WARNING;
        }

      if (length < (unsigned int)PSIZE(prefixlen))
        {
          zlog_warn("ISIS-TLV: invalid IPv4 extended reachability prefix too long for tlv");
          XFREE(MTYPE_ISIS_TLV, reach);
          return ISIS_WARNING;
        }

      memcpy(&reach->prefix_start, pnt, PSIZE(prefixlen));
      pnt += PSIZE(prefixlen);
      length -= PSIZE(prefixlen);

      if (reach->control & TE_IPV4_HAS_SUBTLV)
        {
          if (length < 1)
            {
              zlog_warn("ISIS-TLV: invalid IPv4 extended reachability SubTLV missing");
              XFREE(MTYPE_ISIS_TLV, reach);
              return ISIS_WARNING;
            }

          u_char subtlv_len = *pnt;
          pnt++;
          length--;

          if (length < subtlv_len)
            {
              zlog_warn("ISIS-TLV: invalid IPv4 extended reachability SubTLVs have oversize");
              XFREE(MTYPE_ISIS_TLV, reach);
              return ISIS_WARNING;
            }

          /* Skip Sub-TLVs for now */
          pnt += subtlv_len;
          length -= subtlv_len;
        }
      listnode_add(reach_list, reach);
    }

  if (length)
    {
      zlog_warn("ISIS-TLV: TE/MT ipv4 reachability TLV has trailing data");
      return ISIS_WARNING;
    }

  return ISIS_OK;
}

static int
parse_mt_ipv6_reachs(struct tlvs *tlvs, bool read_mtid,
                     unsigned int length, u_char *pnt)
{
  struct list *reach_list;
  uint16_t mtid;
  int rv;

  rv = parse_mtid(&mtid, read_mtid, &length, &pnt);
  if (rv != ISIS_OK)
    return rv;

  if (mtid == ISIS_MT_IPV4_UNICAST)
    {
      if (!tlvs->ipv6_reachs)
        {
          tlvs->ipv6_reachs = list_new();
          tlvs->ipv6_reachs->del = free_tlv;
        }
      reach_list = tlvs->ipv6_reachs;
    }
  else
    {
      struct tlv_mt_ipv6_reachs *reachs;

      reachs = tlvs_get_mt_ipv6_reachs(tlvs, mtid);
      reachs->list->del = free_tlv;
      reach_list = reachs->list;
    }

  while (length >= 6) /* Metric + Control + Prefixlen */
    {
      struct ipv6_reachability *reach = XCALLOC(MTYPE_ISIS_TLV, sizeof(*reach));

      memcpy(reach, pnt, 6); /* Metric + Control + Prefixlen */
      pnt += 6;
      length -= 6;

      if (reach->prefix_len > IPV6_MAX_BITLEN)
        {
          zlog_warn("ISIS-TLV: invalid IPv6 reachability prefix length %d", reach->prefix_len);
          XFREE(MTYPE_ISIS_TLV, reach);
          return ISIS_WARNING;
        }

      if (length < (unsigned int)PSIZE(reach->prefix_len))
        {
          zlog_warn("ISIS-TLV: invalid IPv6 reachability prefix too long for tlv");
          XFREE(MTYPE_ISIS_TLV, reach);
          return ISIS_WARNING;
        }

      memcpy(&reach->prefix, pnt, PSIZE(reach->prefix_len));
      pnt += PSIZE(reach->prefix_len);
      length -= PSIZE(reach->prefix_len);

      if (reach->control_info & CTRL_INFO_SUBTLVS)
        {
          if (length < 1)
            {
              zlog_warn("ISIS-TLV: invalid IPv6 reachability SubTLV missing");
              XFREE(MTYPE_ISIS_TLV, reach);
              return ISIS_WARNING;
            }

          u_char subtlv_len = *pnt;
          pnt++;
          length--;

          if (length < subtlv_len)
            {
              zlog_warn("ISIS-TLV: invalid IPv6 reachability SubTLVs have oversize");
              XFREE(MTYPE_ISIS_TLV, reach);
              return ISIS_WARNING;
            }

          /* Skip Sub-TLVs for now */
          pnt += subtlv_len;
          length -= subtlv_len;
        }
      listnode_add(reach_list, reach);
    }

  if (length)
    {
      zlog_warn("ISIS-TLV: (MT) IPv6 reachability TLV has trailing data");
      return ISIS_WARNING;
    }

  return ISIS_OK;
}

/*
 * Parses the tlvs found in the variant length part of the PDU.
 * Caller tells with flags in "expected" which TLV's it is interested in.
 */
int
parse_tlvs (char *areatag, u_char * stream, int size, u_int32_t * expected,
	    u_int32_t * found, struct tlvs *tlvs, u_int32_t *auth_tlv_offset)
{
  u_char type, length;
  struct lan_neigh *lan_nei;
  struct area_addr *area_addr;
  struct is_neigh *is_nei;
  struct es_neigh *es_nei;
  struct lsp_entry *lsp_entry;
  struct in_addr *ipv4_addr;
  struct ipv4_reachability *ipv4_reach;
  struct in6_addr *ipv6_addr;
  int value_len, retval = ISIS_OK;
  u_char *start = stream, *pnt = stream;

  *found = 0;
  memset (tlvs, 0, sizeof (struct tlvs));

  while (pnt < stream + size - 2)
    {
      type = *pnt;
      length = *(pnt + 1);
      pnt += 2;
      value_len = 0;
      if (pnt + length > stream + size)
	{
	  zlog_warn ("ISIS-TLV (%s): TLV (type %d, length %d) exceeds packet "
		     "boundaries", areatag, type, length);
	  retval = ISIS_WARNING;
	  break;
	}
      switch (type)
	{
	case AREA_ADDRESSES:
	  /* +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |                        Address Length                         | 
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |                         Area Address                          | 
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * :                                                               :
	   */
	  *found |= TLVFLAG_AREA_ADDRS;
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("TLV Area Adresses len %d", length);
#endif /* EXTREME_TLV_DEBUG */
	  if (*expected & TLVFLAG_AREA_ADDRS)
	    {
	      while (length > value_len)
		{
		  area_addr = (struct area_addr *) pnt;
		  value_len += area_addr->addr_len + 1;
		  pnt += area_addr->addr_len + 1;
		  if (!tlvs->area_addrs)
		    tlvs->area_addrs = list_new ();
		  listnode_add (tlvs->area_addrs, area_addr);
		}
	    }
	  else
	    {
	      pnt += length;
	    }
	  break;

	case IS_NEIGHBOURS:
	  *found |= TLVFLAG_IS_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("ISIS-TLV (%s): IS Neighbours length %d",
		      areatag, length);
#endif /* EXTREME_TLV_DEBUG */
	  if (TLVFLAG_IS_NEIGHS & *expected)
	    {
	      /* +-------+-------+-------+-------+-------+-------+-------+-------+
	       * |                        Virtual Flag                           | 
	       * +-------+-------+-------+-------+-------+-------+-------+-------+
	       */
	      pnt++;
	      value_len++;
	      /* +-------+-------+-------+-------+-------+-------+-------+-------+
	       * |   0   |  I/E  |               Default Metric                  | 
	       * +-------+-------+-------+-------+-------+-------+-------+-------+
	       * |   S   |  I/E  |               Delay Metric                    |
	       * +-------+-------+-------+-------+-------+-------+-------+-------+
	       * |   S   |  I/E  |               Expense Metric                  |
	       * +-------+-------+-------+-------+-------+-------+-------+-------+
	       * |   S   |  I/E  |               Error Metric                    |
	       * +-------+-------+-------+-------+-------+-------+-------+-------+
	       * |                        Neighbour ID                           |
	       * +---------------------------------------------------------------+
	       * :                                                               :
	       */
	      while (length > value_len)
		{
		  is_nei = (struct is_neigh *) pnt;
		  value_len += 4 + ISIS_SYS_ID_LEN + 1;
		  pnt += 4 + ISIS_SYS_ID_LEN + 1;
		  if (!tlvs->is_neighs)
		    tlvs->is_neighs = list_new ();
		  listnode_add (tlvs->is_neighs, is_nei);
		}
	    }
	  else
	    {
	      pnt += length;
	    }
	  break;

	case TE_IS_NEIGHBOURS:
	  *found |= TLVFLAG_TE_IS_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("ISIS-TLV (%s): Extended IS Neighbours length %d",
		     areatag, length);
#endif /* EXTREME_TLV_DEBUG */
	  if (TLVFLAG_TE_IS_NEIGHS & *expected)
	    retval = parse_mt_is_neighs(tlvs, false, length, pnt);
	  pnt += length;
	  break;

	case MT_IS_NEIGHBOURS:
	  *found |= TLVFLAG_TE_IS_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("ISIS-TLV (%s): MT IS Neighbours length %d",
	              areatag, length);
#endif
	  if (TLVFLAG_TE_IS_NEIGHS & *expected)
	    retval = parse_mt_is_neighs(tlvs, true, length, pnt);
	  pnt += length;
	  break;

	case ES_NEIGHBOURS:
	  /* +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |   0   |  I/E  |               Default Metric                  | 
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |   S   |  I/E  |               Delay Metric                    |
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |   S   |  I/E  |               Expense Metric                  |
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |   S   |  I/E  |               Error Metric                    |
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |                        Neighbour ID                           |
	   * +---------------------------------------------------------------+
	   * |                        Neighbour ID                           |
	   * +---------------------------------------------------------------+
	   * :                                                               :
	   */
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("ISIS-TLV (%s): ES Neighbours length %d",
		     areatag, length);
#endif /* EXTREME_TLV_DEBUG */
	  *found |= TLVFLAG_ES_NEIGHS;
	  if (*expected & TLVFLAG_ES_NEIGHS)
	    {
	      es_nei = (struct es_neigh *) pnt;
	      value_len += 4;
	      pnt += 4;
	      while (length > value_len)
		{
		  /* FIXME FIXME FIXME - add to the list */
		  /*          sys_id->id = pnt; */
		  value_len += ISIS_SYS_ID_LEN;
		  pnt += ISIS_SYS_ID_LEN;
		  /*  if (!es_nei->neigh_ids) es_nei->neigh_ids = sysid; */
		}
	      if (!tlvs->es_neighs)
		tlvs->es_neighs = list_new ();
	      listnode_add (tlvs->es_neighs, es_nei);
	    }
	  else
	    {
	      pnt += length;
	    }
	  break;

	case LAN_NEIGHBOURS:
	  /* +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |                        LAN Address                            | 
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * :                                                               :
	   */
	  *found |= TLVFLAG_LAN_NEIGHS;
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("ISIS-TLV (%s): LAN Neigbours length %d",
		      areatag, length);
#endif /* EXTREME_TLV_DEBUG */
	  if (TLVFLAG_LAN_NEIGHS & *expected)
	    {
	      while (length > value_len)
		{
		  lan_nei = (struct lan_neigh *) pnt;
		  if (!tlvs->lan_neighs)
		    tlvs->lan_neighs = list_new ();
		  listnode_add (tlvs->lan_neighs, lan_nei);
		  value_len += ETH_ALEN;
		  pnt += ETH_ALEN;
		}
	    }
	  else
	    {
	      pnt += length;
	    }
	  break;

	case PADDING:
#ifdef EXTREME_TLV_DEBUG
	  zlog_debug ("TLV padding %d", length);
#endif /* EXTREME_TLV_DEBUG */
	  pnt += length;
	  break;

	case LSP_ENTRIES:
	  /* +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |                     Remaining Lifetime                        | 2
	   * +-------+-------+-------+-------+-------+-------+-------+-------+
	   * |                         LSP ID                                | id+2
	   * +-------+-------+-------+-------+-------+-------+-------+-------+