sharpd/sharp_zebra.c

   1 /*
   2  * Zebra connect code.
   3  * Copyright (C) Cumulus Networks, Inc.
   4  *               Donald Sharp
   5  *
   6  * This file is part of FRR.
   7  *
   8  * FRR is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * FRR is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; see the file COPYING; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22 #include <zebra.h>
  23
  24 #include "thread.h"
  25 #include "command.h"
  26 #include "network.h"
  27 #include "prefix.h"
  28 #include "routemap.h"
  29 #include "table.h"
  30 #include "stream.h"
  31 #include "memory.h"
  32 #include "zclient.h"
  33 #include "filter.h"
  34 #include "plist.h"
  35 #include "log.h"
  36 #include "nexthop.h"
  37
  38 #include "sharp_zebra.h"
  39
  40 /* Zebra structure to hold current status. */
  41 struct zclient *zclient = NULL;
  42
  43 /* For registering threads. */
  44 extern struct thread_master *master;
  45
  46 static struct interface *zebra_interface_if_lookup(struct stream *s)
  47 {
  48         char ifname_tmp[INTERFACE_NAMSIZ];
  49
  50         /* Read interface name. */
  51         stream_get(ifname_tmp, s, INTERFACE_NAMSIZ);
  52
  53         /* And look it up. */
  54         return if_lookup_by_name(ifname_tmp, VRF_DEFAULT);
  55 }
  56
  57 /* Inteface addition message from zebra. */
  58 static int interface_add(int command, struct zclient *zclient,
  59                          zebra_size_t length, vrf_id_t vrf_id)
  60 {
  61         struct interface *ifp;
  62
  63         ifp = zebra_interface_add_read(zclient->ibuf, vrf_id);
  64
  65         if (!ifp->info)
  66                 return 0;
  67
  68         return 0;
  69 }
  70
  71 static int interface_delete(int command, struct zclient *zclient,
  72                             zebra_size_t length, vrf_id_t vrf_id)
  73 {
  74         struct interface *ifp;
  75         struct stream *s;
  76
  77         s = zclient->ibuf;
  78         /* zebra_interface_state_read () updates interface structure in iflist
  79          */
  80         ifp = zebra_interface_state_read(s, vrf_id);
  81
  82         if (ifp == NULL)
  83                 return 0;
  84
  85         if_set_index(ifp, IFINDEX_INTERNAL);
  86
  87         return 0;
  88 }
  89
  90 static int interface_address_add(int command, struct zclient *zclient,
  91                                  zebra_size_t length, vrf_id_t vrf_id)
  92 {
  93
  94         zebra_interface_address_read(command, zclient->ibuf, vrf_id);
  95
  96         return 0;
  97 }
  98
  99 static int interface_address_delete(int command, struct zclient *zclient,
 100                                     zebra_size_t length, vrf_id_t vrf_id)
 101 {
 102         struct connected *c;
 103
 104         c = zebra_interface_address_read(command, zclient->ibuf, vrf_id);
 105
 106         if (!c)
 107                 return 0;
 108
 109         connected_free(c);
 110         return 0;
 111 }
 112
 113 static int interface_state_up(int command, struct zclient *zclient,
 114                               zebra_size_t length, vrf_id_t vrf_id)
 115 {
 116
 117         zebra_interface_if_lookup(zclient->ibuf);
 118
 119         return 0;
 120 }
 121
 122 static int interface_state_down(int command, struct zclient *zclient,
 123                                 zebra_size_t length, vrf_id_t vrf_id)
 124 {
 125
 126         zebra_interface_state_read(zclient->ibuf, vrf_id);
 127
 128         return 0;
 129 }
 130
 131 extern uint32_t total_routes;
 132 extern uint32_t installed_routes;
 133
 134 static int route_notify_owner(int command, struct zclient *zclient,
 135                               zebra_size_t length, vrf_id_t vrf_id)
 136 {
 137         struct prefix p;
 138         enum zapi_route_notify_owner note;
 139         uint32_t table;
 140
 141         if (!zapi_route_notify_decode(zclient->ibuf, &p, &table, &note))
 142                 return -1;
 143
 144         installed_routes++;
 145
 146         if (total_routes == installed_routes)
 147                 zlog_debug("Installed All Items");
 148         return 0;
 149 }
 150
 151 static void zebra_connected(struct zclient *zclient)
 152 {
 153         zclient_send_reg_requests(zclient, VRF_DEFAULT);
 154 }
 155
 156 void vrf_label_add(vrf_id_t vrf_id, afi_t afi, mpls_label_t label)
 157 {
 158         zclient_send_vrf_label(zclient, vrf_id, afi, label, ZEBRA_LSP_SHARP);
 159 }
 160
 161 void route_add(struct prefix *p, struct nexthop *nh)
 162 {
 163         struct zapi_route api;
 164         struct zapi_nexthop *api_nh;
 165
 166         memset(&api, 0, sizeof(api));
 167         api.vrf_id = VRF_DEFAULT;
 168         api.type = ZEBRA_ROUTE_SHARP;
 169         api.safi = SAFI_UNICAST;
 170         memcpy(&api.prefix, p, sizeof(*p));
 171
 172         SET_FLAG(api.flags, ZEBRA_FLAG_ALLOW_RECURSION);
 173         SET_FLAG(api.message, ZAPI_MESSAGE_NEXTHOP);
 174
 175         api_nh = &api.nexthops[0];
 176         api_nh->vrf_id = VRF_DEFAULT;
 177         api_nh->gate.ipv4 = nh->gate.ipv4;
 178         api_nh->type = nh->type;
 179         api_nh->ifindex = nh->ifindex;
 180         api.nexthop_num = 1;
 181
 182         zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
 183 }
 184
 185 void route_delete(struct prefix *p)
 186 {
 187         struct zapi_route api;
 188
 189         memset(&api, 0, sizeof(api));
 190         api.vrf_id = VRF_DEFAULT;
 191         api.type = ZEBRA_ROUTE_SHARP;
 192         api.safi = SAFI_UNICAST;
 193         memcpy(&api.prefix, p, sizeof(*p));
 194         zclient_route_send(ZEBRA_ROUTE_DELETE, zclient, &api);
 195
 196         return;
 197 }
 198
 199 extern struct zebra_privs_t sharp_privs;
 200
 201 void sharp_zebra_init(void)
 202 {
 203         struct zclient_options opt = {.receive_notify = true};
 204
 205         zclient = zclient_new_notify(master, &opt);
 206
 207         zclient_init(zclient, ZEBRA_ROUTE_SHARP, 0, &sharp_privs);
 208         zclient->zebra_connected = zebra_connected;
 209         zclient->interface_add = interface_add;
 210         zclient->interface_delete = interface_delete;
 211         zclient->interface_up = interface_state_up;
 212         zclient->interface_down = interface_state_down;
 213         zclient->interface_address_add = interface_address_add;
 214         zclient->interface_address_delete = interface_address_delete;
 215         zclient->route_notify_owner = route_notify_owner;
 216 }