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->route_type = FPM__ROUTE_TYPE__NORMAL;
 167         msg->metric = re->metric;
 168
 169         /*
 170          * Figure out the set of nexthops to be added to the message.
 171          */
 172         num_nhs = 0;
 173         for (ALL_NEXTHOPS(re->ng, nexthop)) {
 174                 if (num_nhs >= multipath_num)
 175                         break;
 176
 177                 if (num_nhs >= ZEBRA_NUM_OF(nexthops))
 178                         break;
 179
 180                 if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE) {
 181                         switch (nexthop->bh_type) {
 182                         case BLACKHOLE_REJECT:
 183                                 msg->route_type = FPM__ROUTE_TYPE__UNREACHABLE;
 184                                 break;
 185                         case BLACKHOLE_NULL:
 186                         default:
 187                                 msg->route_type = FPM__ROUTE_TYPE__BLACKHOLE;
 188                                 break;
 189                         }
 190                         return msg;
 191                 }
 192
 193                 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
 194                         continue;
 195
 196                 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
 197                         continue;
 198
 199                 nexthops[num_nhs] = nexthop;
 200                 num_nhs++;
 201         }
 202
 203         if (!num_nhs) {
 204                 zfpm_debug("netlink_encode_route(): No useful nexthop.");
 205                 assert(0);
 206                 return NULL;
 207         }
 208
 209         /*
 210          * And add them to the message.
 211          */
 212         if (!(msg->nexthops = qpb_alloc_ptr_array(allocator, num_nhs))) {
 213                 assert(0);
 214                 return NULL;
 215         }
 216
 217         msg->n_nexthops = 0;
 218         for (u = 0; u < num_nhs; u++) {
 219                 if (!add_nexthop(allocator, msg, dest, nexthops[u])) {
 220                         assert(0);
 221                         return NULL;
 222                 }
 223         }
 224
 225         assert(msg->n_nexthops == num_nhs);
 226
 227         return msg;
 228 }
 229
 230 /*
 231  * create_route_message
 232  */
 233 static Fpm__Message *create_route_message(qpb_allocator_t *allocator,
 234                                           rib_dest_t *dest,
 235                                           struct route_entry *re)
 236 {
 237         Fpm__Message *msg;
 238
 239         msg = QPB_ALLOC(allocator, typeof(*msg));
 240         if (!msg) {
 241                 assert(0);
 242                 return NULL;
 243         }
 244
 245         fpm__message__init(msg);
 246
 247         if (!re) {
 248                 msg->type = FPM__MESSAGE__TYPE__DELETE_ROUTE;
 249                 msg->delete_route =
 250                         create_delete_route_message(allocator, dest, re);
 251                 if (!msg->delete_route) {
 252                         assert(0);
 253                         return NULL;
 254                 }
 255                 return msg;
 256         }
 257
 258         msg->type = FPM__MESSAGE__TYPE__ADD_ROUTE;
 259         msg->add_route = create_add_route_message(allocator, dest, re);
 260         if (!msg->add_route) {
 261                 assert(0);
 262                 return NULL;
 263         }
 264
 265         return msg;
 266 }
 267
 268 /*
 269  * zfpm_protobuf_encode_route
 270  *
 271  * Create a protobuf message corresponding to the given route in the
 272  * given buffer space.
 273  *
 274  * Returns the number of bytes written to the buffer. 0 or a negative
 275  * value indicates an error.
 276  */
 277 int zfpm_protobuf_encode_route(rib_dest_t *dest, struct route_entry *re,
 278                                uint8_t *in_buf, size_t in_buf_len)
 279 {
 280         Fpm__Message *msg;
 281         QPB_DECLARE_STACK_ALLOCATOR(allocator, 4096);
 282         size_t len;
 283
 284         QPB_INIT_STACK_ALLOCATOR(allocator);
 285
 286         msg = create_route_message(&allocator, dest, re);
 287         if (!msg) {
 288                 assert(0);
 289                 return 0;
 290         }
 291
 292         len = fpm__message__pack(msg, (uint8_t *)in_buf);
 293         assert(len <= in_buf_len);
 294
 295         QPB_RESET_STACK_ALLOCATOR(allocator);
 296         return len;
 297 }