zebra/zebra_fpm_protobuf.c

   1 /*
   2  * zebra_fpm_protobuf.c
   3  *
   4  * @copyright Copyright (C) 2016 Sproute Networks, Inc.
   5  *
   6  * @author Avneesh Sachdev <avneesh@sproute.com>
   7  *
   8  * This file is part of Quagga.
   9  *
  10  * Quagga 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  * Quagga 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 #include <zebra.h>
  25
  26 #include "log.h"
  27 #include "rib.h"
  28 #include "zserv.h"
  29 #include "zebra_vrf.h"
  30
  31 #include "qpb/qpb.pb-c.h"
  32 #include "qpb/qpb.h"
  33 #include "qpb/qpb_allocator.h"
  34 #include "qpb/linear_allocator.h"
  35 #include "fpm/fpm_pb.h"
  36
  37 #include "zebra_fpm_private.h"
  38
  39 /*
  40  * create_delete_route_message
  41  */
  42 static Fpm__DeleteRoute *create_delete_route_message(qpb_allocator_t *allocator,
  43                                                      rib_dest_t *dest,
  44                                                      struct route_entry *re)
  45 {
  46         Fpm__DeleteRoute *msg;
  47
  48         msg = QPB_ALLOC(allocator, typeof(*msg));
  49         if (!msg) {
  50                 assert(0);
  51                 return NULL;
  52         }
  53
  54         fpm__delete_route__init(msg);
  55         msg->vrf_id = zvrf_id(rib_dest_vrf(dest));
  56
  57         qpb_address_family_set(&msg->address_family, rib_dest_af(dest));
  58
  59         /*
  60          * XXX Hardcode subaddress family for now.
  61          */
  62         msg->sub_address_family = QPB__SUB_ADDRESS_FAMILY__UNICAST;
  63         msg->key = fpm_route_key_create(allocator, rib_dest_prefix(dest));
  64         if (!msg->key) {
  65                 assert(0);
  66                 return NULL;
  67         }
  68
  69         return msg;
  70 }
  71
  72 /*
  73  * add_nexthop
  74  */
  75 static inline int add_nexthop(qpb_allocator_t *allocator, Fpm__AddRoute *msg,
  76                               rib_dest_t *dest, struct nexthop *nexthop)
  77 {
  78         uint32_t if_index;
  79         union g_addr *gateway, *src;
  80
  81         gateway = src = NULL;
  82
  83         if_index = nexthop->ifindex;
  84
  85         if (nexthop->type == NEXTHOP_TYPE_IPV4
  86             || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX) {
  87                 gateway = &nexthop->gate;
  88                 if (nexthop->src.ipv4.s_addr)
  89                         src = &nexthop->src;
  90         }
  91
  92         if (nexthop->type == NEXTHOP_TYPE_IPV6
  93             || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
  94                 gateway = &nexthop->gate;
  95         }
  96
  97         if (nexthop->type == NEXTHOP_TYPE_IFINDEX) {
  98                 if (nexthop->src.ipv4.s_addr)
  99                         src = &nexthop->src;
 100         }
 101
 102         if (!gateway && if_index == 0)
 103                 return 0;
 104
 105         /*
 106          * We have a valid nexthop.
 107          */
 108         {
 109                 Fpm__Nexthop *pb_nh;
 110                 pb_nh = QPB_ALLOC(allocator, typeof(*pb_nh));
 111                 if (!pb_nh) {
 112                         assert(0);
 113                         return 0;
 114                 }
 115
 116                 fpm__nexthop__init(pb_nh);
 117
 118                 if (if_index != 0) {
 119                         pb_nh->if_id =
 120                                 qpb_if_identifier_create(allocator, if_index);
 121                 }
 122
 123                 if (gateway) {
 124                         pb_nh->address = qpb_l3_address_create(
 125                                 allocator, gateway, rib_dest_af(dest));
 126                 }
 127
 128                 msg->nexthops[msg->n_nexthops++] = pb_nh;
 129         }
 130
 131         // TODO: Use src.
 132
 133         return 1;
 134 }
 135
 136 /*
 137  * create_add_route_message
 138  */
 139 static Fpm__AddRoute *create_add_route_message(qpb_allocator_t *allocator,
 140                                                rib_dest_t *dest,
 141                                                struct route_entry *re)
 142 {
 143         Fpm__AddRoute *msg;
 144         struct nexthop *nexthop;
 145         uint num_nhs, u;
 146         struct nexthop *nexthops[MULTIPATH_NUM];
 147
 148         msg = QPB_ALLOC(allocator, typeof(*msg));
 149         if (!msg) {
 150                 assert(0);
 151                 return NULL;
 152         }
 153
 154         fpm__add_route__init(msg);
 155
 156         msg->vrf_id = zvrf_id(rib_dest_vrf(dest));
 157
 158         qpb_address_family_set(&msg->address_family, rib_dest_af(dest));
 159
 160         /*
 161          * XXX Hardcode subaddress family for now.
 162          */
 163         msg->sub_address_family = QPB__SUB_ADDRESS_FAMILY__UNICAST;
 164         msg->key = fpm_route_key_create(allocator, rib_dest_prefix(dest));
 165         qpb_protocol_set(&msg->protocol, re->type);
 166         msg->has_route_type = 1;
 167         msg->route_type = FPM__ROUTE_TYPE__NORMAL;
 168         msg->metric = re->metric;
 169
 170         /*
 171          * Figure out the set of nexthops to be added to the message.
 172          */
 173         num_nhs = 0;
 174         for (ALL_NEXTHOPS(re->ng, nexthop)) {
 175                 if (num_nhs >= multipath_num)
 176                         break;
 177
 178                 if (num_nhs >= ZEBRA_NUM_OF(nexthops))
 179                         break;
 180
 181                 if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE) {
 182                         switch (nexthop->bh_type) {
 183                         case BLACKHOLE_REJECT:
 184                                 msg->route_type = FPM__ROUTE_TYPE__UNREACHABLE;
 185                                 break;
 186                         case BLACKHOLE_NULL:
 187                         default:
 188                                 msg->route_type = FPM__ROUTE_TYPE__BLACKHOLE;
 189                                 break;
 190                         }
 191                         return msg;
 192                 }
 193
 194                 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 195                         continue;
 196
 197                 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 198                         continue;
 199
 200                 nexthops[num_nhs] = nexthop;
 201                 num_nhs++;
 202         }
 203
 204         if (!num_nhs) {
 205                 zfpm_debug("netlink_encode_route(): No useful nexthop.");
 206                 assert(0);
 207                 return NULL;
 208         }
 209
 210         /*
 211          * And add them to the message.
 212          */
 213         if (!(msg->nexthops = qpb_alloc_ptr_array(allocator, num_nhs))) {
 214                 assert(0);
 215                 return NULL;
 216         }
 217
 218         msg->n_nexthops = 0;
 219         for (u = 0; u < num_nhs; u++) {
 220                 if (!add_nexthop(allocator, msg, dest, nexthops[u])) {
 221                         assert(0);
 222                         return NULL;
 223                 }
 224         }
 225
 226         assert(msg->n_nexthops == num_nhs);
 227
 228         return msg;
 229 }
 230
 231 /*
 232  * create_route_message
 233  */
 234 static Fpm__Message *create_route_message(qpb_allocator_t *allocator,
 235                                           rib_dest_t *dest,
 236                                           struct route_entry *re)
 237 {
 238         Fpm__Message *msg;
 239
 240         msg = QPB_ALLOC(allocator, typeof(*msg));
 241         if (!msg) {
 242                 assert(0);
 243                 return NULL;
 244         }
 245
 246         fpm__message__init(msg);
 247
 248         if (!re) {
 249                 msg->has_type = 1;
 250                 msg->type = FPM__MESSAGE__TYPE__DELETE_ROUTE;
 251                 msg->delete_route =
 252                         create_delete_route_message(allocator, dest, re);
 253                 if (!msg->delete_route) {
 254                         assert(0);
 255                         return NULL;
 256                 }
 257                 return msg;
 258         }
 259
 260         msg->has_type = 1;
 261         msg->type = FPM__MESSAGE__TYPE__ADD_ROUTE;
 262         msg->add_route = create_add_route_message(allocator, dest, re);
 263         if (!msg->add_route) {
 264                 assert(0);
 265                 return NULL;
 266         }
 267
 268         return msg;
 269 }
 270
 271 /*
 272  * zfpm_protobuf_encode_route
 273  *
 274  * Create a protobuf message corresponding to the given route in the
 275  * given buffer space.
 276  *
 277  * Returns the number of bytes written to the buffer. 0 or a negative
 278  * value indicates an error.
 279  */
 280 int zfpm_protobuf_encode_route(rib_dest_t *dest, struct route_entry *re,
 281                                uint8_t *in_buf, size_t in_buf_len)
 282 {
 283         Fpm__Message *msg;
 284         QPB_DECLARE_STACK_ALLOCATOR(allocator, 4096);
 285         size_t len;
 286
 287         QPB_INIT_STACK_ALLOCATOR(allocator);
 288
 289         msg = create_route_message(&allocator, dest, re);
 290         if (!msg) {
 291                 assert(0);
 292                 return 0;
 293         }
 294
 295         len = fpm__message__pack(msg, (uint8_t *)in_buf);
 296         assert(len <= in_buf_len);
 297
 298         QPB_RESET_STACK_ALLOCATOR(allocator);
 299         return len;
 300 }