// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * This is an implementation of RFC7684 OSPFv2 Prefix/Link Attribute

 * Advertisement

 *

 * Module name: Extended Prefix/Link Opaque LSA

 *

 * Author: Olivier Dugeon <olivier.dugeon@orange.com>

 * Author: Anselme Sawadogo <anselmesawadogo@gmail.com>

 *

 * Copyright (C) 2016 - 2018 Orange Labs http://www.orange.com

 */

#include <zebra.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include "linklist.h"

#include "prefix.h"

#include "if.h"

#include "table.h"

#include "memory.h"

#include "command.h"

#include "vty.h"

#include "stream.h"

#include "log.h"

#include "frrevent.h"

#include "hash.h"

#include "sockunion.h" /* for inet_aton() */

#include "network.h"

#include "if.h"

#include "libospf.h" /* for ospf interface types */

#include "ospfd/ospfd.h"

#include "ospfd/ospf_interface.h"

#include "ospfd/ospf_ism.h"

#include "ospfd/ospf_asbr.h"

#include "ospfd/ospf_lsa.h"

#include "ospfd/ospf_lsdb.h"

#include "ospfd/ospf_neighbor.h"

#include "ospfd/ospf_nsm.h"

#include "ospfd/ospf_flood.h"

#include "ospfd/ospf_packet.h"

#include "ospfd/ospf_spf.h"

#include "ospfd/ospf_dump.h"

#include "ospfd/ospf_route.h"

#include "ospfd/ospf_ase.h"

#include "ospfd/ospf_zebra.h"

#include "ospfd/ospf_sr.h"

#include "ospfd/ospf_ext.h"

#include "ospfd/ospf_errors.h"

/* Following structure are internal use only. */

/*

 * Global variable to manage Extended Prefix/Link Opaque LSA on this node.

 * Note that all parameter values are stored in network byte order.

 */

static struct ospf_ext_lp OspfEXT;

/*

 * -----------------------------------------------------------------------

 * Following are initialize/terminate functions for Extended Prefix/Link

 * Opaque LSA handling.

 * -----------------------------------------------------------------------

 */

/* Extended Prefix Opaque LSA related callback functions */

static void ospf_ext_pref_show_info(struct vty *vty, struct json_object *json,

            struct ospf_lsa *lsa);

static int ospf_ext_pref_lsa_originate(void *arg);

static struct ospf_lsa *ospf_ext_pref_lsa_refresh(struct ospf_lsa *lsa);

static void ospf_ext_pref_lsa_schedule(struct ext_itf *exti,

               enum lsa_opcode opcode);

/* Extended Link Opaque LSA related callback functions */

static int ospf_ext_link_new_if(struct interface *ifp);

static int ospf_ext_link_del_if(struct interface *ifp);

static void ospf_ext_ism_change(struct ospf_interface *oi, int old_status);

static void ospf_ext_link_nsm_change(struct ospf_neighbor *nbr, int old_status);

static void ospf_ext_link_show_info(struct vty *vty, struct json_object *json,

            struct ospf_lsa *lsa);

static int ospf_ext_link_lsa_originate(void *arg);

static struct ospf_lsa *ospf_ext_link_lsa_refresh(struct ospf_lsa *lsa);

static void ospf_ext_link_lsa_schedule(struct ext_itf *exti,

               enum lsa_opcode opcode);

static void ospf_ext_lsa_schedule(struct ext_itf *exti, enum lsa_opcode op);

static int ospf_ext_link_lsa_update(struct ospf_lsa *lsa);

static int ospf_ext_pref_lsa_update(struct ospf_lsa *lsa);

static void ospf_ext_link_delete_adj_sid(struct ext_itf *exti);

static void del_ext_info(void *val);

/*

 * Extended Link/Prefix initialization

 *

 * @param - none

 *

 * @return - 0 if OK, <> 0 otherwise

 */

int ospf_ext_init(void)

{

  int rc = 0;

  memset(&OspfEXT, 0, sizeof(OspfEXT));

  OspfEXT.enabled = false;

  /* Only Area flooding is supported yet */

  OspfEXT.scope = OSPF_OPAQUE_AREA_LSA;

  /* Initialize interface list */

  OspfEXT.iflist = list_new();

  OspfEXT.iflist->del = del_ext_info;

  zlog_info("EXT (%s): Register Extended Link Opaque LSA", __func__);

  rc = ospf_register_opaque_functab(

    OSPF_OPAQUE_AREA_LSA, OPAQUE_TYPE_EXTENDED_LINK_LSA,

    ospf_ext_link_new_if, /* new if */

    ospf_ext_link_del_if, /* del if */

    ospf_ext_ism_change,  /* ism change */

    ospf_ext_link_nsm_change,    /* nsm change */

    NULL,          /* Write router config. */

    NULL,          /* Write interface conf. */

    NULL,          /* Write debug config. */

    ospf_ext_link_show_info,     /* Show LSA info */

    ospf_ext_link_lsa_originate, /* Originate LSA */

    ospf_ext_link_lsa_refresh,   /* Refresh LSA */

    ospf_ext_link_lsa_update,    /* new_lsa_hook */

    NULL);           /* del_lsa_hook */

  if (rc != 0) {

    flog_warn(EC_OSPF_OPAQUE_REGISTRATION,

        "EXT (%s): Failed to register Extended Link LSA",

        __func__);

    return rc;

  }

  zlog_info("EXT (%s): Register Extended Prefix Opaque LSA", __func__);

  rc = ospf_register_opaque_functab(

    OspfEXT.scope, OPAQUE_TYPE_EXTENDED_PREFIX_LSA,

    NULL,          /* new if handle by link */

    NULL,          /* del if handle by link */

    NULL,          /* ism change */

    NULL,          /* nsm change */

    ospf_sr_config_write_router, /* Write router config. */

    NULL,          /* Write interface conf. */

    NULL,          /* Write debug config. */

    ospf_ext_pref_show_info,     /* Show LSA info */

    ospf_ext_pref_lsa_originate, /* Originate LSA */

    ospf_ext_pref_lsa_refresh,   /* Refresh LSA */

    ospf_ext_pref_lsa_update,    /* new_lsa_hook */

    NULL);           /* del_lsa_hook */

  if (rc != 0) {

    flog_warn(EC_OSPF_OPAQUE_REGISTRATION,

        "EXT (%s): Failed to register Extended Prefix LSA",

        __func__);

    return rc;

  }

  return rc;

}

/*

 * Extended Link/Prefix termination function

 *

 * @param - none

 * @return - none

 */

void ospf_ext_term(void)

{

  if ((OspfEXT.scope == OSPF_OPAQUE_AREA_LSA)

      || (OspfEXT.scope == OSPF_OPAQUE_AS_LSA))

    ospf_delete_opaque_functab(OspfEXT.scope,

             OPAQUE_TYPE_EXTENDED_PREFIX_LSA);

  ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA,

           OPAQUE_TYPE_EXTENDED_LINK_LSA);

  list_delete(&OspfEXT.iflist);

  OspfEXT.scope = 0;

  OspfEXT.enabled = false;

  return;

}

/*

 * Extended Link/Prefix finish function

 *

 * @param - none

 * @return - none

 */

void ospf_ext_finish(void)

{

  struct listnode *node;

  struct ext_itf *exti;

  /* Flush Router Info LSA */

  for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti))

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

      ospf_ext_lsa_schedule(exti, FLUSH_THIS_LSA);

  OspfEXT.enabled = false;

}

/*

 * ---------------------------------------------------------------------

 * Following are control functions for Extended Prefix/Link Opaque LSA

 * parameters management.

 * ---------------------------------------------------------------------

 */

/* Functions to free memory space */

static void del_ext_info(void *val)

{

  XFREE(MTYPE_OSPF_EXT_PARAMS, val);

}

/* Increment instance value for Extended Prefix Opaque LSAs Opaque ID field */

static uint32_t get_ext_pref_instance_value(void)

{

  static uint32_t seqno = 0;

  if (seqno < MAX_LEGAL_EXT_INSTANCE_NUM)

    seqno += 1;

  else

    seqno = 1; /* Avoid zero. */

  return seqno;

}

/* Increment instance value for Extended Link Opaque LSAs Opaque ID field */

static uint32_t get_ext_link_instance_value(void)

{

  static uint32_t seqno = 0;

  if (seqno < MAX_LEGAL_EXT_INSTANCE_NUM)

    seqno += 1;

  else

    seqno = 1; /* Avoid zero. */

  return seqno;

}

/* Lookup Extended Prefix/Links by ifp from OspfEXT struct iflist */

static struct ext_itf *lookup_ext_by_ifp(struct interface *ifp)

{

  struct listnode *node;

  struct ext_itf *exti;

  for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti))

    if (exti->ifp == ifp)

      return exti;

  return NULL;

}

/* Lookup Extended Prefix/Links by LSA ID from OspfEXT struct iflist */

static struct ext_itf *lookup_ext_by_instance(struct ospf_lsa *lsa)

{

  struct listnode *node;

  struct ext_itf *exti;

  uint32_t key = GET_OPAQUE_ID(ntohl(lsa->data->id.s_addr));

  uint8_t type = GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr));

  for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti))

    if ((exti->instance == key) && (exti->type == type))

      return exti;

  return NULL;

}

/*

 * ----------------------------------------------------------------------

 * The underlying subsection defines setters and unsetters to create and

 * delete tlvs and subtlvs

 * ----------------------------------------------------------------------

 */

/* Extended Prefix TLV - RFC7684 section 2.1 */

static void set_ext_prefix(struct ext_itf *exti, uint8_t route_type,

         uint8_t flags, struct prefix_ipv4 p)

{

  TLV_TYPE(exti->prefix) = htons(EXT_TLV_PREFIX);

  /* Warning: Size must be adjust depending of subTLV's */

  TLV_LEN(exti->prefix) = htons(EXT_TLV_PREFIX_SIZE);

  exti->prefix.route_type = route_type;

  exti->prefix.flags = flags;

  /* Only Address Family Ipv4 (0) is defined in RFC 7684 */

  exti->prefix.af = 0;

  exti->prefix.pref_length = p.prefixlen;

  exti->prefix.address = p.prefix;

  SET_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE);

}

/* Extended Link TLV - RFC7684 section 3.1 */

static void set_ext_link(struct ext_itf *exti, uint8_t type, struct in_addr id,

       struct in_addr data)

{

  TLV_TYPE(exti->link) = htons(EXT_TLV_LINK);

  /* Warning: Size must be adjust depending of subTLV's */

  TLV_LEN(exti->link) = htons(EXT_TLV_LINK_SIZE);

  exti->link.link_type = type;

  exti->link.link_id = id;

  exti->link.link_data = data;

}

/* Prefix SID SubTLV - section 5 */

static void set_prefix_sid(struct ext_itf *exti, uint8_t algorithm,

         uint32_t value, int value_type, uint8_t flags)

{

  if ((algorithm != SR_ALGORITHM_SPF)

      && (algorithm != SR_ALGORITHM_STRICT_SPF)) {

    flog_err(EC_OSPF_INVALID_ALGORITHM,

       "EXT (%s): unrecognized algorithm, not SPF or S-SPF",

       __func__);

    return;

  }

  /* Update flags according to the type of value field: label or index */

  if (value_type == SID_LABEL)

    SET_FLAG(flags, EXT_SUBTLV_PREFIX_SID_VFLG);

  /* set prefix sid subtlv for an extended prefix tlv */

  TLV_TYPE(exti->node_sid) = htons(EXT_SUBTLV_PREFIX_SID);

  exti->node_sid.algorithm = algorithm;

  exti->node_sid.flags = flags;

  exti->node_sid.mtid = 0; /* Multi-Topology is not supported */

  /* Set Label or Index value */

  if (value_type == SID_LABEL) {

    TLV_LEN(exti->node_sid) =

      htons(SID_LABEL_SIZE(EXT_SUBTLV_PREFIX_SID_SIZE));

    exti->node_sid.value = htonl(SET_LABEL(value));

  } else {

    TLV_LEN(exti->node_sid) =

      htons(SID_INDEX_SIZE(EXT_SUBTLV_PREFIX_SID_SIZE));

    exti->node_sid.value = htonl(value);

  }

}

/* Adjacency SID SubTLV - section 6.1 */

static void set_adj_sid(struct ext_itf *exti, bool backup, uint32_t value,

      int value_type)

{

  int index;

  uint8_t flags;

  /* Determine which ADJ_SID must be set: nominal or backup */

  if (backup) {

    flags = EXT_SUBTLV_LINK_ADJ_SID_BFLG;

    index = 1;

  } else {

    index = 0;

    flags = 0;

  }

  /* Set Header */

  TLV_TYPE(exti->adj_sid[index]) = htons(EXT_SUBTLV_ADJ_SID);

  /* Only Local ADJ-SID is supported for the moment */

  SET_FLAG(flags, EXT_SUBTLV_LINK_ADJ_SID_LFLG);

  exti->adj_sid[index].mtid = 0; /* Multi-Topology is not supported */

  /* Adjust Length, Flags and Value depending on the type of Label */

  if (value_type == SID_LABEL) {

    SET_FLAG(flags, EXT_SUBTLV_LINK_ADJ_SID_VFLG);

    TLV_LEN(exti->adj_sid[index]) =

      htons(SID_LABEL_SIZE(EXT_SUBTLV_ADJ_SID_SIZE));

    exti->adj_sid[index].value = htonl(SET_LABEL(value));

  } else {

    UNSET_FLAG(flags, EXT_SUBTLV_LINK_ADJ_SID_VFLG);

    TLV_LEN(exti->adj_sid[index]) =

      htons(SID_INDEX_SIZE(EXT_SUBTLV_ADJ_SID_SIZE));

    exti->adj_sid[index].value = htonl(value);

  }

  exti->adj_sid[index].flags = flags; /* Set computed flags */

  exti->adj_sid[index].mtid = 0;   /* Multi-Topology is not supported */

  exti->adj_sid[index].weight = 0; /* Load-Balancing is not supported */

}

/* LAN Adjacency SID SubTLV - section 6.2 */

static void set_lan_adj_sid(struct ext_itf *exti, bool backup, uint32_t value,

          int value_type, struct in_addr neighbor_id)

{

  int index;

  uint8_t flags;

  /* Determine which ADJ_SID must be set: nominal or backup */

  if (backup) {

    flags = EXT_SUBTLV_LINK_ADJ_SID_BFLG;

    index = 1;

  } else {

    index = 0;

    flags = 0;

  }

  /* Set Header */

  TLV_TYPE(exti->lan_sid[index]) = htons(EXT_SUBTLV_LAN_ADJ_SID);

  /* Only Local ADJ-SID is supported for the moment */

  SET_FLAG(flags, EXT_SUBTLV_LINK_ADJ_SID_LFLG);

  /* Adjust Length, Flags and Value depending on the type of Label */

  if (value_type == SID_LABEL) {

    SET_FLAG(flags, EXT_SUBTLV_LINK_ADJ_SID_VFLG);

    TLV_LEN(exti->lan_sid[index]) =

      htons(SID_LABEL_SIZE(EXT_SUBTLV_PREFIX_RANGE_SIZE));

    exti->lan_sid[index].value = htonl(SET_LABEL(value));

  } else {

    UNSET_FLAG(flags, EXT_SUBTLV_LINK_ADJ_SID_VFLG);

    TLV_LEN(exti->lan_sid[index]) =

      htons(SID_INDEX_SIZE(EXT_SUBTLV_PREFIX_RANGE_SIZE));

    exti->lan_sid[index].value = htonl(value);

  }

  exti->lan_sid[index].flags = flags; /* Set computed flags */

  exti->lan_sid[index].mtid = 0;   /* Multi-Topology is not supported */

  exti->lan_sid[index].weight = 0; /* Load-Balancing is not supported */

  exti->lan_sid[index].neighbor_id = neighbor_id;

}

static void unset_adjacency_sid(struct ext_itf *exti)

{

  /* Reset Adjacency TLV */

  if (exti->type == ADJ_SID) {

    TLV_TYPE(exti->adj_sid[0]) = 0;

    TLV_TYPE(exti->adj_sid[1]) = 0;

  }

  /* or Lan-Adjacency TLV */

  if (exti->type == LAN_ADJ_SID) {

    TLV_TYPE(exti->lan_sid[0]) = 0;

    TLV_TYPE(exti->lan_sid[1]) = 0;

  }

}

/* Experimental SubTLV from Cisco */

static void set_rmt_itf_addr(struct ext_itf *exti, struct in_addr rmtif)

{

  TLV_TYPE(exti->rmt_itf_addr) = htons(EXT_SUBTLV_RMT_ITF_ADDR);

  TLV_LEN(exti->rmt_itf_addr) = htons(sizeof(struct in_addr));

  exti->rmt_itf_addr.value = rmtif;

}

/* Delete Extended LSA */

static void ospf_extended_lsa_delete(struct ext_itf *exti)

{

  /* Avoid deleting LSA if Extended is not enable */

  if (!OspfEXT.enabled)

    return;

  /* Process only Active Extended Prefix/Link LSA */

  if (!CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE))

    return;

  osr_debug("EXT (%s): Disable %s%s%s-SID on interface %s", __func__,

      exti->stype == LOCAL_SID ? "Prefix" : "",

      exti->stype == ADJ_SID ? "Adjacency" : "",

      exti->stype == LAN_ADJ_SID ? "LAN-Adjacency" : "",

      exti->ifp->name);

  /* Flush LSA if already engaged */

  if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED)) {

    ospf_ext_lsa_schedule(exti, FLUSH_THIS_LSA);

    UNSET_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED);

  }

  /* De-activate this Extended Prefix/Link and remove corresponding

   * Segment-Routing Prefix-SID or (LAN)-ADJ-SID */

  if (exti->stype == ADJ_SID || exti->stype == LAN_ADJ_SID)

    ospf_ext_link_delete_adj_sid(exti);

  else

    ospf_sr_ext_itf_delete(exti);

}

/*

 * Update Extended prefix SID index for Loopback interface type

 *

 * @param ifname - Loopback interface name

 * @param index - new value for the prefix SID of this interface

 * @param p - prefix for this interface or NULL if Extended Prefix

 * should be remove

 *

 * @return instance number if update is OK, 0 otherwise

 */

uint32_t ospf_ext_schedule_prefix_index(struct interface *ifp, uint32_t index,

          struct prefix_ipv4 *p, uint8_t flags)

{

  int rc = 0;

  struct ext_itf *exti;

  /* Find Extended Prefix interface */

  exti = lookup_ext_by_ifp(ifp);

  if (exti == NULL)

    return rc;

  if (p != NULL) {

    osr_debug("EXT (%s): Schedule new prefix %pFX with index %u on interface %s", __func__, p, index, ifp->name);

    /* Set first Extended Prefix then the Prefix SID information */

    set_ext_prefix(exti, OSPF_PATH_INTRA_AREA, EXT_TLV_PREF_NFLG,

             *p);

    set_prefix_sid(exti, SR_ALGORITHM_SPF, index, SID_INDEX, flags);

    /* Try to Schedule LSA */

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE)) {

      if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

        ospf_ext_pref_lsa_schedule(exti,

                 REFRESH_THIS_LSA);

      else

        ospf_ext_pref_lsa_schedule(

          exti, REORIGINATE_THIS_LSA);

    }

  } else {

    osr_debug("EXT (%s): Remove prefix for interface %s", __func__,

        ifp->name);

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

      ospf_ext_pref_lsa_schedule(exti, FLUSH_THIS_LSA);

  }

  return SET_OPAQUE_LSID(exti->type, exti->instance);

}

/**

 * Update Adjacecny-SID for Extended Link LSA

 *

 * @param exti  Extended Link information

 */

static void ospf_ext_link_update_adj_sid(struct ext_itf *exti)

{

  mpls_label_t label;

  mpls_label_t bck_label;

  /* Process only (LAN)Adjacency-SID Type */

  if (exti->stype != ADJ_SID && exti->stype != LAN_ADJ_SID)

    return;

  /* Request Primary & Backup Labels from Label Manager */

  bck_label = ospf_sr_local_block_request_label();

  label = ospf_sr_local_block_request_label();

  if (bck_label == MPLS_INVALID_LABEL || label == MPLS_INVALID_LABEL) {

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

      ospf_ext_lsa_schedule(exti, FLUSH_THIS_LSA);

    return;

  }

  /* Set Adjacency-SID, backup first */

  if (exti->stype == ADJ_SID) {

    set_adj_sid(exti, true, bck_label, SID_LABEL);

    set_adj_sid(exti, false, label, SID_LABEL);

  } else {

    set_lan_adj_sid(exti, true, bck_label, SID_LABEL,

        exti->lan_sid[0].neighbor_id);

    set_lan_adj_sid(exti, false, label, SID_LABEL,

        exti->lan_sid[1].neighbor_id);

  }

  /* Finally, add corresponding SR Link in SRDB & MPLS LFIB */

  SET_FLAG(exti->flags, EXT_LPFLG_FIB_ENTRY_SET);

  ospf_sr_ext_itf_add(exti);

}

/**

 * Delete Adjacecny-SID for Extended Link LSA

 *

 * @param exti  Extended Link information

 */

static void ospf_ext_link_delete_adj_sid(struct ext_itf *exti)

{

  /* Process only (LAN)Adjacency-SID Type */

  if (exti->stype != ADJ_SID && exti->stype != LAN_ADJ_SID)

    return;

  /* Release Primary & Backup Labels from Label Manager */

  if (exti->stype == ADJ_SID) {

    ospf_sr_local_block_release_label(exti->adj_sid[0].value);

    ospf_sr_local_block_release_label(exti->adj_sid[1].value);

  } else {

    ospf_sr_local_block_release_label(exti->lan_sid[0].value);

    ospf_sr_local_block_release_label(exti->lan_sid[1].value);

  }

  /* And reset corresponding TLV */

  unset_adjacency_sid(exti);

  /* Finally, remove corresponding SR Link in SRDB & MPLS LFIB */

  UNSET_FLAG(exti->flags, EXT_LPFLG_FIB_ENTRY_SET);

  ospf_sr_ext_itf_delete(exti);

}

/**

 * Update Extended Link LSA once Segment Routing Label Block has been changed.

 */

void ospf_ext_link_srlb_update(void)

{

  struct listnode *node;

  struct ext_itf *exti;

  osr_debug("EXT (%s): Update Extended Links with new SRLB", __func__);

  /* Update all Extended Link Adjaceny-SID  */

  for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti)) {

    /* Skip Extended Prefix */

    if (exti->stype == PREF_SID || exti->stype == LOCAL_SID)

      continue;

    /* Skip inactive Extended Link */

    if (!CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE))

      continue;

    ospf_ext_link_update_adj_sid(exti);

  }

}

/*

 * Used by Segment Routing to activate/deactivate Extended Link/Prefix flooding

 *

 * @param enable To activate or not Segment Routing Extended LSA flooding

 *

 * @return none

 */

void ospf_ext_update_sr(bool enable)

{

  struct listnode *node;

  struct ext_itf *exti;

  osr_debug("EXT (%s): %s Extended LSAs for Segment Routing ", __func__,

      enable ? "Enable" : "Disable");

  if (enable) {

    OspfEXT.enabled = true;

    /* Refresh LSAs if already engaged or originate */

    for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti)) {

      /* Skip Inactive Extended Link */

      if (!CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE))

        continue;

      /* Update Extended Link (LAN)Adj-SID if not set  */

      if (!CHECK_FLAG(exti->flags, EXT_LPFLG_FIB_ENTRY_SET))

        ospf_ext_link_update_adj_sid(exti);

      /* Finally, flood the extended Link */

      if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

        ospf_ext_lsa_schedule(exti, REFRESH_THIS_LSA);

      else

        ospf_ext_lsa_schedule(exti,

                  REORIGINATE_THIS_LSA);

    }

  } else {

    /* Start by Removing Extended LSA */

    for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti))

      ospf_extended_lsa_delete(exti);

    /* And then disable Extended Link/Prefix */

    OspfEXT.enabled = false;

  }

}

/*

 * -----------------------------------------------------------------------

 * Following are callback functions against generic Opaque-LSAs handling

 * -----------------------------------------------------------------------

 */

/* Add new Interface in Extended Interface List */

static int ospf_ext_link_new_if(struct interface *ifp)

{

  struct ext_itf *new;

  int rc = -1;

  if (lookup_ext_by_ifp(ifp) != NULL) {

    rc = 0; /* Do nothing here. */

    return rc;

  }

  new = XCALLOC(MTYPE_OSPF_EXT_PARAMS, sizeof(struct ext_itf));

  /* initialize new information and link back the interface */

  new->ifp = ifp;

  new->flags = EXT_LPFLG_LSA_INACTIVE;

  listnode_add(OspfEXT.iflist, new);

  rc = 0;

  return rc;

}

/* Remove existing Interface from Extended Interface List */

static int ospf_ext_link_del_if(struct interface *ifp)

{

  struct ext_itf *exti;

  int rc = -1;

  exti = lookup_ext_by_ifp(ifp);

  if (exti != NULL) {

    /* Flush LSA and remove Adjacency SID */

    ospf_extended_lsa_delete(exti);

    /* Dequeue listnode entry from the list. */

    listnode_delete(OspfEXT.iflist, exti);

    XFREE(MTYPE_OSPF_EXT_PARAMS, exti);

    rc = 0;

  } else {

    flog_warn(EC_OSPF_EXT_LSA_UNEXPECTED,

        "EXT (%s): interface %s is not found", __func__,

        ifp ? ifp->name : "-");

  }

  return rc;

}

/*

 * Determine if an Interface belongs to an Extended Link Adjacency or

 * Extended Prefix SID type and allocate new instance value accordingly

 */

static void ospf_ext_ism_change(struct ospf_interface *oi, int old_status)

{

  struct ext_itf *exti;

  /* Get interface information for Segment Routing */

  exti = lookup_ext_by_ifp(oi->ifp);

  if (exti == NULL) {

    flog_warn(EC_OSPF_EXT_LSA_UNEXPECTED,

        "EXT (%s): Cannot get Extended info. from OI(%s)",

        __func__, IF_NAME(oi));

    return;

  }

  /* Reset Extended information if ospf interface goes Down */

  if (oi->state == ISM_Down) {

    ospf_extended_lsa_delete(exti);

    exti->area = NULL;

    exti->flags = EXT_LPFLG_LSA_INACTIVE;

    return;

  }

  /* Determine if interface is related to a Prefix or an Adjacency SID */

  if (oi->type == OSPF_IFTYPE_LOOPBACK) {

    exti->stype = PREF_SID;

    exti->type = OPAQUE_TYPE_EXTENDED_PREFIX_LSA;

    exti->instance = get_ext_pref_instance_value();

    exti->area = oi->area;

    /* Complete SRDB if the interface belongs to a Prefix */

    if (OspfEXT.enabled) {

      osr_debug("EXT (%s): Set Prefix SID to interface %s ",

          __func__, oi->ifp->name);

      ospf_sr_update_local_prefix(oi->ifp, oi->address);

    }

  } else {

    /* Determine if interface is related to Adj. or LAN Adj. SID */

    if (oi->state == ISM_DR)

      exti->stype = LAN_ADJ_SID;

    else

      exti->stype = ADJ_SID;

    exti->type = OPAQUE_TYPE_EXTENDED_LINK_LSA;

    exti->instance = get_ext_link_instance_value();

    exti->area = oi->area;

    /*

     * Note: Adjacency SID information are completed when ospf

     * adjacency become up see ospf_ext_link_nsm_change()

     */

    if (OspfEXT.enabled)

      osr_debug(

        "EXT (%s): Set %sAdjacency SID for interface %s ",

        __func__, exti->stype == ADJ_SID ? "" : "LAN-",

        oi->ifp->name);

  }

}

/*

 * Finish Extended Link configuration and flood corresponding LSA

 * when OSPF adjacency on this link fire up

 */

static void ospf_ext_link_nsm_change(struct ospf_neighbor *nbr, int old_status)

{

  struct ospf_interface *oi = nbr->oi;

  struct ext_itf *exti;

  /* Process Link only when neighbor old or new state is NSM Full */

  if (nbr->state != NSM_Full && old_status != NSM_Full)

    return;

  /* Get interface information for Segment Routing */

  exti = lookup_ext_by_ifp(oi->ifp);

  if (exti == NULL) {

    flog_warn(EC_OSPF_EXT_LSA_UNEXPECTED,

        "EXT (%s): Cannot get Extended info. from OI(%s)",

        __func__, IF_NAME(oi));

    return;

  }

  /* Check that we have a valid area and ospf context */

  if (oi->area == NULL || oi->area->ospf == NULL) {

    flog_warn(EC_OSPF_EXT_LSA_UNEXPECTED,

        "EXT (%s): Cannot refer to OSPF from OI(%s)",

        __func__, IF_NAME(oi));

    return;

  }

  /* Remove Extended Link if Neighbor State goes Down or Deleted */

  if (OspfEXT.enabled

      && (nbr->state == NSM_Down || nbr->state == NSM_Deleted)) {

    ospf_ext_link_delete_adj_sid(exti);

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

      ospf_ext_link_lsa_schedule(exti, FLUSH_THIS_LSA);

    exti->flags = EXT_LPFLG_LSA_INACTIVE;

    return;

  }

  /* Keep Area information in combination with SR info. */

  exti->area = oi->area;

  /* Process only Adjacency/LAN SID */

  if (exti->stype == PREF_SID)

    return;

  switch (oi->state) {

  case ISM_PointToPoint:

    /* Segment ID is an Adjacency one */

    exti->stype = ADJ_SID;

    /* Set Extended Link TLV with link_id == Nbr Router ID */

    set_ext_link(exti, OSPF_IFTYPE_POINTOPOINT, nbr->router_id,

           oi->address->u.prefix4);

    /* And Remote Interface address */

    set_rmt_itf_addr(exti, nbr->address.u.prefix4);

    break;

  case ISM_DR:

    /* Segment ID is a LAN Adjacency for the DR only */

    exti->stype = LAN_ADJ_SID;

    /* Set Extended Link TLV with link_id == DR */

    set_ext_link(exti, OSPF_IFTYPE_BROADCAST, DR(oi),

           oi->address->u.prefix4);

    /* Set Neighbor ID */

    exti->lan_sid[0].neighbor_id = nbr->router_id;

    exti->lan_sid[1].neighbor_id = nbr->router_id;

    break;

  case ISM_DROther:

  case ISM_Backup:

    /* Segment ID is an Adjacency if not the DR */

    exti->stype = ADJ_SID;

    /* Set Extended Link TLV with link_id == DR */

    set_ext_link(exti, OSPF_IFTYPE_BROADCAST, DR(oi),

           oi->address->u.prefix4);

    break;

  default:

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_FIB_ENTRY_SET))

      ospf_ext_link_delete_adj_sid(exti);

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

      ospf_ext_link_lsa_schedule(exti, FLUSH_THIS_LSA);

    exti->flags = EXT_LPFLG_LSA_INACTIVE;

    return;

  }

  SET_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE);

  if (OspfEXT.enabled) {

    osr_debug("EXT (%s): Set %sAdjacency SID for interface %s ",

        __func__, exti->stype == ADJ_SID ? "" : "LAN-",

        oi->ifp->name);

    /* Update (LAN)Adjacency SID */

    ospf_ext_link_update_adj_sid(exti);

    /* flood this links params if everything is ok */

    if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED))

      ospf_ext_link_lsa_schedule(exti, REFRESH_THIS_LSA);

    else

      ospf_ext_link_lsa_schedule(exti, REORIGINATE_THIS_LSA);

  }

}

/* Callbacks to handle Extended Link Segment Routing LSA information */

static int ospf_ext_link_lsa_update(struct ospf_lsa *lsa)

{

  /* Sanity Check */

  if (lsa == NULL) {

    flog_warn(EC_OSPF_LSA_NULL, "EXT (%s): Abort! LSA is NULL",

        __func__);

    return -1;

  }

  /* Process only Opaque LSA */

  if ((lsa->data->type != OSPF_OPAQUE_AREA_LSA)

      && (lsa->data->type != OSPF_OPAQUE_AS_LSA))

    return 0;

  /* Process only Extended Link LSA */

  if (GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr))

      != OPAQUE_TYPE_EXTENDED_LINK_LSA)

    return 0;

  /* Check if it is not my LSA */

  if (IS_LSA_SELF(lsa))

    return 0;

  /* Check if Extended is enable */

  if (!OspfEXT.enabled)

    return 0;