zebra/zebra_srv6.c

   1 /*
   2  * Zebra SRv6 definitions
   3  * Copyright (C) 2020  Hiroki Shirokura, LINE Corporation
   4  * Copyright (C) 2020  Masakazu Asama
   5  *
   6  * This program 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 Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #include "network.h"
  24 #include "prefix.h"
  25 #include "stream.h"
  26 #include "srv6.h"
  27 #include "zebra/debug.h"
  28 #include "zebra/zapi_msg.h"
  29 #include "zebra/zserv.h"
  30 #include "zebra/zebra_router.h"
  31 #include "zebra/zebra_srv6.h"
  32 #include "zebra/zebra_errors.h"
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <stdlib.h>
  36 #include <arpa/inet.h>
  37 #include <netinet/in.h>
  38
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <stdlib.h>
  42 #include <arpa/inet.h>
  43 #include <netinet/in.h>
  44
  45
  46 DEFINE_MGROUP(SRV6_MGR, "SRv6 Manager");
  47 DEFINE_MTYPE_STATIC(SRV6_MGR, SRV6M_CHUNK, "SRv6 Manager Chunk");
  48
  49 /* define hooks for the basic API, so that it can be specialized or served
  50  * externally
  51  */
  52
  53 DEFINE_HOOK(srv6_manager_client_connect,
  54             (struct zserv *client, vrf_id_t vrf_id),
  55             (client, vrf_id));
  56 DEFINE_HOOK(srv6_manager_client_disconnect,
  57             (struct zserv *client), (client));
  58 DEFINE_HOOK(srv6_manager_get_chunk,
  59             (struct srv6_locator **loc,
  60              struct zserv *client,
  61              const char *locator_name,
  62              vrf_id_t vrf_id),
  63             (loc, client, locator_name, vrf_id));
  64 DEFINE_HOOK(srv6_manager_release_chunk,
  65             (struct zserv *client,
  66              const char *locator_name,
  67              vrf_id_t vrf_id),
  68             (client, locator_name, vrf_id));
  69
  70 /* define wrappers to be called in zapi_msg.c (as hooks must be called in
  71  * source file where they were defined)
  72  */
  73
  74 void srv6_manager_client_connect_call(struct zserv *client, vrf_id_t vrf_id)
  75 {
  76         hook_call(srv6_manager_client_connect, client, vrf_id);
  77 }
  78
  79 void srv6_manager_get_locator_chunk_call(struct srv6_locator **loc,
  80                                          struct zserv *client,
  81                                          const char *locator_name,
  82                                          vrf_id_t vrf_id)
  83 {
  84         hook_call(srv6_manager_get_chunk, loc, client, locator_name, vrf_id);
  85 }
  86
  87 void srv6_manager_release_locator_chunk_call(struct zserv *client,
  88                                              const char *locator_name,
  89                                              vrf_id_t vrf_id)
  90 {
  91         hook_call(srv6_manager_release_chunk, client, locator_name, vrf_id);
  92 }
  93
  94 int srv6_manager_client_disconnect_cb(struct zserv *client)
  95 {
  96         hook_call(srv6_manager_client_disconnect, client);
  97         return 0;
  98 }
  99
 100 static int zebra_srv6_cleanup(struct zserv *client)
 101 {
 102         return 0;
 103 }
 104
 105 void zebra_srv6_locator_add(struct srv6_locator *locator)
 106 {
 107         struct zebra_srv6 *srv6 = zebra_srv6_get_default();
 108         struct srv6_locator *tmp;
 109
 110         tmp = zebra_srv6_locator_lookup(locator->name);
 111         if (!tmp)
 112                 listnode_add(srv6->locators, locator);
 113 }
 114
 115 void zebra_srv6_locator_delete(struct srv6_locator *locator)
 116 {
 117         struct zebra_srv6 *srv6 = zebra_srv6_get_default();
 118
 119         listnode_delete(srv6->locators, locator);
 120 }
 121
 122 struct srv6_locator *zebra_srv6_locator_lookup(const char *name)
 123 {
 124         struct zebra_srv6 *srv6 = zebra_srv6_get_default();
 125         struct srv6_locator *locator;
 126         struct listnode *node;
 127
 128         for (ALL_LIST_ELEMENTS_RO(srv6->locators, node, locator))
 129                 if (!strncmp(name, locator->name, SRV6_LOCNAME_SIZE))
 130                         return locator;
 131         return NULL;
 132 }
 133
 134 struct zebra_srv6 *zebra_srv6_get_default(void)
 135 {
 136         static struct zebra_srv6 srv6;
 137         static bool first_execution = true;
 138
 139         if (first_execution) {
 140                 first_execution = false;
 141                 srv6.locators = list_new();
 142         }
 143         return &srv6;
 144 }
 145
 146 /**
 147  * Core function, assigns srv6-locator chunks
 148  *
 149  * It first searches through the list to check if there's one available
 150  * (previously released). Otherwise it creates and assigns a new one
 151  *
 152  * @param proto Daemon protocol of client, to identify the owner
 153  * @param instance Instance, to identify the owner
 154  * @param session_id SessionID of client
 155  * @param name Name of SRv6-locator
 156  * @return Pointer to the assigned srv6-locator chunk,
 157  *         or NULL if the request could not be satisfied
 158  */
 159 static struct srv6_locator *
 160 assign_srv6_locator_chunk(uint8_t proto,
 161                           uint16_t instance,
 162                           uint32_t session_id,
 163                           const char *locator_name)
 164 {
 165         bool chunk_found = false;
 166         struct listnode *node = NULL;
 167         struct srv6_locator *loc = NULL;
 168         struct srv6_locator_chunk *chunk = NULL;
 169
 170         loc = zebra_srv6_locator_lookup(locator_name);
 171         if (!loc) {
 172                 zlog_info("%s: locator %s was not found",
 173                           __func__, locator_name);
 174
 175                 loc = srv6_locator_alloc(locator_name);
 176                 if (!loc) {
 177                         zlog_info("%s: locator %s can't allocated",
 178                                   __func__, locator_name);
 179                         return NULL;
 180                 }
 181
 182                 loc->status_up = false;
 183                 chunk = srv6_locator_chunk_alloc();
 184                 chunk->proto = 0;
 185                 listnode_add(loc->chunks, chunk);
 186                 zebra_srv6_locator_add(loc);
 187         }
 188
 189         for (ALL_LIST_ELEMENTS_RO((struct list *)loc->chunks, node, chunk)) {
 190                 if (chunk->proto != 0 && chunk->proto != proto)
 191                         continue;
 192                 chunk_found = true;
 193                 break;
 194         }
 195
 196         if (!chunk_found) {
 197                 zlog_info("%s: locator is already owned", __func__);
 198                 return NULL;
 199         }
 200
 201         chunk->proto = proto;
 202         return loc;
 203 }
 204
 205 static int zebra_srv6_manager_get_locator_chunk(struct srv6_locator **loc,
 206                                                 struct zserv *client,
 207                                                 const char *locator_name,
 208                                                 vrf_id_t vrf_id)
 209 {
 210         int ret = 0;
 211
 212         *loc = assign_srv6_locator_chunk(client->proto, client->instance,
 213                                          client->session_id, locator_name);
 214
 215         if (!*loc)
 216                 zlog_err("Unable to assign locator chunk to %s instance %u",
 217                          zebra_route_string(client->proto), client->instance);
 218         else if (IS_ZEBRA_DEBUG_PACKET)
 219                 zlog_info("Assigned locator chunk %s to %s instance %u",
 220                           (*loc)->name, zebra_route_string(client->proto),
 221                           client->instance);
 222
 223         if (*loc && (*loc)->status_up)
 224                 ret = zsend_srv6_manager_get_locator_chunk_response(client,
 225                                                                     vrf_id,
 226                                                                     *loc);
 227         return ret;
 228 }
 229
 230 /**
 231  * Core function, release no longer used srv6-locator chunks
 232  *
 233  * @param proto Daemon protocol of client, to identify the owner
 234  * @param instance Instance, to identify the owner
 235  * @param session_id Zclient session ID, to identify the zclient session
 236  * @param locator_name SRv6-locator name, to identify the actual locator
 237  * @return 0 on success, -1 otherwise
 238  */
 239 static int release_srv6_locator_chunk(uint8_t proto, uint16_t instance,
 240                                       uint32_t session_id,
 241                                       const char *locator_name)
 242 {
 243         int ret = -1;
 244         struct listnode *node;
 245         struct srv6_locator_chunk *chunk;
 246         struct srv6_locator *loc = NULL;
 247
 248         loc = zebra_srv6_locator_lookup(locator_name);
 249         if (!loc)
 250                 return -1;
 251
 252         if (IS_ZEBRA_DEBUG_PACKET)
 253                 zlog_debug("%s: Releasing srv6-locator on %s", __func__,
 254                            locator_name);
 255
 256         for (ALL_LIST_ELEMENTS_RO((struct list *)loc->chunks, node, chunk)) {
 257                 if (chunk->proto != proto ||
 258                     chunk->instance != instance ||
 259                     chunk->session_id != session_id)
 260                         continue;
 261                 chunk->proto = NO_PROTO;
 262                 chunk->instance = 0;
 263                 chunk->session_id = 0;
 264                 chunk->keep = 0;
 265                 ret = 0;
 266                 break;
 267         }
 268
 269         if (ret != 0)
 270                 flog_err(EC_ZEBRA_SRV6M_UNRELEASED_LOCATOR_CHUNK,
 271                          "%s: SRv6 locator chunk not released", __func__);
 272
 273         return ret;
 274 }
 275
 276 static int zebra_srv6_manager_release_locator_chunk(struct zserv *client,
 277                                                     const char *locator_name,
 278                                                     vrf_id_t vrf_id)
 279 {
 280         if (vrf_id != VRF_DEFAULT) {
 281                 zlog_err("SRv6 locator doesn't support vrf");
 282                 return -1;
 283         }
 284
 285         return release_srv6_locator_chunk(client->proto, client->instance,
 286                                           client->session_id, locator_name);
 287 }
 288
 289 /**
 290  * Release srv6-locator chunks from a client.
 291  *
 292  * Called on client disconnection or reconnection. It only releases chunks
 293  * with empty keep value.
 294  *
 295  * @param proto Daemon protocol of client, to identify the owner
 296  * @param instance Instance, to identify the owner
 297  * @return Number of chunks released
 298  */
 299 int release_daemon_srv6_locator_chunks(struct zserv *client)
 300 {
 301         int ret;
 302         int count = 0;
 303         struct zebra_srv6 *srv6 = zebra_srv6_get_default();
 304         struct listnode *loc_node;
 305         struct listnode *chunk_node;
 306         struct srv6_locator *loc;
 307         struct srv6_locator_chunk *chunk;
 308
 309         if (IS_ZEBRA_DEBUG_PACKET)
 310                 zlog_debug("%s: Releasing chunks for client proto %s, instance %d, session %u",
 311                            __func__, zebra_route_string(client->proto),
 312                            client->instance, client->session_id);
 313
 314         for (ALL_LIST_ELEMENTS_RO(srv6->locators, loc_node, loc)) {
 315                 for (ALL_LIST_ELEMENTS_RO(loc->chunks, chunk_node, chunk)) {
 316                         if (chunk->proto == client->proto &&
 317                             chunk->instance == client->instance &&
 318                             chunk->session_id == client->session_id &&
 319                             chunk->keep == 0) {
 320                                 ret = release_srv6_locator_chunk(
 321                                                 chunk->proto, chunk->instance,
 322                                                 chunk->session_id, loc->name);
 323                                 if (ret == 0)
 324                                         count++;
 325                         }
 326                 }
 327         }
 328
 329         if (IS_ZEBRA_DEBUG_PACKET)
 330                 zlog_debug("%s: Released %d srv6-locator chunks",
 331                            __func__, count);
 332
 333         return count;
 334 }
 335
 336 void zebra_srv6_init(void)
 337 {
 338         hook_register(zserv_client_close, zebra_srv6_cleanup);
 339         hook_register(srv6_manager_get_chunk,
 340                       zebra_srv6_manager_get_locator_chunk);
 341         hook_register(srv6_manager_release_chunk,
 342                       zebra_srv6_manager_release_locator_chunk);
 343 }
 344
 345 bool zebra_srv6_is_enable(void)
 346 {
 347         struct zebra_srv6 *srv6 = zebra_srv6_get_default();
 348
 349         return listcount(srv6->locators);
 350 }