zebra/zebra_fpm_netlink.c

   1 /*
   2  * Code for encoding/decoding FPM messages that are in netlink format.
   3  *
   4  * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
   5  * Copyright (C) 2012 by Open Source Routing.
   6  * Copyright (C) 2012 by Internet Systems Consortium, Inc. ("ISC")
   7  *
   8  * This file is part of GNU Zebra.
   9  *
  10  * GNU Zebra is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by the
  12  * Free Software Foundation; either version 2, or (at your option) any
  13  * later version.
  14  *
  15  * GNU Zebra is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; see the file COPYING; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <zebra.h>
  26
  27 #include "log.h"
  28 #include "rib.h"
  29 #include "vty.h"
  30 #include "prefix.h"
  31
  32 #include "zebra/zserv.h"
  33 #include "zebra/zebra_ns.h"
  34 #include "zebra/zebra_vrf.h"
  35 #include "zebra/kernel_netlink.h"
  36 #include "zebra/rt_netlink.h"
  37 #include "nexthop.h"
  38
  39 #include "zebra/zebra_fpm_private.h"
  40
  41 /*
  42  * addr_to_a
  43  *
  44  * Returns string representation of an address of the given AF.
  45  */
  46 static inline const char *
  47 addr_to_a (u_char af, void *addr)
  48 {
  49   if (!addr)
  50     return "<No address>";
  51
  52   switch (af)
  53     {
  54
  55     case AF_INET:
  56       return inet_ntoa (*((struct in_addr *) addr));
  57       break;
  58     case AF_INET6:
  59       return inet6_ntoa (*((struct in6_addr *) addr));
  60       break;
  61     default:
  62       return "<Addr in unknown AF>";
  63       break;
  64     }
  65 }
  66
  67 /*
  68  * prefix_addr_to_a
  69  *
  70  * Convience wrapper that returns a human-readable string for the
  71  * address in a prefix.
  72  */
  73 static const char *
  74 prefix_addr_to_a (struct prefix *prefix)
  75 {
  76   if (!prefix)
  77     return "<No address>";
  78
  79   return addr_to_a (prefix->family, &prefix->u.prefix);
  80 }
  81
  82 /*
  83  * af_addr_size
  84  *
  85  * The size of an address in a given address family.
  86  */
  87 static size_t
  88 af_addr_size (u_char af)
  89 {
  90   switch (af)
  91     {
  92
  93     case AF_INET:
  94       return 4;
  95       break;
  96     case AF_INET6:
  97       return 16;
  98       break;
  99     default:
 100       assert(0);
 101       return 16;
 102     }
 103 }
 104
 105 /*
 106  * netlink_nh_info_t
 107  *
 108  * Holds information about a single nexthop for netlink. These info
 109  * structures are transient and may contain pointers into rib
 110  * data structures for convenience.
 111  */
 112 typedef struct netlink_nh_info_t_
 113 {
 114   uint32_t if_index;
 115   union g_addr *gateway;
 116
 117   /*
 118    * Information from the struct nexthop from which this nh was
 119    * derived. For debug purposes only.
 120    */
 121   int recursive;
 122   enum nexthop_types_t type;
 123 } netlink_nh_info_t;
 124
 125 /*
 126  * netlink_route_info_t
 127  *
 128  * A structure for holding information for a netlink route message.
 129  */
 130 typedef struct netlink_route_info_t_
 131 {
 132   uint16_t nlmsg_type;
 133   u_char rtm_type;
 134   uint32_t rtm_table;
 135   u_char rtm_protocol;
 136   u_char af;
 137   struct prefix *prefix;
 138   uint32_t *metric;
 139   unsigned int num_nhs;
 140
 141   /*
 142    * Nexthop structures
 143    */
 144   netlink_nh_info_t nhs[MULTIPATH_NUM];
 145   union g_addr *pref_src;
 146 } netlink_route_info_t;
 147
 148 /*
 149  * netlink_route_info_add_nh
 150  *
 151  * Add information about the given nexthop to the given route info
 152  * structure.
 153  *
 154  * Returns TRUE if a nexthop was added, FALSE otherwise.
 155  */
 156 static int
 157 netlink_route_info_add_nh (netlink_route_info_t *ri, struct nexthop *nexthop,
 158                            int recursive)
 159 {
 160   netlink_nh_info_t nhi;
 161   union g_addr *src;
 162
 163   memset (&nhi, 0, sizeof (nhi));
 164   src = NULL;
 165
 166   if (ri->num_nhs >= (int) ZEBRA_NUM_OF (ri->nhs))
 167     return 0;
 168
 169   nhi.recursive = recursive;
 170   nhi.type = nexthop->type;
 171   nhi.if_index = nexthop->ifindex;
 172
 173   if (nexthop->type == NEXTHOP_TYPE_IPV4
 174       || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX)
 175     {
 176       nhi.gateway = &nexthop->gate;
 177       if (nexthop->src.ipv4.s_addr)
 178         src = &nexthop->src;
 179     }
 180
 181   if (nexthop->type == NEXTHOP_TYPE_IPV6
 182       || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX)
 183     {
 184       nhi.gateway = &nexthop->gate;
 185     }
 186
 187   if (nexthop->type == NEXTHOP_TYPE_IFINDEX)
 188     {
 189       if (nexthop->src.ipv4.s_addr)
 190         src = &nexthop->src;
 191     }
 192
 193   if (!nhi.gateway && nhi.if_index == 0)
 194     return 0;
 195
 196   /*
 197    * We have a valid nhi. Copy the structure over to the route_info.
 198    */
 199   ri->nhs[ri->num_nhs] = nhi;
 200   ri->num_nhs++;
 201
 202   if (src && !ri->pref_src)
 203     ri->pref_src = src;
 204
 205   return 1;
 206 }
 207
 208 /*
 209  * netlink_proto_from_route_type
 210  */
 211 static u_char
 212 netlink_proto_from_route_type (int type)
 213 {
 214   switch (type)
 215     {
 216     case ZEBRA_ROUTE_KERNEL:
 217     case ZEBRA_ROUTE_CONNECT:
 218       return RTPROT_KERNEL;
 219
 220     default:
 221       return RTPROT_ZEBRA;
 222     }
 223 }
 224
 225 /*
 226  * netlink_route_info_fill
 227  *
 228  * Fill out the route information object from the given route.
 229  *
 230  * Returns TRUE on success and FALSE on failure.
 231  */
 232 static int
 233 netlink_route_info_fill (netlink_route_info_t *ri, int cmd,
 234                          rib_dest_t *dest, struct route_entry *re)
 235 {
 236   struct nexthop *nexthop, *tnexthop;
 237   int recursing;
 238   int discard;
 239
 240   memset (ri, 0, sizeof (*ri));
 241
 242   ri->prefix = rib_dest_prefix (dest);
 243   ri->af = rib_dest_af (dest);
 244
 245   ri->nlmsg_type = cmd;
 246   ri->rtm_table = zvrf_id (rib_dest_vrf (dest));
 247   ri->rtm_protocol = RTPROT_UNSPEC;
 248
 249   /*
 250    * An RTM_DELROUTE need not be accompanied by any nexthops,
 251    * particularly in our communication with the FPM.
 252    */
 253   if (cmd == RTM_DELROUTE && !re)
 254     return 1;
 255
 256   if (!re)
 257     {
 258       zfpm_debug ("%s: Expected non-NULL re pointer", __PRETTY_FUNCTION__);
 259       return 0;
 260     }
 261
 262   ri->rtm_protocol = netlink_proto_from_route_type (re->type);
 263
 264   if ((re->flags & ZEBRA_FLAG_BLACKHOLE) || (re->flags & ZEBRA_FLAG_REJECT))
 265     discard = 1;
 266   else
 267     discard = 0;
 268
 269   if (cmd == RTM_NEWROUTE)
 270     {
 271       if (discard)
 272         {
 273           if (re->flags & ZEBRA_FLAG_BLACKHOLE)
 274             ri->rtm_type = RTN_BLACKHOLE;
 275           else if (re->flags & ZEBRA_FLAG_REJECT)
 276             ri->rtm_type = RTN_UNREACHABLE;
 277           else
 278             assert (0);
 279         }
 280       else
 281         ri->rtm_type = RTN_UNICAST;
 282     }
 283
 284   ri->metric = &re->metric;
 285
 286   if (discard)
 287     return 1;
 288
 289   for (ALL_NEXTHOPS_RO(re->nexthop, nexthop, tnexthop, recursing))
 290     {
 291       if (ri->num_nhs >= multipath_num)
 292         break;
 293
 294       if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 295         continue;
 296
 297       if ((cmd == RTM_NEWROUTE
 298            && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 299           || (cmd == RTM_DELROUTE
 300               && CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB)))
 301         {
 302           netlink_route_info_add_nh (ri, nexthop, recursing);
 303         }
 304     }
 305
 306   /* If there is no useful nexthop then return. */
 307   if (ri->num_nhs == 0)
 308     {
 309       zfpm_debug ("netlink_encode_route(): No useful nexthop.");
 310       return 0;
 311     }
 312
 313   return 1;
 314 }
 315
 316 /*
 317  * netlink_route_info_encode
 318  *
 319  * Returns the number of bytes written to the buffer. 0 or a negative
 320  * value indicates an error.
 321  */
 322 static int
 323 netlink_route_info_encode (netlink_route_info_t *ri, char *in_buf,
 324                            size_t in_buf_len)
 325 {
 326   size_t bytelen;
 327   unsigned int nexthop_num = 0;
 328   size_t buf_offset;
 329   netlink_nh_info_t *nhi;
 330
 331   struct
 332   {
 333     struct nlmsghdr n;
 334     struct rtmsg r;
 335     char buf[1];
 336   } *req;
 337
 338   req = (void *) in_buf;
 339
 340   buf_offset = ((char *) req->buf) - ((char *) req);
 341
 342   if (in_buf_len < buf_offset) {
 343     assert(0);
 344     return 0;
 345   }
 346
 347   memset (req, 0, buf_offset);
 348
 349   bytelen = af_addr_size (ri->af);
 350
 351   req->n.nlmsg_len = NLMSG_LENGTH (sizeof (struct rtmsg));
 352   req->n.nlmsg_flags = NLM_F_CREATE | NLM_F_REQUEST;
 353   req->n.nlmsg_type = ri->nlmsg_type;
 354   req->r.rtm_family = ri->af;
 355   req->r.rtm_table = ri->rtm_table;
 356   req->r.rtm_dst_len = ri->prefix->prefixlen;
 357   req->r.rtm_protocol = ri->rtm_protocol;
 358   req->r.rtm_scope = RT_SCOPE_UNIVERSE;
 359
 360   addattr_l (&req->n, in_buf_len, RTA_DST, &ri->prefix->u.prefix, bytelen);
 361
 362   req->r.rtm_type = ri->rtm_type;
 363
 364   /* Metric. */
 365   if (ri->metric)
 366     addattr32 (&req->n, in_buf_len, RTA_PRIORITY, *ri->metric);
 367
 368   if (ri->num_nhs == 0)
 369     goto done;
 370
 371   if (ri->num_nhs == 1)
 372     {
 373       nhi = &ri->nhs[0];
 374
 375       if (nhi->gateway)
 376         {
 377           addattr_l (&req->n, in_buf_len, RTA_GATEWAY, nhi->gateway,
 378                      bytelen);
 379         }
 380
 381       if (nhi->if_index)
 382         {
 383           addattr32 (&req->n, in_buf_len, RTA_OIF, nhi->if_index);
 384         }
 385
 386       goto done;
 387
 388     }
 389
 390   /*
 391    * Multipath case.
 392    */
 393   char buf[NL_PKT_BUF_SIZE];
 394   struct rtattr *rta = (void *) buf;
 395   struct rtnexthop *rtnh;
 396
 397   rta->rta_type = RTA_MULTIPATH;
 398   rta->rta_len = RTA_LENGTH (0);
 399   rtnh = RTA_DATA (rta);
 400
 401   for (nexthop_num = 0; nexthop_num < ri->num_nhs; nexthop_num++)
 402     {
 403       nhi = &ri->nhs[nexthop_num];
 404
 405       rtnh->rtnh_len = sizeof (*rtnh);
 406       rtnh->rtnh_flags = 0;
 407       rtnh->rtnh_hops = 0;
 408       rtnh->rtnh_ifindex = 0;
 409       rta->rta_len += rtnh->rtnh_len;
 410
 411       if (nhi->gateway)
 412         {
 413           rta_addattr_l (rta, sizeof (buf), RTA_GATEWAY, nhi->gateway, bytelen);
 414           rtnh->rtnh_len += sizeof (struct rtattr) + bytelen;
 415         }
 416
 417       if (nhi->if_index)
 418         {
 419           rtnh->rtnh_ifindex = nhi->if_index;
 420         }
 421
 422       rtnh = RTNH_NEXT (rtnh);
 423     }
 424
 425   assert (rta->rta_len > RTA_LENGTH (0));
 426   addattr_l (&req->n, in_buf_len, RTA_MULTIPATH, RTA_DATA (rta),
 427              RTA_PAYLOAD (rta));
 428
 429 done:
 430
 431   if (ri->pref_src)
 432     {
 433       addattr_l (&req->n, in_buf_len, RTA_PREFSRC, &ri->pref_src, bytelen);
 434     }
 435
 436   assert (req->n.nlmsg_len < in_buf_len);
 437   return req->n.nlmsg_len;
 438 }
 439
 440 /*
 441  * zfpm_log_route_info
 442  *
 443  * Helper function to log the information in a route_info structure.
 444  */
 445 static void
 446 zfpm_log_route_info (netlink_route_info_t *ri, const char *label)
 447 {
 448   netlink_nh_info_t *nhi;
 449   unsigned int i;
 450
 451   zfpm_debug ("%s : %s %s/%d, Proto: %s, Metric: %u", label,
 452               nl_msg_type_to_str (ri->nlmsg_type),
 453               prefix_addr_to_a (ri->prefix), ri->prefix->prefixlen,
 454               nl_rtproto_to_str (ri->rtm_protocol),
 455               ri->metric ? *ri->metric : 0);
 456
 457   for (i = 0; i < ri->num_nhs; i++)
 458     {
 459       nhi = &ri->nhs[i];
 460       zfpm_debug("  Intf: %u, Gateway: %s, Recursive: %s, Type: %s",
 461                  nhi->if_index, addr_to_a (ri->af, nhi->gateway),
 462                  nhi->recursive ? "yes" : "no",
 463                  nexthop_type_to_str (nhi->type));
 464     }
 465 }
 466
 467 /*
 468  * zfpm_netlink_encode_route
 469  *
 470  * Create a netlink message corresponding to the given route in the
 471  * given buffer space.
 472  *
 473  * Returns the number of bytes written to the buffer. 0 or a negative
 474  * value indicates an error.
 475  */
 476 int
 477 zfpm_netlink_encode_route (int cmd, rib_dest_t *dest, struct route_entry *re,
 478                            char *in_buf, size_t in_buf_len)
 479 {
 480   netlink_route_info_t ri_space, *ri;
 481
 482   ri = &ri_space;
 483
 484   if (!netlink_route_info_fill (ri, cmd, dest, re))
 485     return 0;
 486
 487   zfpm_log_route_info (ri, __FUNCTION__);
 488
 489   return netlink_route_info_encode (ri, in_buf, in_buf_len);
 490 }