lib/nexthop.c

   1 /* A generic nexthop structure
   2  * Copyright (C) 2013 Cumulus Networks, Inc.
   3  *
   4  * This file is part of Quagga.
   5  *
   6  * Quagga is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * Quagga is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Quagga; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21 #include <zebra.h>
  22
  23 #include "prefix.h"
  24 #include "table.h"
  25 #include "memory.h"
  26 #include "command.h"
  27 #include "if.h"
  28 #include "log.h"
  29 #include "sockunion.h"
  30 #include "linklist.h"
  31 #include "thread.h"
  32 #include "prefix.h"
  33 #include "nexthop.h"
  34 #include "mpls.h"
  35
  36 DEFINE_MTYPE_STATIC(LIB, NEXTHOP,       "Nexthop")
  37 DEFINE_MTYPE_STATIC(LIB, NH_LABEL,      "Nexthop label")
  38
  39 /* check if nexthops are same, non-recursive */
  40 int
  41 nexthop_same_no_recurse (struct nexthop *next1, struct nexthop *next2)
  42 {
  43   if (next1->type != next2->type)
  44     return 0;
  45
  46   switch (next1->type)
  47     {
  48     case NEXTHOP_TYPE_IPV4:
  49     case NEXTHOP_TYPE_IPV4_IFINDEX:
  50       if (! IPV4_ADDR_SAME (&next1->gate.ipv4, &next2->gate.ipv4))
  51         return 0;
  52       if (next1->ifindex && (next1->ifindex != next2->ifindex))
  53         return 0;
  54       break;
  55     case NEXTHOP_TYPE_IFINDEX:
  56       if (next1->ifindex != next2->ifindex)
  57         return 0;
  58       break;
  59     case NEXTHOP_TYPE_IPV6:
  60       if (! IPV6_ADDR_SAME (&next1->gate.ipv6, &next2->gate.ipv6))
  61         return 0;
  62       break;
  63     case NEXTHOP_TYPE_IPV6_IFINDEX:
  64       if (! IPV6_ADDR_SAME (&next1->gate.ipv6, &next2->gate.ipv6))
  65         return 0;
  66       if (next1->ifindex != next2->ifindex)
  67         return 0;
  68       break;
  69     default:
  70       /* do nothing */
  71       break;
  72     }
  73   return 1;
  74 }
  75
  76 /*
  77  * nexthop_type_to_str
  78  */
  79 const char *
  80 nexthop_type_to_str (enum nexthop_types_t nh_type)
  81 {
  82   static const char *desc[] = {
  83     "none",
  84     "Directly connected",
  85     "Interface route",
  86     "IPv4 nexthop",
  87     "IPv4 nexthop with ifindex",
  88     "IPv6 nexthop",
  89     "IPv6 nexthop with ifindex",
  90     "Null0 nexthop",
  91   };
  92
  93   return desc[nh_type];
  94 }
  95
  96 struct nexthop *
  97 nexthop_new (void)
  98 {
  99   return XCALLOC (MTYPE_NEXTHOP, sizeof (struct nexthop));
 100 }
 101
 102 /* Add nexthop to the end of a nexthop list.  */
 103 void
 104 nexthop_add (struct nexthop **target, struct nexthop *nexthop)
 105 {
 106   struct nexthop *last;
 107
 108   for (last = *target; last && last->next; last = last->next)
 109     ;
 110   if (last)
 111     last->next = nexthop;
 112   else
 113     *target = nexthop;
 114   nexthop->prev = last;
 115 }
 116
 117 void
 118 copy_nexthops (struct nexthop **tnh, struct nexthop *nh)
 119 {
 120   struct nexthop *nexthop;
 121   struct nexthop *nh1;
 122
 123   for (nh1 = nh; nh1; nh1 = nh1->next)
 124     {
 125       nexthop = nexthop_new();
 126       nexthop->flags = nh->flags;
 127       nexthop->type = nh->type;
 128       nexthop->ifindex = nh->ifindex;
 129       memcpy(&(nexthop->gate), &(nh->gate), sizeof(union g_addr));
 130       memcpy(&(nexthop->src), &(nh->src), sizeof(union g_addr));
 131       if (nh->nh_label)
 132         nexthop_add_labels (nexthop, nh->nh_label_type,
 133                             nh->nh_label->num_labels, &nh->nh_label->label[0]);
 134       nexthop_add(tnh, nexthop);
 135
 136       if (CHECK_FLAG(nh1->flags, NEXTHOP_FLAG_RECURSIVE))
 137         copy_nexthops(&nexthop->resolved, nh1->resolved);
 138     }
 139 }
 140
 141 /* Free nexthop. */
 142 void
 143 nexthop_free (struct nexthop *nexthop)
 144 {
 145   nexthop_del_labels (nexthop);
 146   if (nexthop->resolved)
 147     nexthops_free(nexthop->resolved);
 148   XFREE (MTYPE_NEXTHOP, nexthop);
 149 }
 150
 151 /* Frees a list of nexthops */
 152 void
 153 nexthops_free (struct nexthop *nexthop)
 154 {
 155   struct nexthop *nh, *next;
 156
 157   for (nh = nexthop; nh; nh = next)
 158     {
 159       next = nh->next;
 160       nexthop_free (nh);
 161     }
 162 }
 163
 164 /* Update nexthop with label information. */
 165 void
 166 nexthop_add_labels (struct nexthop *nexthop, enum lsp_types_t type,
 167                     u_int8_t num_labels, mpls_label_t *label)
 168 {
 169   struct nexthop_label *nh_label;
 170   int i;
 171
 172   nexthop->nh_label_type = type;
 173   nh_label = XCALLOC (MTYPE_NH_LABEL, sizeof (struct nexthop_label) +
 174                       num_labels * sizeof (mpls_label_t));
 175   nh_label->num_labels = num_labels;
 176   for (i = 0; i < num_labels; i++)
 177     nh_label->label[i] = *(label + i);
 178   nexthop->nh_label = nh_label;
 179 }
 180
 181 /* Free label information of nexthop, if present. */
 182 void
 183 nexthop_del_labels (struct nexthop *nexthop)
 184 {
 185   if (nexthop->nh_label)
 186     {
 187       XFREE (MTYPE_NH_LABEL, nexthop->nh_label);
 188       nexthop->nh_label_type = ZEBRA_LSP_NONE;
 189     }
 190 }
 191
 192 const char *
 193 nexthop2str (struct nexthop *nexthop, char *str, int size)
 194 {
 195   switch (nexthop->type)
 196     {
 197       case NEXTHOP_TYPE_IFINDEX:
 198         snprintf (str, size, "if %u", nexthop->ifindex);
 199         break;
 200       case NEXTHOP_TYPE_IPV4:
 201         snprintf (str, size, "%s", inet_ntoa (nexthop->gate.ipv4));
 202         break;
 203       case NEXTHOP_TYPE_IPV4_IFINDEX:
 204         snprintf (str, size, "%s if %u",
 205                   inet_ntoa (nexthop->gate.ipv4), nexthop->ifindex);
 206         break;
 207       case NEXTHOP_TYPE_IPV6:
 208         snprintf (str, size, "%s", inet6_ntoa (nexthop->gate.ipv6));
 209         break;
 210       case NEXTHOP_TYPE_IPV6_IFINDEX:
 211         snprintf (str, size, "%s if %u",
 212                   inet6_ntoa (nexthop->gate.ipv6), nexthop->ifindex);
 213         break;
 214       case NEXTHOP_TYPE_BLACKHOLE:
 215         snprintf (str, size, "blackhole");
 216         break;
 217       default:
 218         snprintf (str, size, "unknown");
 219         break;
 220     }
 221
 222   return str;
 223 }